E2B vs smol machines
Both give each agent its own small Linux VM that can pause and fork with its memory. E2B is a hosted Firecracker cloud with US, EU and APAC regions and a 24-hour session cap, while smol machines has no session cap, bills only the CPU and memory a guest actually uses, and runs the same open-source VM on your laptop or your own servers.
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
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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 | smol machines: 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 | 73rd of 367, with limits $604 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 cap, while smol machines has no cap but no desktop or browser; boat has no cap and both built in. | 51st of 366, with limits $5,348 a month | 148th of 366, with limits $1,038 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 suit short code runs; smol machines has a one-minute minimum and bills used CPU and memory, while E2B pauses a sandbox with its memory and wakes it on the next request. | 37th cheapest of 345 $421 a month | 12th cheapest of 345 $140 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 Both wake a stopped sandbox on the next request; boat adds a desktop, hosting on up to 50 ports and a credentials proxy for each user. | 23rd cheapest of 361 $2,354 a month | 7th cheapest of 361 $531 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 Both fork a running machine with its memory, and E2B's high start rate and forks of up to 20 copies per call make it a strong fit for many short rollouts. | 2nd cheapest of 360 $9,384 a month | 111th of 360, with limits $6,978 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 | 36th cheapest of 364 $670 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 E2B nor smol cloud exposes nested virtualization, so CI jobs that build Android apps or boot VMs need boat's /dev/kvm. | 337th of 377, with limits $1,429 a month | 66th cheapest of 377 $514 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 runs all month hits E2B's 24-hour cap; smol machines can keep running but has no SSH, while boat has SSH, no cap and a dedicated IP. | 192nd of 368, with limits $358 a month | 216th of 368, with limits $29 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 smol cloud has none; boat streams its desktop at 60fps and can embed it in your app. | 32nd cheapest of 369 $1,342 a month | 90th of 369, with limits $156 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 smol machines documents running your own Chromium inside a machine, while boat ships Chromium ready for agents. | 100th of 367, with limits $746 a month | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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 | smol machines | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | libkrun microVM with its own guest 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 |
| Biggest machine | Up to 8 vCPU / 8 GiB self-serve, more on request | Up to 32 vCPU / 32 GB on Startup, 16 vCPU / 24 GB on Pro | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | Up to 1 hour on Hobby, 24 hours on Pro; pausing resets the clock | No provider cap; you can set your own time to live | No cap on paid plans; you set the time to live |
| Pause and wake | Pause with memory, resume in about 1 second, wake on the next HTTP request or SDK call | Checkpoints capture RAM to a file; a command starts a stopped machine and idle apps wake on the next request | Disk saved every minute and on stop; a stopped sandbox costs nothing and is started by API |
| Fork | Fork a running sandbox with its memory, up to 20 copies per call | Branch a running machine with its memory and processes; the one-minute minimum is paid once | Fork a running sandbox with its disk |
| Nested virtualization | Not supported | Not exposed in the cloud create API; a local smolvm flag only | Yes, /dev/kvm for Android emulators and VMs |
| Shell access | SDK command API; SSH supported | Command API and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | HTTPS URL per port, public by default unless you turn on a token; no dedicated IP | Up to 16 published ports through a returned URL or an authenticated connect route; no dedicated 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 | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Desktop and computer use | Linux desktop for computer use | No hosted desktop; a guide shows running your own Chromium inside a machine | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Keeping API keys out of the sandbox | Secrets injected into outbound HTTPS headers (private beta) | Cloud secrets are environment variables the guest can read; swapping exists only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | US by default; EU and APAC on Pro and above, enabled by support | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | Apache-2.0 runtime on your own KVM host, plus bring your own cloud on Enterprise | Open-source smolvm on macOS, Linux and Windows hosts, with the same .smolmachine artifact | No |
Every feature Battleships tracks (43)
| Feature | E2B | smol machines | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | 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 | Yes | 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 | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | 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 | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | Yes | Yes | 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 | 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
On the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, E2B did 12.61 runs per second and boat did 26.69, so boat did about twice the CPU work in the same time. smol machines has not been run on that test, so there is no comparable number for it. smol publishes a boot time under 200ms for smolvm, which measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. smol machines 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 | smol machines, 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 | $25 · Standard | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $368 · Pro · with limits | $93 · Standard | $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,139 · Pro | $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) | $465 · Startup | $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,389 · Startup | $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.
smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, and new accounts get $100 of credit once.
smol machines: 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 20 GiB of disk. smol machines caps how many machines you hold by plan: 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still using a slot. At 1,000 short jobs at once, E2B needs Pro++ and queues bursts above 300 starts a minute, smol needs Startup, and boat's plans cap starts per hour and per day, so boat does not fit that one.
| Scenario | E2B | smol machines | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use E2B when
you run many short jobs that pause between requests and wake fast, need a desktop for computer use, or must run in the US or APAC.
- Regions in the US, EU and APAC. Teams that must run close to users in the US or APAC can pick a region; smol cloud has no region choice.
- Wake in about a second. For jobs that sleep between requests, a paused sandbox resumes in about a second with its processes still running.
- A desktop for computer use. Computer-use agents get a Linux desktop on E2B, while on smol cloud you build and run your own.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, no session cap, and billing on the CPU and memory you actually use.
- No session cap. An agent can keep its machine running for days, while E2B stops a session after 24 hours on Pro.
- One VM from laptop to servers. Teams that want the same open-source VM locally, in a hosted cloud and on their own servers can use smolvm everywhere.
- Pay for what the guest uses. smol bills the CPU and memory a guest actually uses, so mostly idle machines cost less than their full size.
Where boat fits
E2B and smol machines are both built around small VMs that pause, fork and wake fast. If your agents do long, heavy work like builds, Docker, emulators and a browser, boat gives each one a whole, faster machine with coding agents and a credentials proxy built in.
A whole machine with /dev/kvm
Neither E2B nor smol cloud exposes nested virtualization, so Android emulators and VMs cannot start. smol cloud also has no SSH, and neither gives a dedicated IP; boat has all three, and ran the CPU test about twice as fast as E2B.
Runs as long as the work does
On E2B a long task hits the 24-hour cap and your code has to pause and resume it. smol has no cap, but a stopped machine keeps billing for disk and holds a plan slot; a stopped boat sandbox costs nothing.
Agents, desktop and keys built in
On smol cloud secrets are plain environment variables the agent can read, and E2B's header injection is a private beta. boat keeps keys in a proxy, preinstalls seven coding agents you drive from outside, and streams a 60fps desktop.
Use boat when your agents do real work for hours: installs, builds, tests, Docker, emulators and a browser, on a fast machine with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: boat vs E2B and boat vs smol machines.
Questions people ask
Is E2B cheaper than smol machines?
No, smol machines costs less in all five scenarios on this page. One coding agent on workdays is $202 a month on E2B and $25 on smol, and 50 agents in parallel is $2,773 a month on E2B and $1,139 on smol. boat is lower than both in every scenario except 1,000 short jobs at once, which its start limits do not fit.
Which is faster, E2B or smol machines?
There is no CPU score for smol machines to compare. On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, E2B did 12.61 runs per second and boat did 26.69.
Can E2B and smol machines run Docker?
Yes, both run Docker inside the VM; smol's guide says Docker data must live on the machine's ext4 disk. Neither exposes nested virtualization on hosted machines, so Android emulators and VMs need boat's /dev/kvm.
Can a sandbox run for days on E2B or smol machines?
Not in one E2B session: it stops after 24 hours on Pro and 1 hour on Hobby, though pausing resets the clock. smol machines has no provider cap, and boat has no cap on paid plans.
Are E2B and smol machines open source?
Both are. E2B's runtime is Apache-2.0 and can run on your own Linux host with KVM, and smol's smolvm engine runs on macOS, Linux and Windows hosts. boat is a hosted service only.
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