# boxd and the other agent sandboxes

> boxd is a full VM that stays, made of parts that fit together: your app is still running when it wakes, a new machine starts with your stack up, and the coding agents are already there. Below: when to pick which, a matrix of 6 providers, and a page per provider with every claim sourced.

Checked 2026-10-30. Web page: https://boxd.sh/compare/

## Which one, when

| Provider | Pick it when | Pick boxd instead when |
| --- | --- | --- |
| [E2B](https://boxd.sh/compare/e2b/) | You run thousands of short code executions | Your agent or app runs for hours or days |
| [Daytona](https://boxd.sh/compare/daytona/) | You need GPUs, Windows or macOS | You want a full VM without choosing a class |
| [Modal](https://boxd.sh/compare/modal/) | You need GPUs | Your work runs past 24 hours or should pick up where it stopped |
| [Vercel Sandbox](https://boxd.sh/compare/vercel-sandbox/) | Your app already lives on Vercel | Your services have to keep running between requests |
| [Blaxel](https://boxd.sh/compare/blaxel/) | You want the fastest resume for very short sessions | You need a durable disk on the machine itself |
| [Cloudflare Sandbox](https://boxd.sh/compare/cloudflare-sandbox/) | You run short code executions from a Worker | Your work needs a disk that stays |
| [Runloop](https://boxd.sh/compare/runloop/) | Not an option: shutting down 13 November 2026 | You need a new home for devboxes before 13 November |

## What boxd is

- **A full computer, not a container.** Every boxd machine is a VM with its own kernel, root, systemd, Docker and nested virtualization. It starts at 2 vCPU, 8 GiB and 100 GB of disk and goes to 8 vCPU and 32 GiB without asking.
- **Composable.** Machine specs describe a ready machine in code, snapshots keep it warm, disks outlive it, a private network joins your machines, more than 100 integrations and automations run code on a schedule or an event, and any machine can create and drive others, signed in as itself. The same parts are in the CLI on your laptop, the CLI inside every machine, the Python and TypeScript SDKs, the API and the console.
- **Your app is still running when it wakes.** A sleeping machine keeps its memory. An HTTPS or SSH request wakes it, and the app answered in 156 ms, the same process, nothing restarted.
- **New machines start with your stack up.** Set a machine up once and snapshot it. A machine created from that snapshot answered its first request 1.19 s after the create command.
- **Coding agents built in.** Claude Code, Codex and OpenCode on every machine, with headless Chrome, a desktop in the browser and Docker. API keys stay outside: the machine holds a placeholder and our proxy swaps in the real value.
- **No session limit.** A machine runs until you delete it. It sleeps when idle and wakes on the next request.
- **Reachable like a server.** Plain SSH on its own port, an HTTPS URL per port, custom and wildcard domains, raw TCP and UDP ports, and Tailscale or NetBird for your company network.
- **You pay for what's used.** RAM on memory in use, disk on what's written, and a hibernated machine pays only for its disk. No plan fee.
- **Self-host it.** Free up to 16 vCPUs on your own Google Cloud or AWS account, the same release as boxd cloud.

## All providers

|  | boxd | E2B | Daytona | Modal | Vercel Sandbox | Blaxel | Cloudflare Sandbox |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **The machine** |  |  |  |  |  |  |  |
| Full VM, own kernel | Yes, every machine | Yes, Firecracker | Container by default; VM class opt-in | gVisor by default; VM runtime option | Yes, Firecracker | Yes, microVM | Container inside a Firecracker VM |
| Largest, self-serve | 8 vCPU · 32 GiB | 8 vCPU · 8 GiB (more via support) | 4 vCPU · 8 GiB (org default) | Not published | 8 vCPU · 16 GB on Pro | Per tier, shown in console | 4 vCPU · 12 GiB · 20 GB |
| CPU test (runs/s) | 12.6 (our run) | 11.08 | 21.52 (VM class) | 15.48 (VM) · 12.6 (gVisor) | 12.66 | 18.03 | Not measured |
| **Composable** |  |  |  |  |  |  |  |
| Ready machine described in code | Machine specs, built on one another | Templates in code, extendable | Declarative builder; not for VMs | Image builder, chainable | OCI images and snapshots | Images, branchable | Dockerfile; config in your code |
| Machines create machines | Yes, signed in as the machine | You pass an API key in | Not published | Not published | You pass a token in | SDK signs in on Blaxel | Not published |
| Built-in integrations | 100+, credentials kept out | MCP gateway; your own keys | No | Secrets only | Vercel Connect, platform-wide | ~30, as MCP servers | Your Worker holds tokens |
| Schedules and event triggers | Cron and events; sleeps between runs | No; wake on HTTP only | Lifecycle webhooks only | Through Modal Functions | Through Vercel Cron Jobs | Schedules, job triggers | Through Workers Cron Triggers |
| Private network between machines | Org network, split by tags | Public URLs only | Parent and child sandboxes only | Functions only | Not published | Not published | Not published |
| **Ready when you are** |  |  |  |  |  |  |  |
| Sleeps with processes kept | Yes, standby and hibernate | Yes, pause keeps memory | VM class only | No; no stop and start | No; disk only | Yes, standby | No; disk is wiped |
| Wakes on a request | Yes, HTTPS or SSH · app answers in 156 ms | Opt-in auto-resume on HTTP | No; build your own proxy | Not published | On SDK calls, not traffic | Implied, not documented | Your Worker starts a new instance |
| Starts from a snapshot, app running | Yes · app answers in 1.19 s | Yes, templates restore running | VM class only | Memory snapshots in alpha | Disk snapshots; processes restart | Private preview (Carbon) | Filesystem only |
| Session limit | None | 1 h Hobby · 24 h Pro | Stops after 15 idle min | 24 h maximum | 45 min Hobby · 24 h Pro | None stated | No cap, no guarantee |
| **Built for agents** |  |  |  |  |  |  |  |
| Coding agents installed | Claude Code, Codex, OpenCode | Claude Code and Codex templates | Claude Code, Codex, OpenCode | Not published | Claude Code, Codex, OpenCode, Pi | Opt-in Claude Code and Codex images | Install them yourself |
| SSH | Native, own port per machine | WebSocket proxy you set up | Token through their gateway | `modal shell` only | SSH-like CLI shell | CLI terminal; SSH via Tailscale | Through wrangler |
| **Price** |  |  |  |  |  |  |  |
| vCPU-hour | $0.047, CPU used | ≈$0.050 + plan fee | $0.0504, reserved | ≈$0.071, ×1.15–1.75 pinned | $0.128 per active CPU-hour | Included in RAM price | $0.072 active only + $5/mo plan |
| **Also worth knowing** |  |  |  |  |  |  |  |
| GPUs | No | No | Yes, H100 to B300 | Yes, T4 to B300 | Not published | Not published | No |
| Regions | Frankfurt (US waitlist) | US West ×2, EU, Asia-Pacific | US, EU | ~20 incl. US, EU, Asia | 19 worldwide | Oregon, Virginia, London, Frankfurt | Global |
| Self-host | Yes, free to 16 vCPUs | Single node (E2B Embed) | Repo archived; BYOC only | No | No | Your metal, their control plane | No |

Each provider's page has every row with a link to that provider's own docs.

## One by one

- [boxd vs E2B](https://boxd.sh/compare/e2b/index.md): E2B runs short-lived sandboxes from an SDK, with a time limit on every run. A boxd machine is a full computer that stays, wakes on a request with your app still running, and comes with coding agents installed.
- [boxd vs Daytona](https://boxd.sh/compare/daytona/index.md): A Daytona sandbox is a container unless you pick its VM class. Every boxd machine is a full VM with its own kernel, starts at 2 vCPU and 8 GiB, and keeps your app running while it sleeps.
- [boxd vs Modal](https://boxd.sh/compare/modal/index.md): Modal sandboxes are short-lived, end after 24 hours at most, and can't be stopped and started again. A boxd machine stays until you delete it and sleeps with your app running.
- [boxd vs Vercel Sandbox](https://boxd.sh/compare/vercel-sandbox/index.md): Vercel Sandbox runs sessions of up to 24 hours and brings back the disk, not the running processes. A boxd machine keeps its memory while it sleeps, so your app is still running when a request wakes it.
- [boxd vs Blaxel](https://boxd.sh/compare/blaxel/index.md): Blaxel sandboxes suspend within seconds and resume fast, with the filesystem held in memory. A boxd machine is a full computer with a 100 GB disk, plain SSH and coding agents installed.
- [boxd vs Cloudflare Sandbox](https://boxd.sh/compare/cloudflare-sandbox/index.md): Cloudflare Sandbox gives your Worker a container on the edge, with a disk that's wiped when it stops. A boxd machine is a persistent VM with its own disk, SSH and URL, that you can use without writing a Worker.
- [Moving off Runloop](https://boxd.sh/compare/runloop/index.md): Runloop is winding down, with transition support ending on 13 November 2026. boxd keeps what Runloop devboxes did and adds memory: a machine wakes on a request with your processes still running.
- [boxd vs exe.dev](https://boxd.sh/blog/boxd-vs-exe-dev/)
- [boxd vs sprites.dev](https://boxd.sh/blog/boxd-vs-sprites/)

## How we measured

boxd's timings were measured on its production cluster on 2026-10-29, ten runs each, from a client in the same datacenter: a hibernated machine's app answered an HTTPS request in 156 ms median; a new machine from a snapshot answered 1.19 s after the create command.

### Wake from hibernation

A small Python HTTP server on a default 2 vCPU machine, published on its HTTPS URL. Ten times: hibernate the machine, confirm it reports hibernated, then send one HTTPS request on a new connection from a client machine in the same datacenter. Median 156 ms until the app answered (104–213 ms); a warm request takes about 73 ms, so waking adds about 80 ms. The app's process ID was the same after every wake.

### New machine from a snapshot

A snapshot of that machine with the server running. Ten times: run `boxd new --from-snapshot`, then request the new machine's HTTPS URL until the app answers. Median 1.19 s from the create command to the app's first response (1.14–1.24 s). The first request succeeded every time; nothing was started after boot.

### CPU

The Node.js web tooling test from StarSling's open sandbox benchmark (Phoronix Test Suite 10.8.4, pts/node-web-tooling-1.0.1, Node 22.23.1, two passes per run), on a 4 vCPU machine. Three runs: 12.65, 12.86 and 12.19 runs/s. The other providers' numbers are from StarSling's own published leaderboard, which runs 4 vCPU / 8 GiB; boxd's 4 vCPU size has 16 GiB, which this test doesn't use.

### What these numbers don't include

Your own network distance. Every timing was taken from a client in the same Frankfurt datacenter; from the US, add your round trip on top. A larger app has more memory to bring back, so it takes longer than a small server.