E2B vs Docker Cloud Sandboxes
Both give each agent its own microVM with a 24-hour session cap. E2B is an API built to run hundreds of sandboxes at once with desktops and memory pause, while Docker Cloud Sandboxes takes the sbx agent sandbox from your laptop into the cloud, 10 at a time by default.
The companies and products
E2B
E2B calls itself the AI agent cloud: an API that gives each agent session its own isolated Linux machine.
Every E2B sandbox is a Firecracker microVM that boots from a snapshot, so it starts fast and can be paused and resumed with its memory. You build custom sandboxes from templates based on a Docker image, and drive them from Python or JavaScript SDKs. It is built for teams that run many short code, data or agent jobs, and its runtime is open source.
- Isolation
- Firecracker microVM per sandbox
- Bring your own cloud
- Enterprise data plane in your AWS, GCP or Azure account
- Compliance
- SOC 2 Type II; HIPAA BAA on request
- Machine size
- 1 to 8 vCPU and 1 to 8 GiB RAM, CPU only
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. “16th cheapest of 367” means 15 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 | E2B: price rank | Docker Cloud Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both end a session at 24 hours, but E2B runs up to 100 sandboxes at once on Pro while Docker allows 10; bochka has no session cap and runs CPU work about twice as fast as E2B. | 16th cheapest of 367 $4,143 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 cannot stay in one session on either, since both stop at 24 hours; bochka can simply keep running. | 51st of 366, with limits $5,348 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 E2B is built for short code runs that start fast and wake on the next request, while Docker fits less well because it has no code interpreter and allows 10 at once. | 37th cheapest of 345 $421 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 Serving your own users needs many sandboxes at once: E2B sells up to 1,100 self-serve, Docker allows 10 by default on one personal account, and bochka gives each user a full VM with hosting built in. | 23rd cheapest of 361 $2,354 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 E2B's memory forks and high start rate suit many short rollouts that branch from the same state, which Docker's 10-sandbox default cannot match. | 2nd cheapest of 360 $9,384 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 | 78th cheapest of 364 $1,975 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 builds Android apps or VM images needs /dev/kvm, which neither E2B nor Docker offers and bochka exposes. | 337th of 377, with limits $1,429 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 | 192nd of 368, with limits $358 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 E2B has a Linux desktop for computer use and Docker's cloud sandboxes are terminal only; bochka streams its desktop at 60fps. | 32nd cheapest of 369 $1,342 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 Browser agents need a real browser inside the machine, which E2B and bochka have and Docker's terminal sandboxes do not. | 100th of 367, with limits $746 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 | 57th cheapest of 346 $554 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 | 227th of 338, with limits $9,223 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 | 11th cheapest of 360 $1,043 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 | E2B | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| 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 |
| CPU benchmark (4 vCPU / 8 GB) | 12.61 runs/s | Not measured | 26.69 runs/s |
| Biggest machine | Up to 8 vCPU / 8 GiB self-serve, more on request | Up to 16 vCPU / 32 GiB; amd64 or arm64 by account | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | 1 hour by default, at most 24 hours from creation; resuming starts a new timer | No cap on paid plans; you set the time to live |
| Sandboxes at once | 20 on Hobby, 100 on Pro, up to 1,100 self-serve with add-ons | 10 by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Pause and resume | Saves memory and disk; resume takes about 1 second with processes still running | Stop keeps memory and files; resume picks up where it left off | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Fork a running sandbox with its memory, up to 20 copies per call | Snapshot a running sandbox with disk or disk and memory, then restore it as a new sandbox | Fork a running sandbox with its disk |
| Wake on request | Yes; a paused sandbox can resume on the next HTTP request or SDK call | Not documented | No; a stopped sandbox is started by API |
| Nested virtualization | Not supported | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Linux desktop for computer use | Terminal sessions only | 60fps Linux desktop with Chromium and computer use |
| Inbound access | HTTPS URL per port, public by default unless you turn on a token; no dedicated 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 by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Allow and deny lists by IP, CIDR or domain | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| Coding agents | Templates and guides for many agents, run through the command API | Claude Code, Codex, Copilot, OpenCode and more, run and attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping API keys out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Cloud proxy sets the auth header for built-in AI services and custom hosts | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Where it runs | US, EU and APAC; open-source runtime and bring your own cloud on Enterprise | Regions not published; the same microVM also runs on your laptop | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | E2B | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | 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 | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | 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 | 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 | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | Yes | 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
E2B did 12.61 runs per second on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, and bochka did 26.69 in the same run, about twice as much CPU work. Docker Cloud Sandboxes has no comparable measurement: it launched in September 2026, is not in these 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. 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 | E2B, a month | Docker Cloud Sandboxes, 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 | $202 · Pro | $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 | $368 · Pro · 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,773 · Pro | $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,395 · Pro+ (600 concurrent) | $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 | $2,797 · Pro++ (1,100 concurrent) | $1,400 · Docker Agentic Platform (pay-as-you-go) · with limits | $2,000 · $2000/mo · with limits |
E2B: E2B bills per second for the vCPU and RAM you set, idle time included, until you pause or kill the sandbox. Pro costs $150 a month for higher limits with no usage credit, and each extra 500 concurrent slots cost $500 a 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. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Both E2B Pro and Docker end a session at 24 hours, so neither fits one agent that never stops. 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, while E2B covers all three with its Pro+ and Pro++ concurrency add-ons. E2B Pro includes 20 GiB of disk, and bochka's start limits are too low for a 1,000-job burst even on the $2,000 plan.
| Scenario | E2B | Docker Cloud Sandboxes | 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 E2B when
you run many short sandboxes at once for users, rollouts or code runs, and want memory pause, wake on request and a desktop.
- Hundreds of sandboxes at once. Teams serving many users or rollouts can run 100 sandboxes on Pro and up to 1,100 self-serve, against Docker's default of 10.
- Wake on request and memory forks. A paused sandbox comes back in about a second on the next request, and a running one can fork with its memory.
- A desktop and more places to run. E2B has a Linux desktop for computer use, runs in the US, EU and APAC, and its runtime is open source.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day.
- 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 either way.
- Bigger machines, no monthly fee. Sizes go up to 16 vCPU / 32 GiB, with arm64 on some accounts, billed per second with no plan to buy.
- Outbound rules with presets. Teams that must limit where an agent connects can start from allow-all, balanced or deny-all and add rules by host.
Where bochka fits
Both E2B and Docker Cloud Sandboxes stop every session at 24 hours and neither offers nested virtualization. If your agents run for days, build Android apps, need a desktop and a browser, or have to be driven from your own app, bochka gives each one a full VM that keeps going.
No 24-hour cutoff
On both E2B Pro and Docker, a session ends at 24 hours, so a multi-day agent has to be paused and resumed by your code. bochka has no session cap on paid plans and saves the disk every minute.
A whole machine, kernel access included
E2B does not support nested virtualization and Docker does not document it, so Android emulators and VMs cannot start. bochka exposes /dev/kvm, runs Docker with systemd, and did 26.69 CPU runs per second against E2B's 12.61.
Agents driven from outside, screen included
On Docker you attach to an agent's terminal from the sbx CLI, and on E2B you run it through the command API, so you parse its text yourself. bochka preinstalls seven agents with a prompt, steer and events API, plus a 60fps desktop.
Use bochka when your agents work for days or by the dozen, need Android emulators, a desktop or a browser, or have to be driven from your own app through an API. Compare it one to one: bochka vs E2B and bochka vs Docker Cloud Sandboxes.
Questions people ask
Is E2B cheaper than Docker Cloud Sandboxes?
For one coding agent on workdays, Docker costs $49 a month against $202 on E2B Pro for the same 4 vCPU / 8 GiB machine. For 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once, only E2B fits, because Docker allows 10 sandboxes at once by default. bochka costs $20 a month for the workday agent.
Which is faster, E2B or Docker Cloud Sandboxes?
Docker Cloud Sandboxes has not been measured on a comparable benchmark yet. E2B did 12.61 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.
Can E2B or Docker Cloud Sandboxes run longer than 24 hours?
Not in one session. E2B stops a sandbox after 24 hours on Pro, and Docker after 24 hours from creation; pausing or resuming starts a new timer on both. bochka has no session cap on paid plans.
Can I run Docker and Android emulators in each?
All three run Docker inside the sandbox, and Docker Cloud Sandboxes gives each one its own Docker Engine. E2B's docs say nested virtualization is not supported and Docker does not document it, while bochka exposes /dev/kvm for Android emulators and VMs.
How many sandboxes can I run at once?
E2B allows 100 on Pro and up to 1,100 self-serve with concurrency add-ons. Docker allows 10 by default with no published way to raise it. bochka's $20 plan runs 100, and higher plans go up to 2,000.
Do both keep memory when a sandbox stops?
Yes. E2B pauses with memory and resumes in about a second, and Docker keeps memory and files on stop. bochka saves the disk every minute and on stop, but resuming boots the machine again.
Try bochka
Install the CLI, then run bochka new.
Product preview