bochka vs Namespace
Namespace is a build and dev platform: GitHub Actions runners, caches, and Devboxes for people and coding agents, on Linux, macOS and Windows. bochka is built for agents that run for hours or days, on a full VM with no session cap, a Linux desktop and coding agents you drive from outside.
Where bochka stands out
No clock on the session
On bochka's paid plans a sandbox runs as long as the work does, for hours or for months. A Namespace Devbox is shut down when it reaches its plan's limit: 4 hours on Developer, 5 on Team and 24 on Business, and support can raise it to 24 at most.
Coding agents you drive from outside
bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and you drive agents inside from outside with a prompt, steer and events API. Namespace runs the machine while a partner such as Anthropic, Cursor or Devin runs the agent loop. bochka's credentials proxy keeps real AI keys out, and can switch to another account when credits run out.
A Linux desktop for computer use
Every bochka sandbox streams a 60fps Linux desktop with Chromium, with computer use and browser control you can embed in your app. Namespace's screenshot and click API works on macOS Devboxes only and rejects Linux Devboxes.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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
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. “3rd cheapest of 367” means 2 of the other 366 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 | bochka: price rank | Namespace: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 3rd cheapest of 367 $634 a month | 39th of 367, with limits $3,495 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops is a compromise on Namespace, because a Devbox is shut down after at most 24 hours even while it works; bochka has no session cap on paid plans. | 5th cheapest of 366 $657 a month | 303rd of 366, with limits $6,645 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Namespace costs less for one-minute bursts here because it bills per minute with no plan fee, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 247th of 345, with limits $250 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 284th of 361, with limits $2,068 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 356th of 360, with limits $9,012 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 282nd of 364, with limits $1,043 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit; CI runners are Namespace's main product, with caches for Docker, Bazel and more, and bochka runs CI jobs on full VMs with Docker and /dev/kvm. | 4th cheapest of 377 $86 a month | 80th cheapest of 377 $765 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Namespace Devbox is a compromise here because it is shut down after at most 24 hours, though it stops when idle and starts again when you connect; a bochka machine stays up as long as you want. | 18th cheapest of 368 $26 a month | 126th of 368, with limits $168 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, so a Linux computer-use agent is a compromise there; bochka streams a 60fps Linux desktop with Chromium. | 6th cheapest of 369 $200 a month | 67th of 369, with limits $982 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Namespace has no managed browser and no Linux display API for Devboxes, so you set up the browser yourself; bochka ships Chromium with browser control. | 7th cheapest of 367 $200 a month | 285th of 367, with limits $789 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 259th of 346, with limits $332 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 226th of 338, with limits $9,012 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 242nd of 360, with limits $339 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Neither fits: Namespace's machine shapes and bochka's are CPU only. | 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 and instances on Apple Silicon, and bochka has no macOS. | Can't run it | 6th cheapest of 36 $1,205 a month |
Key features
| Feature | bochka | Namespace |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 26.69 runs/s | 21.79 runs/s |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker in Linux Devboxes; /dev/kvm on Linux compute instances, not on macOS or Windows |
| How long a session can run | No session cap on paid plans | Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most; instances after 3, 5 or 24 |
| Desktop and computer use | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances |
| Files after a stop | Snapshots every minute and on stop; a stopped sandbox costs nothing | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used |
| Idle stop and wake | Machines run until you stop them | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect |
| Fork and suspend | Fork a running sandbox into a new one; resume reboots from disk | No fork; compute instances can suspend and resume with RAM kept |
| Custom images | Named snapshots (templates), shareable by code; no Dockerfile builds | Any container image you choose, plus Devbox blueprints |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | HTTPS URLs that need a Namespace login, TCP through a running CLI port-forward; no public IP |
| Outbound internet | Open internet on every plan; no provider-side allowlist | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Egress rules inject a header from Namespace Vault, resolved outside the workload |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Hosts Claude Managed Agents, Cursor and Devin sessions run through those partners; an MCP server lets your own agent create Devboxes and run commands |
| Operating systems | Linux only; Wine for Windows apps | Linux, macOS on Apple Silicon, and Windows on Team plans and up |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | bochka | Namespace |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | No |
| Computer-use API | Yes | Yes |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | Yes |
| Arm64 | No | Yes |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
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. That run found an OCI container inside the Namespace machine it tested. A Namespace Devbox's vCPU count is a ceiling it can boost to, not a guaranteed share.
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).
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 | bochka, a month | Namespace, 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 | $20 · $20/mo | $50 · Devbox (pay as you go) |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $176 · Devbox (pay as you go) · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $2,198 · Devbox (pay as you go) |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $1,214 · Devbox (pay as you go) |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $3,237 · Devbox (pay as you go) |
bochka: 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.
Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan: a 4 vCPU / 8 GB Devbox uses one a minute, and bigger sizes use more. The minutes in the Team ($100) and Business ($250) plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Limits in those scenarios
The limit that bites most on Namespace is time: a Devbox is shut down after 4, 5 or 24 hours by plan, so the agent that never stops restarts at least once a day, and on Developer or Team even one workday session hits the 4 or 5 hour limit. Namespace limits instances by a pool of vCPU and memory per plan (32 vCPU on Developer up to 160 on Business), and it does not publish a Devbox concurrency limit or an egress price. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000 short jobs get queued and need more starts per day than the $2,000 plan allows.
| Scenario | bochka | Namespace |
|---|---|---|
| One coding agent, workdays | 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 Devboxes for people that stop when idle.
- macOS and Windows. Useful if your agents build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows machines.
- CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
- Egress rules and idle stop. Useful if agents must reach only chosen domains, or boxes should stop when nobody uses them and start on connect.
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, and coding agents you drive from outside.
- No clock on the session. An agent that runs a long migration or stays on as an assistant gets cut off mid-task on Namespace. Its processes die, and your code has to notice, restart the Devbox and resume the work every day.
- Coding agents you drive from outside. On Namespace you either sign up for a partner's agent service or write the code that installs, starts, prompts and watches each agent yourself. When an account runs out of credits, bochka switches the credential and the agent keeps going.
- A Linux desktop for computer use. A Linux agent that has to use a browser or a desktop app has no display API on a Namespace Devbox. You install a desktop and VNC yourself, or pay for macOS minutes at a much higher rate.
Questions people ask
Is bochka cheaper than Namespace?
In most of the scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $50 on Namespace, and one agent running all month comes to $26 versus $176, and on Namespace it has to restart at least once a day. 50 agents in parallel come to $317 versus $2,198. For 1,000 short jobs at once Namespace fits and bochka does not without higher start limits.
How long can a Namespace Devbox run?
Up to 4 hours on Developer, 5 on Team and 24 on Business, and the limit applies even while you work in it. Support can raise it to 24 hours at most. bochka has no session cap on paid plans.
Is Namespace a sandbox for AI agents?
Partly. Namespace is mainly a CI and build platform, and its Devboxes are remote dev machines for people and coding agents. Partners such as Anthropic, Cursor and Devin run agent sessions on them. bochka is built only for agent sandboxes, with the agents and their API built in.
Does bochka run macOS or Windows like Namespace?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X (Zen 5) hosts and has Wine docs for Windows apps. If you need macOS for Xcode or a Windows machine, Namespace has both.
Where does my data run?
bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Namespace runs in several regions and lets you ask support for a preferred region; keeping every workload inside one region needs its enterprise plan.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention. Namespace's trust center lists SOC 2 Type II.
Start a sandbox
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs exe.dev
- bochka vs Amp Orbs
- bochka vs Prized
- bochka vs Zo Computer
- bochka vs Ona
- bochka vs boxes.dev
- bochka vs Tencent Cloud Studio
- bochka vs Sealos DevBox
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- E2B vs Namespace
- Daytona vs Namespace
- Modal vs Namespace
- Vercel Sandbox vs Namespace
- Cloudflare Sandbox vs Namespace
- Blaxel vs Namespace
- Runloop vs Namespace
- Tensorlake vs Namespace