An isolated machine boots like any other, in milliseconds.

The console marks an isolated machine on its row.
A real machine as the sandbox
Containers share the host’s kernel, which is exactly the surface untrusted code attacks. A microVM gives the workload a kernel of its own, so the sandbox can allow everything a Linux server allows. Code in the sandbox can run Docker, load kernel modules, restartsystemd, edit /etc, open ports, and break the OS completely, and the damage stays inside that one machine.
The trade-off you’d expect, slow VM startup, is gone. A fresh machine boots in under 10ms and a fork lands in under 200ms, so per-task sandboxes feel like function calls.
One sandbox per task
Create a machine, run the untrusted work, delete it:- CLI
- TypeScript
- Python
Fleets for automation
Background jobs, runners, test matrices, agent fleets, and RL rollouts all want many disposable environments at once. Create them concurrently, and every one is hardware-isolated from the others and from the rest of your machines:- TypeScript
- Python
fromSnapshot: "my-toolchain" / from_snapshot="my-toolchain" alongside the same isolated flag. A fresh machine boots in under 10ms, so the fleet is up in seconds.
Disposable is one mode, and persistent is the other. boxd machines are persistent by default. A sandbox lives as long as you keep it, disk and all, which is exactly what a multi-tenant product wants: one long-lived isolated machine per customer. See Agentic SaaS.
Cut off from your fleet by design
Normally, machines you own share one private network, and each carries a pre-authenticated in-machineboxd CLI. That is convenient for your own machines and wrong for a sandbox, because code in the sandbox could reach your other machines.
A sandbox created with --isolated is cut off from all of that from birth. boxd leaves out everything that could reach into the rest of your organization: the in-machine boxd CLI, your integrations and the run CLI, your agent logins, and the bridge to your laptop. It never joins the default network and never reaches another isolated machine. It keeps outbound internet unless you set an egress allowlist, along with its public HTTPS domain, inbound SSH unless you turn it off, and its persistent disk, so it is a normal machine to work in that cannot see or act on anything else you own.
When a sandbox does need a controlled path to something of yours, a job queue or a shared database for example, grant it one explicitly with networks. An isolated machine reaches exactly the non-isolated machines it shares a named network with, and networking changes apply in real time, without a reboot:
--isolated is set at creation and cannot be changed afterward. Forks and machines created from its snapshots inherit it, so an isolated lineage stays isolated.Close the internet and SSH too
Isolation cuts a sandbox off from your fleet. For code you trust even less, close the other two ways in and out as well: an egress allowlist that names only what the sandbox needs (none for nothing at all), and SSH off, so nothing answers SSH for it. You drive the sandbox through exec and file transfers, which go through the boxd API and keep working.
- CLI
- TypeScript
- Python
FAQ
What stops code from breaking out of the sandbox?
What stops code from breaking out of the sandbox?
The microVM boundary. Code has root inside its own machine and no path to the host or to other machines. Internet egress is the only shared surface, and it can be confined to an allowlist;
--isolated removes the paths into your own fleet as well.How many sandboxes can I run at once?
How many sandboxes can I run at once?
The default cap is 50 machines per organization, and you can request a raise beyond that, usually granted same-day. See Resources and limits.
Can sandboxed code run Docker?
Can sandboxed code run Docker?
Yes. The machine has a real kernel and a real
systemd, so Docker works without nesting tricks. See Run Docker.