# Namespace vs Blacksmith for GitHub Actions runners

> Namespace vs Blacksmith on GitHub Actions runners: the rate looks lower until you match the RAM. Prices, shapes, cache volumes and billing read today.

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

Namespace vs Blacksmith looks like a price win for Namespace at $0.002 a minute against $0.004, until you notice that Namespace's 2 vCPU shape carries 4 GB of RAM and Blacksmith's carries 8 GB. Match the memory and they are level at $0.004 prepaid, so the real decision is prepaid commitment and cache volumes against a standing free tier and a simpler bill.

Namespace sells compute across devboxes, builds and GitHub Actions runners, with a label grammar rather than a fixed size list: `nscloud-{os}-{arch}-{shape}`, with suffixes that attach a cache volume or extra features. Rates come in two columns, a prepaid rate inside your plan and a higher overage rate outside it, which rewards teams that can forecast their usage.

Blacksmith sells one thing, managed GitHub Actions runners on its own bare metal, at a single published rate per platform with 3,000 free minutes a month and no plan to pick. It is the simpler purchase, and the simplicity is most of what you are buying.

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

|  | Namespace | Blacksmith | Latchkey |
| --- | --- | --- | --- |
| Price per minute, 2 vCPU Linux x64 | $0.002 prepaid, $0.003 overage (2 vCPU, 4 GB RAM) | $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.004 prepaid, $0.006 overage (4 vCPU, 8 GB RAM) | $0.008 (4 vCPU, 16 GB RAM, 80 GB disk) | **$0.005** (4 vCPU, 16 GB RAM, 100 GB disk) |
| Free tier | A 30-day trial on the pay-as-you-go Developer plan; no standing monthly free minutes | 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 | A one-minute minimum, then each following 15 seconds rounded down | Not published | Per minute |
| Runner sizes and OS | Shapes 2x4 through 32x64 on amd64 and arm64; Windows Server 2022 on amd64; macOS arm64 images from Sonoma to Tahoe; disk not published | 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 | Tagged cache volumes attached with a label suffix; 20 GB by default, up to 50 GB on Team and 100 GB on Business; snapshots at $0.002/GB-hr with 5,000 GB-hr free on Team | Colocated cache intercepts `actions/cache`, 25 GB free per repo per week; 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 | Remote builders are on by default; the docs tell you to remove `docker/setup-buildx-action` so it does not override them | `useblacksmith/setup-docker-builder@v2` and `useblacksmith/build-push-action@v2`, with layers on a persistent sticky disk | `latchkey-dev/docker-cache-action@v1`, layers held in a Latchkey-managed private registry per organization |
| Concurrency limits | Published per plan, and counted in vCPU: 32 on Developer, 64 on Team, 160 on Business for Linux; 12, 24 and 48 for macOS. A single job is capped at 3 hours on Developer and 5 on Team | None imposed, per the runner docs | Not published; warm-pool capacity varies by plan |
| Where jobs run | Namespace Compute, on AMD EPYC for amd64 and AmpereOne or Apple silicon for arm64 | 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 | Not offered | Built in: transient failures are diagnosed and retried inside the run |
| Setup change required | Change the `runs-on` label, and append `-with-cache` plus a cache tag label to attach a cache volume | Install the GitHub App, then change the `runs-on` label | A `runs-on` label change. GitHub organization accounts only |

## Match the memory before you compare the rate

Namespace prices by machine shape, and its shapes pair 2 GB of RAM with each vCPU. Blacksmith pairs 4 GB with each vCPU on x64. That means the two rate cards are not describing the same machine at the same row, and a straight 2 vCPU comparison flatters Namespace by exactly the amount of memory it left out.

Lined up by memory instead of by core count, the published Linux rates read like this: 8 GB costs $0.004 prepaid or $0.006 overage on Namespace (a 4x8 shape), $0.004 on Blacksmith (a 2 vCPU runner) and $0.0025 on Latchkey. 16 GB costs $0.008 prepaid on Namespace, $0.008 on Blacksmith and $0.005 on Latchkey. Namespace and Blacksmith are level at matched memory, and Namespace gives you twice the cores for the same money at that point, which is a real advantage on parallel work and no advantage at all on a single-threaded build.

Which framing is right depends on your jobs. If your test suite is memory-hungry and single-threaded, buy memory and Blacksmith is straightforwardly cheaper per gigabyte. If it shards cleanly, buy cores and Namespace is ahead.

## 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.

What you will find elsewhere is each vendor's own figure, measured on a workload the vendor chose. Those numbers are not wrong, but they are not comparable to each other, and none of them is your repository. The cheap way to get a real answer is to point one slow job at each candidate for a week: runner selection is per job, so three jobs in the same workflow file can run on three providers, and the Actions run log gives you the timings for free.

## Cost: the same month, priced three ways

The usual month, 10,000 Linux minutes and 2,000 macOS minutes. Namespace is shown on a 2 vCPU 4 GB shape, which is its best case, and then again at 8 GB so the machines match.

|  | 10,000 Linux minutes | 2,000 macOS minutes | Monthly total |
| --- | --- | --- | --- |
| Namespace, 2 vCPU 4 GB | 10,000 min at multiplier 2 = 20,000 unit minutes | 2,000 min at multiplier 60 = 120,000 unit minutes | **$160**: the $100 Team plan covers 100,000 of the 140,000, and the 40,000 over it bill at $0.0015 |
| Namespace, 4 vCPU 8 GB | 10,000 min at multiplier 4 = 40,000 unit minutes | 2,000 min at multiplier 60 = 120,000 unit minutes | **$190**: 160,000 unit minutes, so 60,000 over the plan at $0.0015 is $90 on top of the $100 |
| Blacksmith, 2 vCPU 8 GB | $28 after 3,000 free minutes | $160 at $0.08/min | $188 |
| Latchkey, 2 vCPU 8 GB | $25 at $0.0025/min | Not offered: $124 on GitHub-hosted | $149 plus $5 to $49 a month for the plan |

Namespace does not bill minutes, it bills unit minutes, which are wall-clock minutes multiplied by the shape: a 2 vCPU Linux runner counts 2, a 4 vCPU one counts 4, and the 6 vCPU macOS runner counts 60, because macOS carries a 10x platform multiplier on top of its cores. The $100 Team plan is not a fee on top of the rate, it buys 100,000 of those unit minutes, and anything past them is $0.0015 each. That is why the two Namespace rows land at $160 and $190 rather than at the arithmetic you would do for a flat-rate vendor: the plan and the minutes are one purchase, not two. Below 100,000 unit minutes a month the Team plan is the whole bill, which makes Namespace cheapest here by a wide margin; past it the effective rate creeps back toward the $0.0015 overage.

Namespace is also the only vendor here that is cheaper per macOS minute than GitHub-hosted, at $0.06 prepaid against $0.062. If your bill is mostly macOS, that is worth more than any Linux rate on this page. 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.

## Reliability

Neither publishes a runner SLA on the pages read here, but both publish a concurrency position and the two are opposites. Blacksmith states it imposes no limit at all on simultaneous jobs or vCPUs. Namespace caps it by plan and counts it in vCPU rather than jobs: 32 vCPU of Linux concurrency on Developer, 64 on Team, 160 on Business, with macOS on its own ladder of 12, 24 and 48.

A cap denominated in vCPU is easy to misread, and it is the number to check before you widen a matrix. Namespace's 64 vCPU on Team is thirty-two 2 vCPU jobs at once, or eight 8 vCPU ones, so making runners bigger and making the matrix wider draw on the same budget. Namespace also caps a single job at 3 hours on Developer and 5 on Team, against GitHub's 6, which matters for long integration suites.

Both are silent on failure handling, which is the honest answer for both: a job that dies on a registry timeout or an out-of-memory kill fails, bills, and waits. The one operational difference worth knowing is Blacksmith's capacity model, where runners are provisioned for repositories that have the GitHub App installed, so a repository using `blacksmith-*` labels without the app can quietly starve the pool for everyone else.

## When to choose Namespace

- You can forecast usage and commit to a plan, so the prepaid rate is the rate you actually pay rather than the one on the marketing page.
- Your jobs parallelise. At matched memory you get twice the cores for the same money.
- Your bill is macOS-heavy: $0.06 prepaid per macOS minute is the lowest on this page and below GitHub-hosted.
- You want cache volumes you control by tag and size, up to 100 GB on Business, rather than a fixed per-repo allowance.
- You are buying more than runners. Devboxes, container builds and Bazel remote caching come off the same plan and the same balance.

## When to choose Blacksmith

- You want one rate, no plan decision and no commitment: $0.004 a Linux minute with 3,000 free minutes a month, and an overage rate that does not exist because there is no plan to exceed.
- Your jobs need memory more than cores. 8 GB at 2 vCPU against Namespace's 4 GB is the difference between a build that completes and one that gets [killed by the kernel](/learn/failures/exit-code-137-in-github-actions).
- You want arm64 at $0.0025/min, which is the lowest published arm64 rate in this comparison.
- Your cache story is `actions/cache` and you want it transparently faster with no workflow edits, rather than a volume you attach and size yourself.

## Switching: the exact diff

Both are label changes. Namespace encodes the shape in the label and needs an extra suffix before a cache volume is attached, so the diff is slightly wordier; Blacksmith needs the GitHub App installed on each repository that uses its labels.

```.github/workflows/ci.yml
jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: nscloud-ubuntu-24.04-amd64-4x8-with-cache

   build:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2404
```

## The verdict

The headline rate says Namespace is half the price and the machine specification says they are level, so the tiebreak is what kind of buyer you are. If you can commit to a plan, want cores rather than memory, and are willing to learn a label grammar and a cache-volume model, Namespace is genuinely cheaper and sells you macOS below GitHub-hosted price, which nobody else here does. If you want a rate you can quote without a footnote, 3,000 free minutes to start on, and 8 GB of RAM at the smallest size, Blacksmith is the easier purchase and the better memory-per-dollar. Neither of them repairs a failed job, and at these rates the re-runs you are already paying for are a bigger number than the gap between the two.

## FAQ

### Is Namespace cheaper than Blacksmith?

Per vCPU, yes; per gigabyte of RAM, no. Namespace lists $0.002/min prepaid for a 2 vCPU 4 GB shape and Blacksmith lists $0.004/min for a 2 vCPU 8 GB runner. At matched 8 GB the Namespace shape is 4x8 at $0.004 prepaid, which is level with Blacksmith and twice the cores. Namespace's prepaid rate also assumes a plan; its overage rate is 50% higher.

### Which GitHub Actions services let you run jobs on faster hardware without self-hosting?

Namespace, Blacksmith, Depot, RunsOn, WarpBuild, Ubicloud and Latchkey all sell managed runners you adopt with a `runs-on` change, and GitHub sells larger runners up to 96 vCPU. All of them exist because the standard private-repo Linux runner is 2 vCPU with 8 GB of RAM and 14 GB of disk, and plenty of builds outgrew that years ago.

### How do Namespace cache volumes differ from Blacksmith sticky disks?

Namespace cache volumes are attached by adding a suffix and a tag to the runner label, default to 20 GB, and cap at 50 GB on Team or 100 GB on Business, with snapshot storage billed per GB-hour. Blacksmith sticky disks are ext4 volumes mounted by an action, up to 5 per job, billed at $0.50/GB/month and evicted after 7 days without use. Blacksmith also transparently redirects `actions/cache` to a colocated cache with 25 GB free per repo per week, which needs no workflow change at all.

### Does either of them retry a job that failed for a transient reason?

Neither publishes automatic detection and repair of transient failures. Both will run your job on faster hardware, and both will bill you for the run that died on a DNS blip and again for the re-run. That is the gap Latchkey is built around, and it is a different axis from speed or price.

## References

- [Namespace pricing, prepaid and overage rates by shape](https://namespace.so/pricing)
- [Namespace runner labels, shapes and cache volumes](https://namespace.so/docs/reference/github-actions/runner-configuration)
- [Blacksmith pricing](https://www.blacksmith.sh/pricing)
- [Blacksmith runner instance types](https://docs.blacksmith.sh/blacksmith-runners/overview)
- [GitHub Actions per-minute rates and minute multipliers](https://docs.github.com/en/billing/reference/actions-minute-multipliers)

---

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