Deno Sandbox vs Docker Cloud Sandboxes
Both run agent code in a small Linux microVM. Deno Sandbox is a fixed 2 vCPU machine for runs of up to 30 minutes that starts in under 200 ms, while Docker Cloud Sandboxes come in sizes up to 16 vCPU, run Docker inside and last up to 24 hours.
The companies and products
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
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. “290th cheapest of 367” means 289 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 | Deno Sandbox: 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 A software factory runs builds and Docker for hours; Deno stops at 30 minutes on 2 vCPU and Docker at 24 hours with 10 at a time, while boat has no session cap. | 290th of 367, with limits $5,665 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 An assistant that lives on its machine all month fits neither: Deno ends after 30 minutes and wipes its disk, and Docker ends 24 hours after creation. | 287th of 366, with limits $5,803 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 This is where both do best: Deno starts in under 200 ms and bills CPU only while code runs, and Docker bills small sandboxes by the second. | 141st of 345, with limits $329 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 Deno Builder allows 20 sandboxes at once per region and Docker 10 per account by default, so both fall short of hundreds of users at once; boat's plans go to 2,000. | 148th of 361, with limits $1,863 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 | 122nd of 360, with limits $7,963 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 Evals that run an agent past 30 minutes or need more than 2 vCPU fit Docker better than Deno, though Docker's 10 at a time slows a big run. | 296th of 364, with limits $1,563 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 CI that needs Docker or more than 2 vCPU fits Docker better than Deno; Android or VM builds need /dev/kvm, which only boat documents. | 304th of 377, with limits $731 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 A dev box that stays on all month needs no session cap, which rules out Deno's 30 minutes and Docker's 24 hours; boat keeps the disk and has no cap. | 179th of 368, with limits $200 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 Computer-use agents need a screen: Deno and Docker are shell and terminal only, while boat has a 60fps Linux desktop with Chromium. | 280th of 369, with limits $1,583 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 | 284th of 367, with limits $783 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 | 286th of 346, with limits $573 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 | 247th of 338, with limits $11,923 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 | 251st of 360, with limits $367 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 | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Deno Sandbox | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | MicroVM with its own Linux kernel; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | 2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk | 1 vCPU / 2 GiB up to 16 vCPU / 32 GiB, amd64 or arm64 by account | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | 1 hour by default, at most 24 hours from creation | No cap on paid plans; you set the time to live |
| Sandboxes at once | 3 per region on Pro, 20 per region on Builder | 10 by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Stop and resume | No stop; the root disk is wiped when the sandbox ends, opt-in volumes in Chicago only | Stop keeps memory and files; snapshots unused for 7 days are deleted | Disk saved every minute and on stop; a stopped sandbox costs nothing and boots again |
| Snapshots and fork | Read-only volume snapshots that new sandboxes boot from; no fork of a running sandbox | Snapshot a running sandbox with disk or disk and memory, restore it as a new one | Automatic disk snapshots; fork a running sandbox with its disk |
| Docker and nested virtualization | Root access; Docker and nested virtualization not documented | Its own Docker Engine inside; nested virtualization not documented | Docker, systemd and /dev/kvm for Android emulators and VMs |
| Desktop and browser | No desktop; a VS Code editor in the browser and SSH | Terminal sessions only | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Inbound access | HTTPS URL per exposed port, public without authentication; SSH | Public HTTPS URL per published port, not a TCP tunnel; SSH with Docker-issued certificates | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Host allowlist per sandbox, enforced by a proxy outside the VM | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Secrets swapped in on requests to approved hosts; the sandbox sees a placeholder | 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; switch a credential to another account when credits run out |
| Coding agents | A root image with Claude Code, run through the shell command API | Claude Code, Codex, Copilot, OpenCode and more, attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Start and workflow | Starts in under 200 ms from a TypeScript or Python SDK | Same sbx CLI as on your laptop; move a sandbox between laptop and cloud | Boots a full VM; cloud only |
| Regions | Amsterdam and Chicago | Not published | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Deno Sandbox | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Not published | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | 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 | No | Yes | Yes |
| Idle auto-stop | No | No | No |
| Wake on request | No | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | 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 | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | 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 | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: Deno Sandbox and Docker Cloud Sandboxes are not in the hpc-sandbox-benchmarks runs, and Deno's fixed 2 vCPU shape could not run the 4 vCPU test as set up. boat did 26.69 runs per second on that Node.js build-and-test benchmark at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Deno Sandbox and Docker Cloud Sandboxes have 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 | Deno Sandbox, 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 | $53 · Pro · with limits | $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 | $200 · Builder · 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,779 · Builder · with limits | $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 | $783 · Builder · with limits | $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 | $1,563 · Builder · with limits | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
Deno Sandbox: Sandboxes need the Pro plan at $20 a month or Builder at $200 a month; the fee is not credit but includes CPU, memory and egress allowances shared with 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.
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. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Deno Sandbox fits none of the five scenarios: a sandbox lives up to 30 minutes on a fixed 2 vCPU, and Builder allows 20 at once per region. Docker fits the workday agent, but its 24-hour cap rules out the agent that never stops, and its default of 10 at once rules out 50 agents, sandboxes for your users and 1,000 short jobs. boat fits four of the five; at 1,000 short jobs at once its top plan queues starts above 90 a minute.
| Scenario | Deno Sandbox | 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 Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds, reach only the hosts you allow, or run in the US, especially if you already deploy on Deno Deploy.
- Starts in under 200 ms. Good for one sandbox per request: Deno says a sandbox starts in under 200 ms, and CPU bills only while code runs.
- A US region and Deno Deploy. Fits teams already on Deno Deploy: sandboxes run in Chicago or Amsterdam and can be promoted to a Deploy app.
- Strict host allowlist. Useful for untrusted code: each sandbox can reach only the hosts you list, blocked by a proxy outside the VM.
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, on a bigger machine with Docker inside and memory kept across stops.
- Bigger machines and Docker inside. Fits builds and tests that need room: sizes go up to 16 vCPU / 32 GiB, each with its own Docker Engine.
- Stop and fork with memory. Useful for agents that pause: a stopped sandbox comes back with its memory, and you can fork one with memory.
- The same sandbox on your laptop. If you already run sbx locally, the cloud uses the same microVM and CLI, and you can move work between them.
Where boat fits
Both Deno and Docker are built for agent runs that end: 30 minutes on Deno, a day at most on Docker. If your agents work for days, run by the dozen, need a screen or Android emulators, or have to be driven from your own app, look at boat.
A machine that stays
A Deno sandbox ends after 30 minutes and wipes its root disk, and a Docker one ends 24 hours after creation. On both, your code must split the work and restart it. boat has no cap on paid plans and saves the disk every minute.
A whole machine, screen included
Neither Deno nor Docker documents /dev/kvm or offers a desktop, so Android emulators cannot start and a browser agent needs a separate service. boat has /dev/kvm, Docker, systemd and a 60fps desktop with Chromium in every sandbox.
Drive agents inside from outside, at width
Deno runs Claude Code through shell commands and Docker through an attached terminal, so you parse text to know when an agent is done. boat has a prompt, steer and events API, and runs 100 at once on the $20 plan.
Use boat when your agents run for days or by the dozen, need Docker, Android emulators, a desktop or a browser, or have to be driven from your own app through an API. Compare it one to one: boat vs Deno Sandbox and boat vs Docker Cloud Sandboxes.
Questions people ask
Is Deno Sandbox cheaper than Docker Cloud Sandboxes?
In most scenarios here Docker comes out a little lower: for 50 agents in parallel it is $2,464 a month against $2,779 on Deno. For one agent that never stops they are close, $200 on Deno and $204 on Docker, but neither fits. boat is $26 a month for that agent.
Which is faster, Deno Sandbox or Docker Cloud Sandboxes?
Neither is in the hpc-sandbox-benchmarks CPU runs, so there is no measured answer. Deno says a sandbox starts in under 200 ms, while Docker lets you pick up to 16 vCPU against Deno's fixed 2 vCPU, which gives heavy builds more room.
Can Deno Sandbox run Docker?
Deno's docs give root access but do not say Docker works inside a sandbox. Docker Cloud Sandboxes each run their own Docker Engine. boat runs Docker and systemd and also exposes /dev/kvm for Android emulators and VMs.
How long can each sandbox run?
A Deno sandbox lives up to 30 minutes, and longer work can be promoted to a Deno Deploy app. A Docker cloud sandbox expires after one hour by default and cannot go past 24 hours from creation. A boat sandbox has no session cap on paid plans.
How many can I run at once?
Deno allows 3 sandboxes at once per region on Pro and 20 on Builder. Docker allows 10 per account by default and publishes no way to raise it. boat runs 100 at once on the $20 plan and up to 2,000 on higher plans.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Deno Sandbox
- boat vs Docker Cloud Sandboxes
- E2B vs Deno Sandbox
- Daytona vs Deno Sandbox
- Modal vs Deno Sandbox
- Vercel Sandbox vs Deno Sandbox
- Cloudflare Sandbox vs Deno Sandbox
- Blaxel vs Deno Sandbox
- Runloop vs Deno Sandbox
- Tensorlake vs Deno Sandbox
- Morph Cloud vs Deno Sandbox
- CodeSandbox SDK vs Deno Sandbox