E2B vs exe.dev
E2B gives each agent session a Firecracker microVM that starts fast, pauses with its memory and stops after 24 hours on Pro. exe.dev rents KVM VMs that run until you stop them, from a monthly pool or by the second, but they are headless and have no snapshots.
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
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs long runs and builds; E2B cuts sessions at 24 hours, exe.dev has no desktop or snapshots, and bochka has both plus nested virtualization. | 16th cheapest of 367 $4,143 a month | 253rd of 367, with limits $3,701 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 hits E2B's 24-hour session cap, while exe.dev and bochka simply keep it running. | 51st of 366, with limits $5,348 a month | 15th cheapest of 366 $3,833 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 pause with their memory; exe.dev is not a code interpreter and fits only as a compromise. | 37th cheapest of 345 $421 a month | 235th of 345, with limits $175 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 E2B fits sandboxes for your users with high self-serve concurrency, exe.dev Personal caps you at 50 at once, and bochka adds token-protected URLs and a bigger, faster machine. | 23rd cheapest of 361 $2,354 a month | 257th of 361, with limits $1,226 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 suits many short rollouts that branch from the same state, thanks to memory forks and high concurrency; exe.dev Personal stops at 50 VMs at once. | 2nd cheapest of 360 $9,384 a month | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 Neither is a strong CI runner: E2B has no nested virtualization, and exe.dev pools bill whether jobs run or not. | 337th of 377, with limits $1,429 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev and bochka both make good 24/7 dev boxes with root, SSH and a disk that lasts; E2B's session cap makes it a poor fit. | 192nd of 368, with limits $358 a month | 25th cheapest of 368 $35 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 and bochka both have a Linux desktop for computer use, and bochka streams it at 60fps; exe.dev VMs are headless. | 32nd cheapest of 369 $1,342 a month | 240th of 369, with limits $1,055 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 | 100th of 367, with limits $746 a month | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | KVM VM with Cloud Hypervisor; you can't choose the kernel | 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 |
| Session length | Up to 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | No cap; VMs run until you stop them | No cap on paid plans; you set the time to live |
| Saved state | Pause saves memory and disk; resume in about 1 second with processes still running | Disk persists and is streamed to a second server; no snapshots | Disk snapshot every minute and on stop; resume boots the machine again |
| Fork | Fork a running sandbox with its memory, up to 20 copies per call | cp copies a VM's disk and config into a new VM | Fork a running sandbox with its disk; named snapshots as templates |
| Desktop and computer use | Linux desktop for computer use | Headless; no desktop or screen streaming | 60fps desktop with Chromium, computer use, browser control, embeddable stream |
| Nested virtualization | Not supported | Enterprise only | Yes, /dev/kvm on every plan for Android emulators and VMs |
| Custom images | Templates built from a Docker image | Boot each VM from your own Docker image | Templates from named snapshots; no Dockerfile or OCI images |
| Coding agents | Templates and guides for many agents, run through the command API | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Seven agents preinstalled, with one API to prompt, steer and stream events |
| Keeping API keys out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Integrations inject secrets at the network edge for any HTTP host | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Inbound access | HTTPS URL per port, public by default unless you turn on a token; no dedicated IP | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | 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 | Open internet, no provider-side allowlist | Open internet, no provider-side allowlist |
| Regions | US by default; EU and APAC on Pro and above, enabled by support | 9 regions in the US, Europe, Asia and Australia | EU only: Germany, Finland, France |
| Self-hosting and own cloud | Open-source runtime, plus bring your own cloud on Enterprise | Bring your own cloud and dedicated hardware on Enterprise | No |
Every feature Battleships tracks (43)
| Feature | E2B | exe.dev | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | No | 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 | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | Yes | 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 | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
E2B and bochka were measured in the same StarSling hpc-sandbox-benchmarks run, a Node.js build-and-test loop at 4 vCPU / 8 GB. E2B did 12.61 runs per second and bochka did 26.69, about twice as much CPU work in the same time. exe.dev is not in that run, so there is no comparable score for it, and we don't guess one.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev 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 | exe.dev, 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 | $35 · Personal | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $368 · Pro · with limits | $35 · Personal | $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 | $1,848 · Personal | $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) | $530 · Personal · 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,050 · Personal · 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 is $150 a month for higher limits with no usage credit, and each extra 500 concurrent slots cost $500 a month.
exe.dev: exe.dev Personal is a flat monthly pool from $15 (2 vCPU / 4 GB) to $155 (16 vCPU), billed whether your VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour, and pay nothing for CPU and memory while stopped.
exe.dev: Plans start at $20 a month, and the whole fee is usage credit. Sandboxes bill per second while they run, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
E2B caps a session at 24 hours on Pro, so it does not fit the agent that never stops, and Pro includes 20 GiB of disk. exe.dev Personal stops at 50 VMs at once, so it does not fit 300 user sandboxes or 1,000 short jobs at once. E2B Pro++ does fit 1,000 jobs at once, queueing bursts above 300 starts a minute, while bochka's start limits per hour and per day rule it out there.
| Scenario | E2B | exe.dev | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
| None that bite | 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 jobs that pause between requests, branch from shared memory state, or need outbound rules and an open-source runtime.
- Memory pause and wake on request. For jobs that sleep between requests: a paused sandbox wakes on the next call in about a second, processes still running.
- Built for many short jobs. For RL rollouts and code runs: fork a running sandbox with its memory, and run up to 1,100 at once self-serve.
- Outbound rules and open source. For teams that must limit what an agent reaches: allow or block hosts by IP or domain, on an Apache-2.0 runtime.
Use exe.dev when
you want persistent dev VMs that never time out, in regions outside Europe, booted from your own Docker image.
- VMs that never time out. For dev boxes and assistants that live all month: an exe.dev VM runs until you stop it, on a flat monthly pool.
- Nine regions. For users far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Your own Docker image and team controls. For teams with a Dockerfile: each VM boots from your image, and the Work plan adds SSO and roles.
Where bochka fits
If your agents do real work for hours, look at bochka. Each sandbox is a full VM with Docker, systemd and /dev/kvm, a 60fps desktop, a disk saved every minute and no session cap on paid plans. On the same CPU benchmark it did 26.69 runs per second to E2B's 12.61.
Long runs with a safety net
E2B stops a sandbox after 24 hours on Pro, so your code has to pause and resume it. exe.dev never stops it, but has no snapshots, so one bad agent step can cost a whole session's work.
Emulators and VMs inside
E2B does not support nested virtualization and exe.dev offers it only on Enterprise, so Android emulators and VMs can't start. bochka exposes /dev/kvm on every plan.
Drive agents inside from outside
On E2B you run agents through the command API, and on exe.dev only Shelley takes prompts. bochka ships seven agents with one API to prompt, steer and stream them, and keeps real keys outside.
Use bochka when your agents work for hours on a fast full VM: builds, tests, Docker, emulators, a desktop and a browser, with state saved every minute and one API to drive agents inside from outside. Compare it one to one: bochka vs E2B and bochka vs exe.dev.
Questions people ask
Is E2B cheaper than exe.dev?
No. exe.dev's monthly bill is lower in all five scenarios on this page, for example $35 against $202 for one coding agent on workdays. But exe.dev Personal fits only three of them, because it stops at 50 VMs at once, and bochka is lower than both in four.
Which is faster, E2B or exe.dev?
E2B did 12.61 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and exe.dev has not been measured. bochka did 26.69 on the same test.
Can E2B or exe.dev run Docker?
Both run Docker inside the machine. Neither gives you nested virtualization on self-serve plans: E2B does not support it, and exe.dev offers it only on Enterprise. bochka exposes /dev/kvm on every plan.
Can an E2B or exe.dev machine run for days?
An exe.dev VM runs until you stop it. E2B stops a sandbox after 24 hours on Pro and 1 hour on Hobby, though pausing and resuming resets the clock.
Do E2B and exe.dev have a desktop for computer use?
E2B has a Linux desktop for computer-use agents. exe.dev VMs are headless, reached over SSH and an HTTPS proxy. bochka streams a 60fps desktop with Chromium that you can embed in your app.
Where do E2B and exe.dev run?
E2B runs in the US by default, with EU and APAC on Pro and above. exe.dev has nine regions in the US, Europe, Asia and Australia. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview