Every sandbox is a full Linux VM, not a container. Containers are faster to start and cheaper to run, so this needs some justification. It comes down to three things: isolation, Docker support, and persistent state.

What agents actually do in a sandbox

Most code sandboxes were designed to run a snippet, capture the output, and throw everything away. Containers are genuinely great at that. They start in milliseconds and you can pack thousands of them onto one host.

A coding agent doesn’t use its sandbox like that. It clones a repo, installs dependencies, starts Postgres, runs migrations, spins up a dev server, points a browser at it, breaks something, reads the logs, and keeps going like this for hours. It uses the sandbox the way a developer uses a laptop, so the sandbox has to behave like one.

The kernel problem

A container is not really a separate machine. It’s a normal process on the host that the kernel keeps walled off from everything else. All containers on a machine share that one kernel, so a single kernel bug can expose everyone on the machine. That trade is fine when you wrote the code yourself. It’s a much worse trade for agent code, which is generated on the fly, pulls in dependencies nobody reviewed, and occasionally comes from someone actively trying to break out.

A VM puts the boundary at virtual hardware instead. Each sandbox boots its own Ubuntu kernel on KVM. If something exploits the kernel inside the sandbox, it has exploited a guest kernel, and all it can reach is that VM’s virtual devices. The host isn’t sitting on the other side of a syscall.

This is why we’re able to give your agent full root access to do whatever it needs.

MicroVM sandboxes

Not every agent sandbox is a container. E2B and Vercel Sandbox run each sandbox in a Firecracker microVM. Modal offers a VM runtime next to its default gVisor runtime, and Daytona offers a VM class next to its default containers. A microVM also boots its own kernel, so it gets the same isolation boundary as boat.

The differences with boat are elsewhere. boat saves the disk with no code on your side, ships systemd, Docker, a desktop and coding agents in every sandbox, and has a lower list price per VM-hour than E2B or Vercel Sandbox at 4 vCPU / 8 GB. Vercel Sandbox bills busy CPU only, so a nearly idle sandbox can cost less there. Several microVM providers publish starts under a second (E2B 576 ms, Vercel Sandbox 421 ms, one at a time, in ComputeSDK's run of 7 August 2026); boat is not in that benchmark. Several also offer regions outside the EU or a memory snapshot. The comparison page lists each provider with sources.

Docker inside the sandbox

Most real projects need Docker at some point, usually to run a database, tests, or a browser. Inside a container sandbox, Docker doesn’t work out of the box, because you’d be running containers inside a container. The usual workarounds either give the sandbox access to the host’s Docker, or loosen the isolation the sandbox exists for.

In a VM or a microVM with its own kernel, Docker runs normally. On boat it comes preinstalled, and docker compose up runs like it would on your own machine.

Keeping state around

An agent that’s been working for a few hours has built up a lot: the repo is cloned, dependencies are installed, the database is migrated and seeded, credentials are configured. Throw that away between sessions and every session starts with setup instead of real work, and you pay for that setup again in both time and tokens.

A boat sandbox saves its disk every minute and when it stops. Stop it, resume it a week later, and the files and installed packages are back. Memory, running programs and /tmp are not saved, so a resume is like a reboot. A stopped sandbox keeps its disk for at least 14 days; save a snapshot to keep it longer. You can also fork a sandbox into a copy, uncommitted changes included. A fork of a running sandbox uses its last 1-minute snapshot. So if you want to try three different approaches to the same problem, you fork the sandbox three times and give each agent its own copy of the whole machine.

Side by side

Container sandboxMicroVM sandboxFull VM (boat)
KernelShared with the hostIts ownIts own
If the kernel gets exploitedA kernel bug can reach the host and other sandboxes on itThe attacker also needs a hypervisor bug to reach the hostThe attacker also needs a hypervisor bug to reach the host
DockerNeeds Docker-in-Docker or a host socket, which weakens the isolationRuns on several, e.g. E2B, Vercel Sandbox and Modal's VM runtimePreinstalled
Background servicesOften limited: most images have no init systemDepends on the imagesystemd, like any Linux machine
Files between sessionsVaries by providerPause and resume, or snapshots your code takesSaved every minute and at stop; kept at least 14 days when stopped
Cold startMillisecondsUnder a second for E2B and Vercel Sandbox (ComputeSDK, 7 August 2026)Not in the public start-time benchmarks we use

Where each one wins

Use containers when

your sandboxes live for seconds. Per-request code execution, evals, RL rollouts. Anything where cold start and density are what matter and the code never needs Docker or a kernel of its own.

Use a VM when

the work is actual software development. Long sessions, Docker, background services, real networking, state you want to keep. The few extra seconds of boot time are negligible when a session runs for hours.

The obvious objection to VMs is price, and it used to be a fair one. On boat, a 4 vCPU / 8 GB VM costs $0.036/hr, billed per second, from a $20 monthly plan. That plan buys about 555 hours of VM time for that month. It is the lowest list price per VM-hour among the providers on our dated price table. Below about $20 of use a month, a provider with a $0 plan or free credits costs less. A nearly idle sandbox can also cost less on a provider that bills only busy CPU. We also benchmarked boat against E2B, Daytona, exe, and Islo by having an agent build a full app on each.