E2B vs Runloop
Both give each agent its own small VM. E2B is built for short jobs that pause and resume with their memory, while Runloop's devboxes can run past a day and add arm64, Dockerfile builds and hostname allowlists.
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
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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 | Runloop: price rank | boat: 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 | 20th cheapest of 367 $8,152 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 a Runloop devbox with an idle policy can keep running; boat has no session cap on paid plans. | 51st of 366, with limits $5,348 a month | 32nd cheapest of 366 $10,194 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 suits many short code runs that start fast and pause with their memory between requests, and it ranks a little above Runloop here. | 37th cheapest of 345 $421 a month | 44th cheapest of 345 $525 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 | 23rd cheapest of 361 $2,354 a month | 26th cheapest of 361 $3,301 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 rollouts that branch from the same state; both rank near the top. | 2nd cheapest of 360 $9,384 a month | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 Runloop fits CI fully while E2B is a compromise, and boat's faster CPUs finish builds and tests sooner than either. | 337th of 377, with limits $1,429 a month | 121st cheapest of 377 $1,554 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither has a public IP or raw TCP, and E2B stops at 24 hours, so boat fits a dev box that runs all month better. | 192nd of 368, with limits $358 a month | 113th cheapest of 368 $410 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 Both ship a Linux desktop your agent can control; boat streams its desktop at 60fps and you can embed it in your app. | 32nd cheapest of 369 $1,342 a month | 39th cheapest of 369 $2,306 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 Runloop fits browser agents fully while E2B is a compromise here. | 100th of 367, with limits $746 a month | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 Both fit; Runloop can lock each devbox to a hostname allowlist, E2B filters by IP, CIDR or domain, and boat gives each one a full kernel with nested virtualization. | 11th cheapest of 360 $1,043 a month | 10th cheapest of 360 $770 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 | Runloop | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Micro-VM on a custom bare-metal hypervisor, plus a container layer | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 12.61 runs/s | 8.29 runs/s | 26.69 runs/s |
| Session length | Up to 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it with no documented cap | No cap on paid plans; you set the time to live |
| Pause and resume | Saves memory and disk; resume takes about 1 second with processes still running | Suspend keeps the disk (Pro plan only); shutdown ends the devbox | Disk saved every minute and on stop, on every plan; a stopped sandbox costs nothing |
| Wake on request | A paused sandbox can resume on the next HTTP request or SDK call | A suspended devbox wakes on an HTTP request to its tunnel (Pro) | No; a stopped sandbox is started by API |
| Fork | Fork a running sandbox with its memory, up to 20 copies per call | Manual disk snapshots of a devbox | Fork a running sandbox with its disk |
| Nested virtualization | Not supported | Not documented; Docker-in-Docker blueprints only | Yes, /dev/kvm for Android emulators and VMs |
| Images and architecture | Templates from a Docker image, x86_64 only | Blueprints built from Dockerfiles, x86_64 and arm64 | Templates from named snapshots, x86_64 only |
| Inbound access | HTTPS URL per port, public by default unless you turn on a token; no dedicated IP | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy; no public IP | 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 | Hostname allowlist with wildcards, or block all | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Agent gateways for any API endpoint with bearer, header or basic auth | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Templates and guides for many agents, run through the command API | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Seven agents preinstalled, driven from outside with a prompt, steer and events API |
| Where it runs | US by default; EU and APAC on Pro and above, enabled by support | Regions not documented or selectable | EU only (Germany, Finland, France), EU data residency |
| Self-hosting and own cloud | Open-source Apache-2.0 runtime, plus your own AWS, GCP or Azure on Enterprise | Deploy to VPC on AWS, GCP or Azure (Enterprise) | No |
Every feature Battleships tracks (43)
| Feature | E2B | Runloop | boat |
|---|---|---|---|
| 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 | 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 | No | 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 | Yes | 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 | 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 | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
All three were measured on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, in the same run (36498291449, 2026-09-29). boat did 26.69 runs a second, E2B 12.61 and Runloop 8.29, so E2B did about 1.5 times the CPU work of Runloop and boat about twice that of E2B. The test measures CPU work only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite.
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 | Runloop, 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 | $202 · Pro | $113 · Basic | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $368 · Pro · with limits | $429 · Basic | $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 | $5,268 · Basic | $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) | $1,441 · Basic | $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) | $3,184 · Basic | $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.
Runloop: Runloop bills per second for the CPU and memory you allocate while a devbox starts, runs, suspends or resumes, and bills its disk for its whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
Runloop: Plans start at $20 a month, and the whole fee is usage credit, billed per second while a sandbox runs. 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 always-on scenario, and Pro includes 20 GiB of disk with machines up to 8 GiB of RAM. Runloop publishes no concurrency cap for paid plans, and its disk tops out at 64 GiB. Neither publishes an egress price. boat's limit that bites is start rate: even its $2,000 plan caps starts per hour and per day, so 1,000 short jobs at once fits E2B Pro++ and Runloop but not boat.
| Scenario | E2B | Runloop | boat |
|---|---|---|---|
| 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 and wake on the next one, or you need the US or APAC, or an open-source runtime.
- Memory pause and wake on request. For short jobs that sleep between requests: a paused E2B sandbox comes back in about a second with its processes running.
- A faster CPU than Runloop. On the same benchmark at 4 vCPU / 8 GB, E2B did 12.61 runs a second and Runloop 8.29.
- Open source and more regions. Its runtime is Apache-2.0 and can run on your own host, and it runs in the US, EU and APAC.
Use Runloop when
your devboxes must run past a day, or you need arm64, Dockerfile blueprints, hostname allowlists or a deploy into your own cloud.
- Devboxes that outlast a day. With an idle policy in place of the 48-hour lifetime, a Runloop devbox has no documented cap, while E2B stops at 24 hours.
- arm64 and Dockerfile blueprints. Runloop builds images from Dockerfiles and offers arm64 machines, which helps teams that ship to arm64.
- No plan fee to start. Runloop's Basic plan is usage only, while E2B's higher limits come with a $150 Pro fee each month.
Where boat fits
If your agents do real work for hours, with installs, builds, tests, Docker and emulators, look at boat. Each sandbox is a full VM on dedicated AMD Ryzen 9 9950X hosts that ran the CPU benchmark about twice as fast as E2B and three times as fast as Runloop, with no session cap and files kept on every plan. E2B and Runloop still suit huge bursts of short jobs better.
A fuller Linux machine
Neither E2B nor Runloop documents /dev/kvm, so an Android emulator or a VM does not start at all. Both reach a sandbox only over HTTPS, so a server that speaks raw TCP has no way in.
Faster CPUs for every build
Agents spend most of their time waiting on installs, builds and tests. boat did 26.69 runs a second, E2B 12.61 and Runloop 8.29, so each of those waits is two to three times longer there.
Long runs with files kept
E2B stops a session at 24 hours, so your code has to pause and resume it. On Runloop a devbox is gone once it shuts down, so keeping its disk means paying the $250 Pro fee each month or snapshot code you maintain.
Use boat when your agents do real work for hours: installs, builds, tests, Docker and emulators, on a fast full VM with no session cap and files kept on every plan. Compare it one to one: boat vs E2B and boat vs Runloop.
Questions people ask
Is E2B cheaper than Runloop?
In most of our scenarios, yes: 50 agents in parallel cost $2,773 a month on E2B and $5,268 on Runloop. One coding agent on workdays is the exception, at $113 on Runloop versus $202 on E2B, and an agent that never stops fits Runloop but not E2B's 24-hour cap.
Which is faster, E2B or Runloop?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, E2B did 12.61 runs a second and Runloop 8.29. boat did 26.69 in the same run.
Can E2B or Runloop run Docker?
Yes, both run Docker inside the sandbox; on Runloop you use the Docker-in-Docker blueprints. Neither documents nested virtualization, so Android emulators and VMs need boat, which exposes /dev/kvm.
Can an E2B sandbox or a Runloop devbox run for days?
E2B stops a session after 24 hours on Pro, though pausing and resuming resets the clock. Runloop's fixed lifetime tops out at 48 hours, but an idle policy replaces it with no documented cap. boat has no session cap on paid plans.
Can I limit which hosts a sandbox can reach?
Yes on both. E2B allows or denies outbound traffic by IP, CIDR or domain, and Runloop allows only the hostnames you list, with wildcards, or blocks all. boat has no provider-side egress allowlist, so you filter inside the VM.
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