Namespace vs GitHub Codespaces
Namespace is a build platform: fast GitHub Actions runners with caches, plus Devboxes on Linux, macOS and Windows that stop after 4 to 24 hours by plan. GitHub Codespaces is a Linux dev container you open from a repository in VS Code or the browser, and it stops after 12 hours at most.
The companies and products
Namespace
Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.
Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents, and they also host sessions for Claude Managed Agents, Cursor Cloud Agents and Devin. It is a different kind of product from bochka, so this page compares the part where they overlap: a machine an agent works on.
- Products
- GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
- Hardware
- Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
- Linux Devboxes
- Run from a container image you choose and include Docker; the docs do not say whether each one has its own kernel
- Funding
- Announced a $42M Series B
- Compliance
- Trust center lists SOC 2 Type II
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from bochka: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “80th cheapest of 377” means 79 of the other 376 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Namespace: price rank | GitHub Codespaces: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both give an agent Docker, but Codespaces documents no /dev/kvm and Namespace offers it on Linux compute instances only; bochka has Docker, systemd and /dev/kvm on every machine. | 39th of 367, with limits $3,495 a month | 274th of 367, with limits $4,618 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops gets cut off on both, at the Devbox plan limit on Namespace and at 12 hours on Codespaces; bochka has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | 309th of 366, with limits $6,970 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 247th of 345, with limits $250 a month | 288th of 345, with limits $619 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Neither publishes how many Devboxes or codespaces can run at once, so handing 300 machines to your own users is a compromise on both. | 284th of 361, with limits $2,068 a month | 281st of 361, with limits $1,964 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 356th of 360, with limits $9,012 a month | 282nd of 360, with limits $9,489 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 282nd of 364, with limits $1,043 a month | 295th of 364, with limits $1,519 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI is Namespace's main product, with drop-in GitHub Actions runners and build caches, so it fits fully, while Codespaces has no fork or snapshot API and every run starts from a repo or a prebuild; bochka runs CI jobs on full VMs with Docker and /dev/kvm. | 80th cheapest of 377 $765 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are a compromise for a box that stays up: a Namespace Devbox stops after 4 to 24 hours by plan and a codespace after 12 hours, while a bochka machine runs until you stop it. | 126th of 368, with limits $168 a month | 130th of 368, with limits $270 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Namespace's screenshot and click API works on macOS Devboxes only and a codespace has no graphical desktop at all, while bochka streams a 60fps Linux desktop with Chromium. | 67th of 369, with limits $982 a month | 267th of 369, with limits $1,367 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 285th of 367, with limits $789 a month | 275th of 367, with limits $678 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 259th of 346, with limits $332 a month | 310th of 346, with limits $922 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 226th of 338, with limits $9,012 a month | 280th of 338, with limits $18,637 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Neither can copy a prepared machine, so every parallel attempt starts again from an image or a repo; bochka forks one running sandbox into many. | 242nd of 360, with limits $339 a month | 267th of 360, with limits $445 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month Only Namespace fits: it runs macOS Devboxes on Apple Silicon, and neither Codespaces nor bochka has macOS. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | GitHub Codespaces | bochka |
|---|---|---|---|
| What it is | CI runners, build caches and Devboxes for people and coding agents | A cloud dev environment opened from a GitHub repository | A sandbox API for agents: full VMs you drive from code |
| Isolation | Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | A Docker container on its own newly built VM, with its own virtual network | Every sandbox is a full VM with its own kernel |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.79 runs/s | Not measured | 26.69 runs/s |
| How long a session can run | Devboxes stop after 4 hours on Developer, 5 on Team, 24 on Business, even while in use | Stops after 12 hours at most on every plan, even while in use | No session cap on paid plans |
| Idle stop | Stops after an idle timeout (15 minutes to 8 hours) and starts again when you connect | Stops after 30 idle minutes by default (5 to 240); you restart it | Machines run until you stop them |
| Docker and nested virtualization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Docker and sudo in the dev container; /dev/kvm not documented | Docker, root, systemd and /dev/kvm on every machine |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only | Linux only; Wine for Windows apps |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | VS Code, JupyterLab and a terminal; no graphical desktop | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
| Files after a stop | Storage kept, billed at $0.20 per GB-month used | Files kept, billed at $0.07 per GB-month; stopped codespaces deleted after 30 days by default | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork and suspend | No fork; compute instances can suspend and resume with RAM kept | No copy or snapshot endpoint; new codespaces start from a repo or prebuild | Fork a running sandbox into copies; named snapshots as templates |
| Starting point | Any container image you choose, plus Devbox blueprints | Dev container config in the repo, with prebuilds built by GitHub Actions | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Reaching the machine | HTTPS URLs that need a Namespace login; TCP through a CLI port-forward; no public IP | A URL per forwarded port, private, organization or public; SSH tunnels; no public IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet and keys | Egress allowlists by domain; rules can inject a header from Namespace Vault outside the workload | Open internet with no way to restrict it; secrets copied in as environment variables | Open internet; AI credentials proxy for model providers and any HTTPS API, with account switching when credits run out |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions through those partners; MCP server to create Devboxes | GitHub Copilot as a VS Code extension; other agents you install yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
Every feature Battleships tracks (43)
| Feature | Namespace | GitHub Codespaces | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Namespace did 21.79, so the same build takes about a fifth longer on Namespace. GitHub Codespaces was not in that benchmark, so there is no comparable number for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). GitHub Codespaces has no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Namespace, a month | GitHub Codespaces, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $50 · Devbox (pay as you go) | $51 · Personal account: GitHub Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $176 · Devbox (pay as you go) · with limits | $270 · Personal account: GitHub Free · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $2,198 · Devbox (pay as you go) | $3,019 · Personal account: GitHub Free | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $1,214 · Devbox (pay as you go) | $850 · Personal account: GitHub Free · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $3,237 · Devbox (pay as you go) | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Namespace: Devboxes are billed pay as you go at $0.004 per Devbox Minute, one a minute for 4 vCPU / 8 GB, and stored files cost $0.20 per GB-month. The Team and Business plan minutes cover runners and instances, not Devboxes.
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, plus $0.07 per GB-month of storage while it exists. There is no 4-core 8 GB machine, so 4 vCPU jobs use the 4-core 16 GB one; personal accounts get a free monthly quota and organizations do not.
GitHub Codespaces: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither fits an agent that never stops: a Namespace Devbox restarts at least once a day and a codespace every 12 hours, and running processes end at each stop. GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed on Codespaces, while Namespace fits both but publishes no Devbox concurrency limit or egress price. On bochka the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Namespace | GitHub Codespaces | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Namespace when
you need macOS or Windows machines, faster GitHub Actions runners with build caches, or egress rules that limit agents to chosen domains.
- macOS and Windows machines. Pick Namespace if agents build iOS or Mac apps or test on Windows: it runs macOS on Apple Silicon and Windows machines.
- Faster CI with build caches. Pick Namespace if you want quicker GitHub Actions: it is a drop-in runner with Docker, Bazel, Turborepo and Nix caching.
- Egress rules and wake on connect. Pick Namespace if agents must reach only chosen domains, or boxes should stop when idle and start again when you connect.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, in the US, EU or Asia.
- Built into GitHub. Pick Codespaces if your team lives on GitHub: open a ready dev container from any repo, branch or pull request.
- Free hours for personal accounts. Pick Codespaces for occasional personal work: GitHub Free includes 120 core-hours and 15 GB-month of storage each month.
- Longer default cap on small plans. Pick Codespaces over Namespace's Developer or Team plans if one session must run past 4 or 5 hours, up to 12.
Where bochka fits
Namespace and Codespaces are both machines for developers that agents can borrow, and both cut a session off at a fixed time. If what you are really running is agents that work on Linux for hours or days, bochka gives each one a full VM with no session cap, a desktop, and coding agents you drive from outside.
No clock on the session
A Namespace Devbox is shut down at 4, 5 or 24 hours by plan and a codespace at 12, even mid-task. Your code has to notice, restart the machine and resume the job every time.
A full VM with /dev/kvm and a Linux desktop
Codespaces has no documented /dev/kvm and no desktop; Namespace has /dev/kvm only on compute instances and a click API only on macOS. On bochka every machine has Docker, systemd, /dev/kvm and a 60fps desktop.
Fork a running machine and keep its work
Neither can copy a warm machine, so every parallel attempt starts again from an image or a repo. bochka forks a running sandbox, snapshots its disk every minute, and a stopped one costs nothing.
Use bochka when your agents work on Linux for hours or days: a full, faster VM with no session cap, Docker and /dev/kvm, a 60fps desktop, forks of running machines, and coding agents you drive from outside. Compare it one to one: bochka vs Namespace and bochka vs GitHub Codespaces.
Questions people ask
Is Namespace cheaper than GitHub Codespaces?
About the same for one coding agent on workdays: $50 a month on Namespace against $51 on Codespaces. Namespace costs less for 50 agents in parallel, $2,198 against $3,019, and for one agent all month, $176 against $270, though neither runs 24/7 without restarts. bochka comes to $20, $317 and $26 for the same three.
Which is faster, Namespace or GitHub Codespaces?
Codespaces has no comparable measurement. In StarSling's run at 4 vCPU / 8 GB, Namespace did 21.79 Node.js build-and-test runs per second and bochka did 26.69.
How long can a session run on Namespace and on Codespaces?
A Namespace Devbox stops after 4 hours on Developer, 5 on Team and 24 on Business, and support can raise it to 24 at most. A codespace stops after 12 hours on every plan. Both limits apply even while you work, and bochka has no session cap on paid plans.
Can Namespace and Codespaces run Docker?
Yes, both run Docker inside. Namespace offers /dev/kvm on Linux compute instances, while GitHub does not document /dev/kvm in Codespaces. Every bochka machine has Docker, systemd and /dev/kvm.
Do Namespace or Codespaces run macOS?
Namespace runs macOS Devboxes on Apple Silicon and Windows machines on Team plans and up. Codespaces is Linux only, and so is bochka, which has Wine docs for Windows apps.
Can I run Claude Code on Namespace or Codespaces?
On Namespace, Claude Managed Agents, Cursor and Devin sessions run through those partners, or you install an agent yourself. On Codespaces you install it in the terminal with your key as an environment variable. bochka ships Claude Code, Codex and OpenCode preinstalled and keeps real keys outside the sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview