# Latchkey vs Blacksmith for GitHub Actions runners

> Latchkey vs Blacksmith on price, cache, runner sizes and free minutes, read from both pricing pages, with the arm64 gap stated plainly.

Source: https://latchkey.dev/learn/runners/latchkey-vs-blacksmith  
Updated: 2026-09-22

Latchkey and Blacksmith both replace `ubuntu-latest` with a one-line `runs-on` change and both bill per minute, so the choice comes down to three things: the rate, what you need beyond Linux x64, and whether a failed job costs you a re-run. Latchkey is $0.0025 a minute at 2 vCPU against Blacksmith at $0.004, and Blacksmith ships arm64, Windows and macOS runners plus 3,000 free minutes a month, none of which Latchkey has.

Blacksmith sells managed GitHub Actions runners on its own hardware in Ashburn, Phoenix, Amsterdam and Frankfurt, adopted by installing a GitHub App and changing `runs-on` to a label such as `blacksmith-4vcpu-ubuntu-2404`. It publishes $0.004 a minute at 2 vCPU with 8 GB and an 80 GB disk, 3,000 free minutes a month on every plan, a colocated cache that intercepts `actions/cache` with 25 GB free per repository per week, and sticky disks for Docker layer reuse.

Latchkey sells managed runners the same way and at $0.0025 a minute for the same 2 vCPU and 8 GB, on a 100 GB disk, with a self-healing agent that diagnoses and retries transient failures inside the run rather than handing them back red. It is missing things Blacksmith has shipped for a while: no arm64, no Windows, no macOS, and no free monthly allowance outside the trial and the plan tiers.

Every cell below was read from the vendor's own public pricing or documentation page on 20 September 2026. Where a vendor does not publish a number, the cell says "not published" instead of carrying a guess.

## Comparison

|  | Blacksmith | Latchkey |
| --- | --- | --- |
| Price per minute, 2 vCPU Linux x64 | $0.004 (2 vCPU, 8 GB RAM, 80 GB disk) | **$0.0025** (2 vCPU, 8 GB RAM, 100 GB disk) |
| Price per minute, 4 vCPU Linux x64 | $0.008 (4 vCPU, 16 GB RAM, 80 GB disk) | **$0.005** (4 vCPU, 16 GB RAM, 100 GB disk) |
| Free tier | 3,000 free minutes a month, printed on every runner card | 30-day trial, then 2,000 included minutes a month on Developer, 4,000 on Launch, 6,000 on Scale |
| Billing granularity | Not published | Per minute |
| Runner sizes and OS | 2 to 32 vCPU on Linux x64 and arm64; Windows Server 2025 at 2 to 32 vCPU in public beta; macOS M4 at 6 and 12 vCPU | 2, 4, 8 and 16 vCPU, Ubuntu 24.04 on x86_64 only. arm64, Windows and macOS are not offered |
| Cache: type, limit, persistence | Colocated cache intercepts `actions/cache`, [25 GB free per repo per week](https://docs.blacksmith.sh/blacksmith-caching/dependencies-actions); sticky disks are ext4 volumes, 5 per job, evicted after 7 days idle, $0.50/GB/month | Size not published. `latchkey-dev/cache-action@v1` swaps one line for `actions/cache`, keeping `path`, `key` and `restore-keys`; entries are isolated per organization, versioned by OS, kept 14 days; a failed restore warns rather than failing the job |
| Docker build acceleration | `useblacksmith/setup-docker-builder@v2` and `useblacksmith/build-push-action@v2`; layers sit on a sticky disk per cache key, garbage-collected after 8 days unused | `latchkey-dev/docker-cache-action@v1`, layers held in a Latchkey-managed private registry per organization |
| Concurrency limits | None imposed, per the runner docs | Not published; warm-pool capacity varies by plan |
| Where jobs run | Blacksmith's own regions: Ashburn, Phoenix, Amsterdam and Frankfurt | Latchkey's own AWS estate on m6a-class hosts, one job per runner, private network, destroyed after the job |
| Self-healing or retries | Not offered | Built in: transient failures are diagnosed and retried inside the run |
| Setup change required | Install the GitHub App, then change the `runs-on` label to `blacksmith-4vcpu-ubuntu-2404` | A `runs-on` label change. GitHub organization accounts only |

## Where Blacksmith wins, before anything else

Blacksmith covers hardware Latchkey does not sell at all. arm64 is generally available at every size from 2 to 32 vCPU, Windows Server 2025 is in public beta across the same range, and macOS M4 runners come at 6 and 12 vCPU. If any job in your matrix is `runs-on: macos-latest` or builds an arm64 image, Latchkey cannot take it and Blacksmith can. That is not a rate you can argue with, it is a capability gap.

Blacksmith also prints 3,000 free minutes a month on every plan. Latchkey has a 30-day trial and then an included allowance that depends on tier, from 2,000 minutes on Developer to 6,000 on Scale, so a small repository that fits inside 3,000 minutes runs on Blacksmith for nothing and on Latchkey for the plan fee.

The cache story is more even than the price suggests. Blacksmith publishes a hard number, 25 GB free per repository per week, and Latchkey does not publish a size at all. A published limit you can plan against is worth more than an unpublished one you have to discover.

## Where Latchkey wins

On the size most CI actually runs, Latchkey is 37.5% cheaper: $0.0025 a minute against $0.004 at 2 vCPU and 8 GB, and $0.005 against $0.008 at 4 vCPU. Latchkey also gives a 100 GB disk at both sizes where Blacksmith gives 80 GB, which matters on Docker-heavy jobs that fill the runner before they finish.

The substantive difference is what happens when a job fails for a reason that has nothing to do with your code. A registry timeout, an OOM kill, an apt lock, a flaky network mount: on Blacksmith that run goes red and somebody clicks re-run. On Latchkey the agent on the machine diagnoses the failing step, applies the fix and retries it inside the same run, so the failure never reaches your team. Blacksmith does not offer this and does not claim to.

## Speed

Not benchmarked yet; the runner benchmark report will replace this section. We have not run the same workload on these runners ourselves, and until we have, there is no number here worth quoting.

The cheap way to get a real answer is to point one slow job at each candidate for a week, because runner selection is per job and the Actions run log gives you the timings for free.

## Cost: one worked month

Take 10,000 Linux minutes a month at 2 vCPU on a private repository, the shape most teams land on once they move off `ubuntu-latest`. On Blacksmith that is $40 at $0.004 a minute, less the 3,000 free minutes, so $28. On Latchkey it is $25 at $0.0025 a minute, less the included allowance on your tier, so between $20 on Developer and $10 on Scale.

Latchkey's own plan is $5 to $49 a month on top of that compute, and its 2,000 to 6,000 included minutes are not netted off, so the figure is gross on both counts.

The gap at this volume is real but small in absolute terms, which is the honest read: at 10,000 minutes you are choosing between roughly $28 and roughly $25 plus a plan fee. The rate difference only compounds into real money above about 50,000 minutes a month, and below 3,000 minutes Blacksmith is simply free and Latchkey is not.

## Reliability

Neither vendor publishes an uptime SLA on its public pricing page, so there is nothing to compare there and this page is not going to invent one. Blacksmith imposes no concurrency limit per its runner docs; Latchkey does not publish a limit and its warm-pool capacity varies by plan, which is a weaker answer.

The difference that is documented is failure handling. Blacksmith gives you the same red build GitHub-hosted would. Latchkey repairs the transient class of failure on the runner and reports what it did, which is the reason to pay for it over a cheaper rate somewhere else.

## When to choose Blacksmith

Choose Blacksmith if any part of your matrix is arm64, Windows or macOS, because Latchkey has no answer for those and a split provider setup costs you the simplicity you were buying. Choose it if you are under 3,000 minutes a month, where its free tier beats any per-minute rate. Choose it if you want a published cache limit to plan capacity against, or if your builds depend on layer reuse across runs and sticky disks already work for you.

## When to choose Latchkey

Choose Latchkey if your CI is Linux x64 and your volume is high enough that a 37.5% rate difference is worth having, or if the thing costing you most is not the bill but the re-runs. If your team loses an hour a week to builds that failed on a registry timeout and went green on retry, the agent that repairs those in-run is the product, and the rate is a bonus.

## Switching

Switching is a label change on the jobs you choose, not a migration. Leave the rest of the workflow alone, move one slow job first, and read the timings out of the run log before you move the others.

```One job, moved from Blacksmith to Latchkey
jobs:
  build:
-   runs-on: blacksmith-4vcpu-ubuntu-2404
+   runs-on: latchkey-medium
    steps:
      - uses: actions/checkout@v4
```

## The verdict

If your matrix is Linux x64 only and you run enough minutes for the rate to matter, Latchkey is the cheaper machine and the only one of the two that repairs a transient failure instead of handing it back. If you build for arm64, Windows or macOS, or you fit inside 3,000 minutes a month, Blacksmith wins on coverage and on free allowance and the rate difference never gets a chance to pay you back. Most teams know which of those they are without running a trial.

## FAQ

### Is Latchkey cheaper than Blacksmith?

On Linux x64 at the two sizes both vendors publish, yes: $0.0025 a minute against $0.004 at 2 vCPU, and $0.005 against $0.008 at 4 vCPU. Below roughly 3,000 minutes a month Blacksmith is cheaper in practice, because its 3,000 free minutes cover the whole bill and Latchkey still charges a plan fee.

### Does Latchkey have arm64 runners like Blacksmith?

No. Latchkey runs Ubuntu 24.04 on x86_64 only, at 2, 4, 8 and 16 vCPU. Blacksmith publishes arm64 from 2 to 32 vCPU, Windows Server 2025 in public beta, and macOS M4 at 6 and 12 vCPU. An arm64 or macOS job cannot move to Latchkey.

### What does Blacksmith do about failed builds?

Nothing beyond what GitHub Actions already does. A transient failure produces a red run and somebody re-runs it. That is the gap Latchkey self-healing fills: the agent diagnoses the failing step on the runner and retries it inside the same run.

### How much work is it to move from Blacksmith to Latchkey?

A label change per job, plus swapping `actions/cache` for `latchkey-dev/cache-action@v1` if you want the dependency cache. Both products are a `runs-on` value and a GitHub App, so nothing else in the workflow file moves. Jobs that need arm64, Windows or macOS have to stay where they are.

## References

- [Blacksmith pricing](https://www.blacksmith.sh/pricing)
- [Blacksmith: caching dependencies with actions/cache](https://docs.blacksmith.sh/blacksmith-caching/dependencies-actions)
- [Latchkey pricing](https://latchkey.dev/pricing)
- [GitHub: about billing for GitHub Actions](https://docs.github.com/en/billing/managing-billing-for-your-products/about-billing-for-github-actions)

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt