E2B vs Agent 37
E2B gives each job a Firecracker microVM that starts fast, pauses with its memory and stops after 24 hours on Pro. Agent 37 gives each user a lighter gVisor sandbox that runs with no time limit, sleeps when idle and costs far less per hour.
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
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 16th cheapest of 367 $4,143 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent 37 ranks first here: its sandboxes run with no time limit and sleep between messages, while E2B's 24-hour cap on Pro makes an always-on assistant pause and resume. | 51st of 366, with limits $5,348 a month | Cheapest of 366 $279 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 Both fit short code runs; Agent 37 ranks first on price, and E2B resumes a paused sandbox with its memory in about a second. | 37th cheapest of 345 $421 a month | Cheapest of 345 $22 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 with up to 1,100 sandboxes at once on Pro++, while Agent 37 stops at 200 instances, sleeping and stopped ones included; bochka ranks first here. | 23rd cheapest of 361 $2,354 a month | 30th of 361, with limits $79 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 ranks 2nd: its memory forks and high start rate suit many short rollouts that branch from the same state. | 2nd cheapest of 360 $9,384 a month | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 Agent 37 ranks 2nd and bochka ranks 4th; E2B is a compromise because it has no nested virtualization and caps sessions. | 337th of 377, with limits $1,429 a month | 2nd cheapest of 377 $84 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A machine kept around the clock fits Agent 37 and bochka, which have no session cap; E2B stops it after 24 hours on Pro. | 192nd of 368, with limits $358 a month | 3rd cheapest of 368 $12 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 Agent 37 ranks first, E2B has a Linux desktop for computer use, and bochka streams a 60fps desktop you can embed in your app. | 32nd cheapest of 369 $1,342 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 Agent 37 ranks first and bochka ranks 2nd; bochka can also fork a running attempt to try many paths at once, which Agent 37 cannot. | 11th cheapest of 360 $1,043 a month | Cheapest of 360 $43 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 | Agent 37 | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | gVisor sandbox by default; full VM as an opt-in type | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Yes, inside the sandbox | Only on the VM type, at 2.5x the default compute rate | Yes, in every sandbox |
| Nested virtualization | Not supported | /dev/kvm on the VM type, with an Android template | /dev/kvm in every sandbox, Android emulator works |
| CPU benchmark (4 vCPU / 8 GB) | 12.61 runs/s | No published result | 26.69 runs/s |
| Session length | Up to 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | No time limit; runs until you stop it or it sleeps | No cap on paid plans; you set the time to live |
| Sleep with memory | Pause keeps memory; resume in about 1 second, or on the next request | Opt-in auto-sleep keeps memory; wakes on the next request | 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 | No fork; backups restore onto the same instance only | Fork a running sandbox with its disk |
| Coding agents | Templates and guides for many agents, run through the command API | Hermes, OpenClaw, Claude Code, Codex and more, with a chat API per instance | Seven agents preinstalled, with a prompt, steer and events API |
| Keys kept out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Its own managed models, search and Composio; your own keys go in as env vars | Proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Desktop | Linux desktop for computer use | noVNC desktop through a template build or the Ubuntu VM template | 60fps desktop and Chromium in every sandbox, embeddable stream |
| Inbound access | HTTPS URL per port, public by default; no dedicated IP | HTTPS URL per port, signed URLs, custom domains; no public IP | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6 |
| Outbound rules | Allow and deny lists by IP, CIDR or domain | No provider-side allowlist | Open internet, no provider-side allowlist |
| Regions | US by default; EU and APAC on Pro and above | United States | EU only (Germany, Finland, France), EU data residency |
| Self-hosting | Open-source runtime, plus bring your own cloud on Enterprise | No | No |
Every feature Battleships tracks (43)
| Feature | E2B | Agent 37 | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | 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 | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and E2B did 12.61 in the same run, so bochka did about twice the CPU work. Agent 37 has no published result on that benchmark, so there is no comparable measurement for it. Agent 37 says its default instances share host resources, and its Performance type runs on dedicated cores.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Agent 37 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 | Agent 37, 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 | $6 · Wallet (any top-up) | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $368 · Pro · with limits | $12 · Wallet (any top-up) | $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 | $329 · Wallet ($100 lifetime top-ups) | $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) | $33 · Wallet ($250 lifetime top-ups) · 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) | $73 · Wallet ($250 lifetime top-ups) · 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 more concurrency costs $500 a month per 500 slots.
Agent 37: Agent 37 uses a prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while asleep. Performance compute costs 4x and VM compute 2.5x the default rate.
Agent 37: 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
E2B caps a session at 24 hours on Pro, so it does not fit the agent that never stops, and Pro includes only 20 GiB of disk. Agent 37 counts sleeping and stopped instances toward a cap of 200 on its top self-serve tier, so it does not fit 300 user sandboxes at once or the 1,000-job burst. The 50-agent scenario needs Docker, so Agent 37 is priced on its VM type at 2.5x the compute rate. bochka stops at the burst too, because its plans cap starts per hour and per day.
| Scenario | E2B | Agent 37 | 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 E2B when
you run many short jobs that pause between requests, fork with their memory, or must run in the US or APAC.
- Pause, wake and fork with memory. For short jobs that sleep between requests: a paused sandbox resumes in about a second, and a running one forks with its memory.
- Big bursts and outbound rules. For many short jobs at once: Pro++ holds 1,100 sandboxes, and you can limit which hosts each one reaches.
- Open source and more regions. Its runtime is Apache-2.0, Enterprise runs in your own cloud, and it serves the US, EU and APAC.
Use Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory and wake on the next message.
- Always on, asleep when idle. For one assistant per user: an instance has no time limit, sleeps when quiet, keeps its memory and wakes on the next message.
- Low per-minute rates. For small, mostly idle machines: a prepaid wallet with no plan fee, billed by the minute at low rates.
- Your Docker image, dedicated cores. It builds templates from your own Docker image, and sells a Performance type on dedicated cores for steady speed.
Where bochka fits
E2B and Agent 37 both shine when sandboxes are short or mostly asleep. If your agents do real work for hours, with installs, builds, Docker, emulators and a browser, bochka gives each one a full, fast VM with no session cap on paid plans. It also keeps your API keys outside the machine for any HTTPS API.
A full VM is the default
Every bochka sandbox has its own kernel, systemd, Docker and /dev/kvm. E2B cannot run Android emulators or VMs at all, and on Agent 37 Docker needs the VM type, which costs 2.5x and has no init system.
About twice E2B's CPU speed
On the same Node.js build-and-test benchmark, bochka did 26.69 runs per second and E2B did 12.61, so every install and test waits half as long. Agent 37 has no result, and its default type shares cores.
Keys stay outside for any API
bochka's proxy keeps real keys out of the sandbox for any HTTPS API. On Agent 37 your own keys sit inside as env vars, and E2B's secret injection is still a private beta.
Use bochka when your agents do real work for hours: installs, builds, tests, Docker and emulators on a fast full VM, with keys kept outside for any API. Compare it one to one: bochka vs E2B and bochka vs Agent 37.
Questions people ask
Is E2B cheaper than Agent 37?
No. Agent 37 costs less in every scenario on this page, for example $6 against $202 a month for one coding agent on workdays. But Agent 37 does not fit 300 user sandboxes at once or the 1,000-job burst, because its self-serve cap is 200 instances.
Which is faster, E2B or Agent 37?
E2B did 12.61 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB. Agent 37 has no published result, so they cannot be compared directly. bochka did 26.69 runs per second on the same test.
Can E2B and Agent 37 run Docker?
E2B runs Docker inside its sandboxes, but its docs say nested virtualization is not supported. Agent 37 runs Docker only on its VM type, at 2.5x the default compute rate. bochka runs Docker and /dev/kvm in every sandbox.
Can a sandbox run for days?
Not in one E2B session: it stops after 24 hours on Pro and 1 hour on Hobby, though pausing resets the clock. Agent 37 has no time limit, and bochka has no session cap on paid plans.
Where do E2B and Agent 37 run?
E2B runs in the US by default, with EU and APAC on Pro and above, enabled by support. Agent 37 runs on dedicated servers in the United States. bochka runs only in the EU, in Germany, Finland and France.
How many sandboxes can run at once?
E2B goes up to 1,100 at once on its Pro++ self-serve plan. Agent 37 stops at 200 instances, counting sleeping and stopped ones, and asks you to email for more. bochka plans go up to 2,000 at once.
Try bochka
Install the CLI, then run bochka new.
Product preview