# Depot vs Namespace for GitHub Actions runners

> Depot vs Namespace for GitHub Actions: a per-minute rate card against unit minutes, converted to the same money, with both cache bills shown.

Source: https://latchkey.dev/learn/runners/depot-vs-namespace  
Updated: 2026-09-21

Depot vs Namespace is hard to read from the two pricing pages because they do not price the same thing: Depot lists a dollar rate per runner minute per size, and Namespace lists a rate per unit minute, where one unit is 1 vCPU with 2 GB of RAM for a minute multiplied by a platform factor. Converted to the same machine, Namespace is cheaper inside a plan and level with Depot outside one.

Depot sells ephemeral EC2 runners that carry a RAM disk in front of the root disk, from 2 GB at 2 vCPU up to 32 GB at 64 vCPU, and a cache its documentation describes at up to 1,000 MiB/s. Usage is tracked by the second with no one-minute minimum, and minutes arrive bundled in a plan, $20 a month with 2,000 GitHub Actions minutes or $200 with 20,000, rather than as a standing free tier.

Namespace sells compute in one currency across devboxes, Docker builds and GitHub Actions runners, and that currency is the unit minute. Runner labels encode the shape rather than picking from a fixed size list, and every rate has two columns: a prepaid rate inside your plan and a higher overage rate once the plan minutes are gone. The $100 Team plan is not a fee on top of the rate, it buys 100,000 unit minutes.

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

## Comparison

|  | Depot | Namespace | Latchkey |
| --- | --- | --- | --- |
| Price per minute, 2 vCPU Linux x64 | $0.006 (2 vCPU, 8 GB RAM, 100 GB disk, 2 GB RAM disk) | $0.004 prepaid or $0.006 overage for the 2 vCPU 8 GB shape; $0.002 prepaid for 2 vCPU with 4 GB | **$0.0025** (2 vCPU, 8 GB RAM, 100 GB disk) |
| Price per minute, 4 vCPU Linux x64 | $0.012 (4 vCPU, 16 GB RAM, 130 GB disk, 4 GB RAM disk) | $0.008 prepaid or $0.012 overage for 4 vCPU with 16 GB; $0.004 prepaid for 4 vCPU with 8 GB | **$0.005** (4 vCPU, 16 GB RAM, 100 GB disk) |
| Free tier | None standalone: 2,000 GitHub Actions minutes with the $20/month Developer plan, 20,000 with the $200/month Startup plan, after a 7-day trial | 30-day free trial of compute, devboxes and runners; the Developer plan is pay as you go with no included minutes | 30-day trial, then 2,000 included minutes a month on Developer, 4,000 on Launch, 6,000 on Scale |
| Billing granularity | Per-second usage tracking, whole minutes billed at the end of the month, no one-minute minimum | Per unit minute: wall-clock minutes multiplied by the shape, then by 1 for Linux, 2 for Windows, 10 for macOS and 7 for Linux on Apple silicon | Per minute |
| Runner sizes and OS | 2 to 64 vCPU on Linux x64 and arm64 (Graviton4); Windows Server 2022 and 2025 from 2 vCPU, with no Hyper-V; macOS at 8 vCPU with 24 GB | Linux amd64 and arm64 to 64 vCPU, Windows to 32 vCPU, macOS on Apple silicon from 4 to 16 vCPU, and Linux on Apple silicon in early access | 2, 4, 8 and 16 vCPU, Ubuntu 24.04 on x86_64 only. arm64, Windows and macOS are not offered |
| Cache: type, limit, persistence | Depot Cache, 25 GB of cache and registry storage included on Developer and 250 GB on Startup, then $0.20/GB/month; entries are not isolated by branch | Cache volumes at $0.002/GB-hour for snapshots and $0.0048/GB-day for storage, with 5,000 GB-hours and 3,000 GB-days free on Team; Turborepo and Gradle caches at $0.2/GB-month; Bazel cache hits at $0.10 per 1,000 | 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 | A RAM disk on every runner, plus remote container builds as a separate product: 16 vCPU and 32 GB by default with 50 GB of NVMe layer cache, expandable to 500 GB | Docker builds are a metered product of their own: $0.05 a build on Developer, 1,000 included on the $100 Team plan and 2,500 on the $250 Business plan, then $10 per 1,000 | `latchkey-dev/docker-cache-action@v1`, layers held in a Latchkey-managed private registry per organization |
| Concurrency limits | Not published | Counted in vCPU rather than jobs: 32 vCPU of Linux on Developer, 64 on Team, 160 on Business, with macOS on a separate ladder of 12, 24 and 48 | Not published; warm-pool capacity varies by plan |
| Where jobs run | Ephemeral EC2 instances in Depot's AWS account, or in your own account on the Business plan | Namespace Compute, on AMD EPYC for amd64 and AmpereOne or Apple silicon for arm64 | 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. The repository must be owned by a GitHub organization | Change the `runs-on` label to a `nscloud-` shape string, adding a suffix when you want a cache volume attached | A `runs-on` label change. GitHub organization accounts only |

## Converting unit minutes into money, once

The comparison only becomes honest after the conversion, so do it once and keep the result. A Namespace compute unit is 1 vCPU and 2 GB of RAM for one minute, times a platform multiplier of 1 for Linux, 2 for Windows and 10 for macOS. A shape with a different ratio is counted as the larger of its vCPU count and its RAM divided by two, which is why a 2 vCPU machine with 8 GB bills as four units and not two.

That last rule is where the two rate cards stop describing the same machine. Depot pairs 4 GB with every vCPU, so its 2 vCPU runner carries 8 GB. Namespace sells both a 4 GB and an 8 GB shape at that core count and prices them differently. Comparing the headline numbers puts Depot's 8 GB machine against Namespace's 4 GB one and flatters Namespace by exactly the memory it left out.

| Machine | Depot | Namespace prepaid | Namespace overage | Latchkey |
| --- | --- | --- | --- | --- |
| 2 vCPU, 8 GB | $0.006 | $0.004 | $0.006 | $0.0025 |
| 4 vCPU, 16 GB | $0.012 | $0.008 | $0.012 | $0.005 |
| 8 vCPU, 32 GB | $0.024 | $0.016 | $0.024 | Published per size, same doubling |
| 16 vCPU, 64 GB | $0.048 | $0.032 | $0.048 | Published per size, same doubling |
| macOS, 6 vCPU with 14 GB | Not sold at that shape: 8 vCPU with 24 GB at $0.08 | $0.06 | $0.09 | Not offered |

> Depot rates from its runner types table; Namespace rates from the Linux and macOS shape tables on its pricing page, both read 21 September 2026. Namespace overage is exactly 1.5 times prepaid at every Linux row, which is the cleanest way to remember it.

## 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 fortnight, because runner selection is per job and the Actions run log hands you the timings for free.

Both vendors do publish a performance claim and neither is a measurement you can reuse. Depot says its runners are up to 3x faster than a GitHub-hosted runner and that its cache is 10x faster. Namespace argues from hardware instead, naming AMD EPYC for amd64 and AmpereOne or Apple silicon for arm64. Neither names the workload, so neither transfers to your test suite.

The number that is yours to measure is the shape of your own job. If it is single-threaded and memory-hungry, buy memory and stop reading rate cards per core. If it shards, buy cores, and see [shard tests across GitHub Actions runners](/learn/speed/shard-tests-across-github-actions-runners) before you buy anything at all, because a matrix change is free and a rate change is not.

## Cost: the same month, then the products on top

The workload every comparison here uses: 10,000 Linux minutes at 2 vCPU plus 2,000 macOS minutes on a private repository. Namespace is shown on the plan that fits, because its plan and its minutes are one purchase rather than two.

|  | 10,000 Linux minutes at 2 vCPU | 2,000 macOS minutes | Monthly total |
| --- | --- | --- | --- |
| Depot | $60 at $0.006/min | $160 at $0.08/min | $220 before plan fees |
| Namespace on Team, 2 vCPU with 8 GB | 40,000 unit minutes | 120,000 unit minutes at the 6 vCPU shape | $190: the $100 plan plus 60,000 overage units at $0.0015 |
| Namespace on Business, same shapes | 40,000 unit minutes | 120,000 unit minutes | $250, with 90,000 units still unused |
| GitHub-hosted | $60 at $0.006/min | $124 at $0.062/min | $184 |
| Latchkey | $25 at $0.0025/min | Not offered: $124 on GitHub-hosted | $149 plus $5 to $49 a month for the plan |

Namespace wins this month outright and the reason is macOS, not Linux. Its 6 vCPU macOS shape prices out at $0.06 a minute inside a plan, below both Depot's $0.08 and GitHub's own $0.062, and macOS is two thirds of this bill. Strip the macOS minutes out and the two are level: 40,000 unit minutes is $60 of overage against Depot's $60, or nothing at all if your plan already covers them. 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.

Then add the second meter each vendor runs, because neither bill stops at runner minutes. On Depot the separate products are container builds at $0.04 a build minute past 500 included, and cache and registry storage at $0.20 per GB per month past the 25 GB the Developer plan includes. On Namespace the second meter is storage shaped: cache volume snapshots at $0.002 per GB-hour, cache volume storage at $0.0048 per GB-day, and Docker builds counted per build rather than per minute.

Work one case to see how differently they scale. Keep 50 GB of cache warm all month. On Depot that is 25 GB of overage at $0.20, which is $5 on top of the $20 plan. On Namespace, 50 GB held for 30 days is 1,500 GB-days at $0.0048, which is $7.20, against 3,000 GB-days free on Team. Small either way, and the shapes diverge fast: Depot's cache bill is flat until you pass an allowance, and Namespace's grows with every gigabyte-day you keep.

## Reliability

Treat uptime as unmeasured. Neither vendor publishes a GitHub Actions SLA on the pages read here, so the useful comparison is the limits each one does publish, and Namespace publishes more of them. Concurrency is capped by plan and denominated in vCPU: 32 on Developer, 64 on Team, 160 on Business. A single job is capped at 3 hours on Developer and 5 on Team, against GitHub's 6. Depot publishes neither number.

A cap counted in vCPU is easy to misread, and it is the one to check before widening a matrix, because bigger runners and wider matrices draw on the same budget. Sixty-four vCPU on Team is thirty-two 2 vCPU jobs at once, or eight 8 vCPU ones, not both.

What neither addresses is the job that dies for a mechanical reason at minute nine: a registry timeout, a base image pull rate limit, an out-of-memory kill. That run bills, the re-run bills, and the merge waits for a person to notice. [Docker Hub pull rate limit](/learn/failures/docker-hub-pull-rate-limit-in-ci) is the one that hits container-heavy pipelines hardest.

## When to choose Depot

- Your bill is Linux and your usage is spiky. Per-second tracking with no one-minute minimum removes rounding that a nominally lower rate does not, and a thousand 40-second jobs is where that shows up.
- You build container images and want them off the runner. A 16 vCPU remote builder with 50 GB of NVMe layer cache means a 2 vCPU runner can drive a large build.
- You build amd64 and arm64 from one workflow and want both native rather than one of them under emulation.
- You would rather learn one rate card than a unit-minute conversion, a multiplier table and two plan tiers before you can forecast a month.
- One caveat before you commit: Depot documents that its Windows runners have no Hyper-V on EC2, so Docker on Windows is unlikely to work there.

## When to choose Namespace

- Your bill is mostly macOS. At $0.06 a minute prepaid for a 6 vCPU machine, Namespace is the only vendor in this corpus that undercuts GitHub-hosted macOS, and that is worth more than any Linux rate if your pipeline builds iOS.
- You can forecast usage well enough to sit inside a plan. Prepaid is a third below overage at every Linux row, and the gap is the whole argument for committing.
- You want cores rather than memory. At matched spend Namespace sells twice the vCPU that Depot does, which is a real advantage on parallel work and none at all on a single-threaded build.
- You already run Bazel, Turborepo or Gradle remote caches and would rather buy them from the vendor that runs your compute than wire up a second service.
- Note the trade: the label is a shape string rather than a size name, cache volumes are attached by suffix, and the bill arrives in unit minutes, so somebody on your team has to hold the conversion in their head.

## Switching: the exact diff

Both are `runs-on` changes and nothing else, which is the honest reason to test rather than argue. Depot names a size; Namespace names a shape, and adds a suffix when you want a cache volume attached to the runner. Runner selection is per job, so point one slow job at each for a fortnight and compare two real invoices.

```.github/workflows/ci.yml
jobs:
   test-on-depot:
-    runs-on: ubuntu-latest
+    runs-on: depot-ubuntu-24.04-4
     steps:
       - uses: actions/checkout@v7
       - run: npm ci && npm test

   test-on-namespace:
-    runs-on: ubuntu-latest
+    runs-on: nscloud-ubuntu-24.04-amd64-4x16
     steps:
       - uses: actions/checkout@v7
       - run: npm ci && npm test
```

> Both labels name a 4 vCPU machine with 16 GB, which is the smallest pair of shapes the two vendors both sell, so the two jobs are comparable. Add the cache-volume suffix to the Namespace label only after you have a baseline without it, or you will not know which change moved the timing.

## The verdict

Namespace is the better buy for most teams that can commit to a plan, and the margin comes from two places rather than one: prepaid Linux rates a third below overage, and a macOS minute that undercuts GitHub itself. Depot earns its money somewhere else entirely. If your problem is that a container build has outgrown the runner driving it, a remote 16 vCPU builder with a persistent NVMe layer cache is a real answer and a cheaper runner minute is not. The per-second tracking is worth more than it looks on a pipeline of very short jobs, and the single rate card is worth something to a team that does not want to maintain a conversion. Neither of them notices that the job died because a registry timed out, repairs it and carries on, and on a pipeline with a thousand jobs a month that quiet line is larger than the gap between these two rate cards.

## FAQ

### What are Namespace unit minutes?

A unit minute is 1 vCPU with 2 GB of RAM running for one minute, multiplied by a platform factor of 1 for Linux, 2 for Windows and 10 for macOS. A shape whose ratio is not 1 vCPU to 2 GB counts as the larger of its vCPU count and its RAM divided by two. A 4 vCPU Linux instance for 5 minutes is 20 unit minutes; a 6 vCPU macOS instance for 3 minutes is 180.

### Is Namespace cheaper than Depot?

At matched memory, yes inside a plan and level outside one. Namespace lists $0.004 a minute prepaid and $0.006 overage for a 2 vCPU 8 GB shape; Depot lists $0.006 for the same machine. The prepaid column assumes you have bought a plan, and the Namespace plan and its minutes are one purchase rather than a fee plus a rate.

### Does Depot or Namespace support macOS runners?

Both do, at different shapes and different prices. Depot sells one macOS size, 8 vCPU with 24 GB and 400 GB of disk at $0.08 a minute, on macOS 14, 15 and 26. Namespace sells Apple silicon from 4 to 16 vCPU, where a 6 vCPU machine with 14 GB is $0.06 prepaid or $0.09 overage. Latchkey sells neither.

### How do I estimate a Namespace bill before switching?

Multiply your monthly runner minutes by the shape you intend to use, then by the platform factor, and compare the total against the 100,000 unit minutes on Team or 250,000 on Business. Anything past the plan is $0.0015 a unit. Do the macOS arithmetic first, because a 10x multiplier means a small number of macOS minutes can be most of the bill.

## References

- [Namespace pricing: unit minutes, multipliers and shape tables (verified 2026-09-21)](https://namespace.so/pricing)
- [Namespace runner labels, shapes and cache volumes (verified 2026-09-21)](https://namespace.so/docs/reference/github-actions/runner-configuration)
- [Depot GitHub Actions runner types and per-minute prices (verified 2026-09-21)](https://depot.dev/docs/github-actions/runner-types)
- [Depot pricing: plans, included usage and overage rates (verified 2026-09-21)](https://depot.dev/pricing)

---

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