Namespace vs Docker Cloud Sandboxes
Namespace is a build and dev platform: CI runners, caches and Devboxes on Linux, macOS and Windows. Docker Cloud Sandboxes runs the same sbx microVMs you use on your laptop in Docker's cloud, one per coding agent, for up to a day.
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 boat, 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
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Namespace is the better of the two for a software factory because it has no published Devbox concurrency limit, while Docker allows 10 sandboxes at once by default; boat fits fully with no session cap. | 39th of 367, with limits $3,495 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Neither fits an assistant that never stops: a Namespace Devbox shuts down after at most 24 hours and a Docker sandbox ends 24 hours after creation, while boat has no session cap on paid plans. | 303rd of 366, with limits $6,645 a month | 276th of 366, with limits $5,110 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 Docker fits short code runs better than Namespace here, with small sandboxes billed by the second and memory kept across stops; boat's start limits make big bursts a compromise. | 247th of 345, with limits $250 a month | 119th of 345, with limits $233 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 Docker's default of 10 sandboxes at once on one personal account limits serving your users, while Namespace fits but bills each short session as a 4 vCPU Devbox here; boat fits fully. | 284th of 361, with limits $2,068 a month | 136th of 361, with limits $1,628 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 | 114th of 360, with limits $7,000 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 | 167th of 364, with limits $1,400 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 CI fully, since its main product is GitHub Actions runners with build caches, while Docker sells agent sandboxes, not runners; boat runs CI jobs on full VMs with Docker and /dev/kvm. | 80th cheapest of 377 $765 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 126th of 368, with limits $168 a month | 127th of 368, with limits $204 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 has a screenshot and click API on macOS Devboxes and VNC on instances, while Docker's sandboxes are terminal only; boat streams a 60fps Linux desktop with Chromium. | 67th of 369, with limits $982 a month | 268th of 369, with limits $1,400 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 Neither ships a browser inside the machine, so you set one up yourself on both; boat ships Chromium with browser control. | 285th of 367, with limits $789 a month | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 | 248th of 360, with limits $350 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 and instances on Apple Silicon, and neither Docker Cloud Sandboxes nor boat has macOS. | 6th cheapest of 36 $1,205 a month | Can't run it | Can't run it |
Key features
| Feature | Namespace | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel | MicroVM per sandbox with its own Linux kernel and Docker Engine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| 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, 5 or 24 hours by plan, even while you work; 24 hours at most | 1 hour by default, at most 24 hours from creation | No session cap on paid plans |
| Machines at once | A vCPU and memory pool per plan for instances (32 vCPU on Developer up to 160 on Business); no published Devbox limit | 10 concurrent and 50 stored by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans |
| Docker and nested virtualization | Docker in Linux Devboxes; /dev/kvm on Linux compute instances | Its own Docker Engine in each sandbox; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Stop, resume and fork | No fork; compute instances can suspend and resume with RAM kept | Stop keeps memory and files; snapshot a running sandbox with memory and restore it as a new one | Disk saved every minute and on stop; fork a running sandbox with its disk; resume boots again |
| Idle stop and wake | Devboxes stop after an idle timeout and start again when you connect | No idle stop; you stop the sandbox or it hits its timer | Machines run until you stop them |
| Desktop and computer use | Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances | Terminal sessions only | 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 | Public HTTPS URL per published port, not a TCP tunnel; SSH with Docker-issued certificates | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Egress policies per Devbox blueprint, runner or instance: block, advisory or allow by domain | Allow and deny rules by host at a proxy, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Egress rules inject a header from Namespace Vault, outside the workload | Cloud proxy sets the auth header for AI services and custom hosts; the sandbox sees a placeholder | Credentials proxy for model providers and any HTTPS API; switches to another account when credits run out |
| Coding agents | Hosts Claude Managed Agents, Cursor and Devin sessions run by those partners; an MCP server for your own agent | Claude Code, Codex, Copilot, OpenCode and more, started and attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Operating systems | Linux, macOS on Apple Silicon, and Windows on Team plans and up | Linux only, amd64 or arm64 by account | Linux only; Wine for Windows apps |
| Laptop and cloud | Cloud only | Same microVM and CLI locally or in the cloud; move a sandbox either way | Cloud only |
Every feature Battleships tracks (43)
| Feature | Namespace | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| 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 | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | 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 | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | Yes | Yes | 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 | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, boat 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. Docker Cloud Sandboxes has no comparable measurement yet: it launched in September 2026, is not in those runs, and Docker does not say what hardware it uses.
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). Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, a month | boat, 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) | $49 · Docker Agentic Platform (pay-as-you-go) | $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 | $204 · Docker Agentic Platform (pay-as-you-go) · 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,464 · Docker Agentic Platform (pay-as-you-go) · 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) | $700 · Docker Agentic Platform (pay-as-you-go) · 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,400 · Docker Agentic Platform (pay-as-you-go) · 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, and a 4 vCPU / 8 GB Devbox uses one a minute. Plan minutes on Team and Business cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: Plans start at $20 a month and the whole fee is usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Both stop work at 24 hours: a Namespace Devbox shuts down at its plan's limit even while working, and a Docker sandbox ends 24 hours after creation, so the agent that never stops fits neither. Docker's default of 10 sandboxes at once rules it out for 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once, all of which fit on Namespace, though Namespace does not publish an egress price. boat has no session cap, but its start limits are too low for the 1,000-job burst even on the $2,000 plan.
| Scenario | Namespace | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| 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 many 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, Turborepo and Nix caching.
- Boxes that stop when idle. Useful for dev boxes people use on and off: a Devbox stops after an idle timeout and starts again when you connect.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few to keep going in the cloud for up to a day, with memory kept across stops.
- Stop and fork with memory. Useful for agents that pause between steps: a stopped sandbox comes back with its memory, and a running one can be copied with it.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move a sandbox between them.
- A microVM with its own kernel. Useful if you want each agent in its own kernel with its own Docker Engine, which Docker documents and Namespace does not.
Where boat fits
If what you are really running is Linux coding agents that work for hours or days, both Namespace and Docker stop the machine within 24 hours. boat gives each agent a full, faster VM with no session cap, /dev/kvm, a 60fps desktop and an API to drive the agent inside. Namespace stays the pick for macOS, Windows and CI runners.
No clock on the session
A Namespace Devbox shuts down after 4, 5 or 24 hours by plan, and a Docker sandbox ends 24 hours after creation. On both, your code has to notice, restart and resume the agent every day; boat's paid plans have no session cap.
A whole machine, screen included
Docker's sandboxes are terminal only with no documented /dev/kvm, and Namespace's click API works on macOS only. A Linux agent that tests an Android app or clicks through a site needs a desktop you install yourself; boat ships one at 60fps.
Agents you drive from outside
On Docker you attach to an agent's terminal from the sbx CLI, and on Namespace a partner runs the agent loop or you write it. boat ships seven agents with a prompt, steer and events API, so your app knows when each one is done.
Use boat when your Linux agents run for days or by the dozen, need Docker with /dev/kvm, a desktop or a browser, or have to be driven from your own app through an API. Compare it one to one: boat vs Namespace and boat vs Docker Cloud Sandboxes.
Questions people ask
Is Namespace cheaper than Docker Cloud Sandboxes?
It depends on the job. One coding agent on workdays comes to $50 a month on Namespace and $49 on Docker, and short code runs cost less on Docker. For 50 agents in parallel Namespace fits at $2,198 a month while Docker does not, because of its 10-sandbox default; boat comes to $20 and $317 for those two.
Which is faster, Namespace or Docker Cloud Sandboxes?
There is no comparable number for Docker yet, because it is not in the public benchmark runs. Namespace did 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB, and boat did 26.69 on the same test.
Can either run longer than 24 hours?
No. A Namespace Devbox stops after 4, 5 or 24 hours by plan, and a Docker cloud sandbox ends 24 hours after creation, with resuming starting a new timer. boat has no session cap on paid plans.
Can Namespace and Docker Cloud Sandboxes run Docker inside?
Yes, both do. Docker gives each microVM its own Docker Engine, and Namespace Linux Devboxes include Docker, with /dev/kvm on Linux compute instances. boat has Docker, root, systemd and /dev/kvm on every machine.
Does either run macOS or Windows?
Only Namespace: it runs macOS on Apple Silicon and Windows on Team plans and up. Docker Cloud Sandboxes and boat are Linux only, and boat has Wine docs for Windows apps.
Where does my data run?
boat runs only in the EU (Germany, Finland and France). Namespace runs in several regions and keeps a workload inside one region only on its enterprise plan, and Docker does not publish its regions.
Try boat
Install the CLI, then run boat new.
7-day free trial