Namespace vs Deno Sandbox
Namespace is a build and dev platform whose Devboxes are remote machines that run for up to 24 hours, on Linux, macOS and Windows. Deno Sandbox runs short pieces of untrusted code in small Linux microVMs that start in under 200 ms and live up to 30 minutes.
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
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
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 | Deno Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Namespace is the closer fit for a software factory, with 4 vCPU Devboxes, Docker and up to 24 hours a session, while Deno's 2 vCPU sandboxes end after 30 minutes; bochka fits fully with no session cap. | 39th of 367, with limits $3,495 a month | 290th of 367, with limits $5,665 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both are a compromise for an assistant that never stops: a Namespace Devbox is shut down after at most 24 hours, and a Deno sandbox ends after 30 minutes and wipes its disk. | 303rd of 366, with limits $6,645 a month | 287th of 366, with limits $5,803 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 Deno Sandbox does better here, with starts under 200 ms and CPU billed only while code runs, while Namespace bills Devbox minutes and bochka's start limits make big bursts a compromise. | 247th of 345, with limits $250 a month | 141st of 345, with limits $329 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 Deno caps Builder at 20 sandboxes at once per region and its URLs are public, Namespace's URLs need a Namespace login, and bochka's are token-protected with plans that go to hundreds of sandboxes. | 284th of 361, with limits $2,068 a month | 148th of 361, with limits $1,863 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 | 122nd of 360, with limits $7,963 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 | 296th of 364, with limits $1,563 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 Namespace fits fully, since CI runners with Docker, Bazel and Turborepo caching are its main product, while Deno does not document Docker; bochka also fits, with Docker and /dev/kvm on every machine. | 80th cheapest of 377 $765 a month | 304th of 377, with limits $731 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Namespace Devbox stops when idle and starts again when you connect, but is shut down after at most 24 hours; a Deno sandbox ends after 30 minutes, and a bochka machine stays up as long as you want. | 126th of 368, with limits $168 a month | 179th of 368, with limits $200 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 Deno Sandbox has no desktop, while bochka streams a 60fps Linux desktop with Chromium. | 67th of 369, with limits $982 a month | 280th of 369, with limits $1,583 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 | 284th of 367, with limits $783 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 | 286th of 346, with limits $573 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 | 247th of 338, with limits $11,923 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 | 242nd of 360, with limits $339 a month | 251st of 360, with limits $367 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 on Apple Silicon, and both Deno Sandbox and bochka are Linux only. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Deno Sandbox | bochka |
|---|---|---|---|
| Isolation | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | 4 vCPU / 8 GB Devboxes and bigger sizes; Linux shapes up to 64 vCPU | 2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.79 runs/s | Not measured; the fixed 2 vCPU shape cannot run the 4 vCPU test | 26.69 runs/s |
| How long a session can run | Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No session cap on paid plans |
| Files after a stop | A stopped Devbox keeps its storage, billed at $0.20 per GB-month used | Root disk wiped when the sandbox ends; opt-in volumes of 300 MB to 20 GB, Chicago only | Whole disk saved every minute and on stop; a stopped sandbox costs nothing |
| Docker and nested virtualization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Root access; Docker and nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Starting and stopping | Devboxes stop after an idle timeout (15 minutes to 8 hours) and start again when you connect | Starts in under 200 ms | Boots a full VM and runs until you stop it |
| Fork and snapshots | No fork; compute instances can suspend and resume with RAM kept | Read-only volume snapshots that new sandboxes can boot from; no fork of a running sandbox | Automatic disk snapshots; fork a running sandbox into a new one |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | No desktop; a VS Code editor in the browser and SSH | 60fps Linux desktop with Chromium, computer use and browser control |
| Reaching the sandbox | HTTPS URLs that need a Namespace login, TCP through a CLI port-forward; no public IP | HTTPS URL per exposed port, public without authentication; SSH | HTTPS URLs for up to 50 ports, token-protected; raw TCP |
| Outbound rules | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Host allowlist per sandbox, enforced by a proxy outside the VM | Open internet; no provider-side allowlist |
| Keeping API keys out of the sandbox | Egress rules inject a header from Namespace Vault, resolved outside the workload | Secrets swapped in on requests to approved hosts; the sandbox only sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server lets your agent create Devboxes | A root image with Claude Code, run through the shell command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only | Linux only; Wine for Windows apps |
Every feature Battleships tracks (43)
| Feature | Namespace | Deno Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | 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 | No | 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 | No | 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 | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | 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 | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | 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. Deno Sandbox is not in that benchmark, and its fixed 2 vCPU shape could not run the 4 vCPU test, so there is no comparable score 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). Deno Sandbox 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 | Deno Sandbox, 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) | $53 · Pro · with limits | $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 | $200 · Builder · 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) | $2,779 · Builder · with limits | $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) | $783 · Builder · 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,563 · Builder · with limits | $2,000 · $2000/mo · with limits |
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. Plan minutes cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Deno Sandbox: Sandboxes need Pro at $20 a month or Builder at $200 a month, with allowances shared with your Deno Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Deno Sandbox: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Namespace fits four of the five scenarios, but the agent that never stops has to restart at least once a day because a Devbox is shut down after 24 hours at most, and Namespace does not publish an egress price. Deno Sandbox fits none as written: a sandbox lives up to 30 minutes on 2 vCPU and 4 GB, and Builder allows 20 at once per region, short of 50 agents, 300 user sandboxes or 1,000 jobs. bochka fits four of the five; for 1,000 short jobs at once its top plan queues starts above 90 a minute and allows 2,400 starts a day.
| Scenario | Namespace | Deno Sandbox | bochka |
|---|---|---|---|
| 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 Linux Devboxes that run for hours and stop when idle.
- Longer sessions on bigger machines. Useful for agents that build for hours: a Devbox runs up to 24 hours on 4 vCPU or more, with Docker inside.
- macOS and Windows. Useful if your agents build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows.
- CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
Use Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds and reach only the hosts you allow, especially if you already deploy on Deno Deploy.
- Fast starts and active-CPU billing. Good for short bursts of code: a sandbox starts in under 200 ms and CPU bills only while code runs.
- Locked-down outbound traffic. Useful for untrusted code: each sandbox can be limited to a list of hosts, enforced by a proxy outside the VM.
- A path to Deno Deploy. Fits teams already on Deno Deploy: a sandbox can be promoted to a Deploy app and runs in Chicago or Amsterdam.
Where bochka fits
If your agents do long work on Linux, both products put a clock on the machine: 4 to 24 hours on Namespace and 30 minutes on Deno Sandbox. bochka gives each agent a full VM with no session cap on paid plans, a disk saved every minute, Docker and /dev/kvm, a 60fps desktop, and coding agents you drive from outside.
No clock on the session
A Namespace Devbox is shut down at its plan limit even mid-task, and a Deno sandbox ends after 30 minutes and wipes its root disk. Your code then has to restart, split the work or rebuild the environment each time.
Coding agents you drive from outside
On Namespace a partner such as Anthropic, Cursor or Devin runs the agent loop, and on Deno you run Claude Code through shell commands and parse its output. bochka ships seven agents with a prompt, steer and events API.
A Linux desktop for computer use
Deno Sandbox has no desktop, and Namespace's screenshot and click API rejects Linux Devboxes, so a Linux agent needs a desktop and VNC you set up yourself, or pricier macOS minutes. bochka streams a 60fps Linux desktop with Chromium.
Use bochka when your agents work on Linux for hours or days: a full, faster VM with no session cap, a disk saved every minute, Docker and /dev/kvm, a 60fps desktop, and coding agents you drive from outside. Compare it one to one: bochka vs Namespace and bochka vs Deno Sandbox.
Questions people ask
Is Namespace cheaper than Deno Sandbox?
For long work, mostly yes: one coding agent on workdays comes to $50 on Namespace and $53 on Deno, and 50 agents in parallel to $2,198 against $2,779, and Deno does not fit either because of its 30-minute cap. For short jobs Deno is lower, $1,563 against $3,237 for 1,000 jobs at once, but Builder allows only 20 at once per region. bochka comes to $20 and $317 for the first two.
Which is faster, Namespace or Deno Sandbox?
For CPU work there is no head-to-head number: Namespace did 21.79 runs per second in StarSling's Node.js test, and Deno Sandbox is not in it. bochka did 26.69 in the same run. For start time, Deno says a sandbox starts in under 200 ms.
How long can a session run on Namespace and Deno Sandbox?
A Namespace Devbox runs up to 4 hours on Developer, 5 on Team and 24 on Business, even while you work in it. A Deno sandbox lives up to 30 minutes, and you can promote one to a Deno Deploy app for longer work. bochka has no session cap on paid plans.
Can Namespace or Deno Sandbox run Docker?
Namespace Linux Devboxes include Docker, and its Linux compute instances expose /dev/kvm. Deno's docs give root access but do not say Docker or nested virtualization works. bochka runs Docker and systemd and exposes /dev/kvm on every machine.
Do they keep files between sessions?
A stopped Namespace Devbox keeps its storage, billed at $0.20 per GB-month used. A Deno sandbox's root disk is wiped when it ends, and you can mount a volume of 300 MB to 20 GB, only in Chicago. bochka saves the whole disk every minute and on stop, and a stopped sandbox costs nothing.
Does Deno Sandbox run macOS or Windows like Namespace?
No. Deno Sandbox runs Linux microVMs only, while Namespace runs macOS on Apple M4 Pro and M5 Max chips and Windows on Team plans and up. bochka is Linux only too, with Wine for Windows apps.
Try bochka
Install the CLI, then run bochka new.
Product preview