Sandboxes compared at their sources
This page compares the sandboxes Stado drives, Boat (stado sandbox) and fleet-owned gVisor environments (stado sandbox fleet, Fleet-owned agent sandboxes), with E2B, Modal and Daytona, each read from its own documentation. A row states what the source says, not a name that sounds alike. "Read" means the vendor's documentation states it; "verified" is reserved for a capability a real run through Stado has shown, and no third-party row here is verified. "Missing" is a gap with its own outcome contract below; "not applicable" says why.
Sources: E2B sandbox lifecycle, E2B persistence, E2B snapshots, E2B metadata, E2B list, E2B internet access, E2B BYOC, E2B documentation index; Modal Sandboxes, Modal snapshots, Modal networking, Modal warm pool example, Modal Sandbox.create; Daytona sandboxes, Daytona persistence, Daytona GPU sandboxes, Daytona bring your own compute; Stado: stado sandbox --help, stado sandbox fleet --help and the fleet sandboxes page.
| Capability | Boat via stado sandbox |
Fleet gVisor via stado sandbox fleet |
E2B | Modal | Daytona |
|---|---|---|---|---|---|
| Isolation | Boat machine per sandbox (read from Stado's driver) | gVisor container, not a VM; no runc fallback |
Linux VM per sandbox (read) | Container (read) | Linux container by default; Linux VM, Windows, macOS and GPU classes (read) |
| Create from an image | create |
create --image IMAGE@sha256:… (immutable digest only) |
Template (read) | Image, named images recommended (read) | Snapshot or image with tag or digest; latest refused (read) |
| CPU and memory | Boat's offer | Explicit cores, RAM bytes, process ceiling, enforced by Docker; shared-host quota | Per template; info reports cpuCount, memoryMB (read) |
Requested CPU and memory; may burst above, billed at max(request, actual) (read) | Per snapshot class, from 1 vCPU / 1 GiB (read) |
| GPU | Missing in Stado's driver | create --gpus N: NVIDIA GPUs through gVisor's nvproxy, refused when runsc lacks --nvproxy |
Not stated on the lifecycle pages read | Yes (read) | NVIDIA and AMD classes; GPU sandboxes are ephemeral, no auto-pause (read) |
| Network | Boat's; host gives a port a public HTTPS URL |
none, or --egress HOST: only the declared hosts over HTTP(S), through the sandbox's own proxy on an internal network |
allowInternetAccess and network settings (read) |
Outbound policy, tunnels (read) | Own network stack (read) |
| Files in and out | read, write, download, file-url |
/workspace volume, read through exec |
Filesystem API (read) | Volumes, filesystem API (read) | Filesystem API (read) |
| Run a command | exec, exec --detach, process |
exec, exec --detach, logs |
Commands API (read) | exec with per-command timeout (read) |
Process API (read) |
| Stop and resume | stop saves the disk, resume from it |
stop ends processes and keeps the workspace; resume restarts, interrupted processes do not resume |
Pause keeps memory and filesystem; resume restores (read) | No resume; snapshot then a new sandbox (read) | Stop, start; pause and resume on VM classes (read) |
| Snapshot and fork | fork from a sandbox's disk |
fork from a stopped sandbox: same image, limits and lifetime, workspace copy kept only when a digest of every file matches; no named snapshot object |
Snapshots: the sandbox keeps running; many sandboxes from one (read) | Filesystem, directory and memory snapshots as images; exit snapshots (read) | Fork on VM classes; snapshot from sandbox (read) |
| Archive | Missing | Not applicable: the workspace stays on the host | Not stated | Not applicable: snapshots are images | Auto-archive moves a stopped sandbox's filesystem to object storage (read) |
| Lifetime limits | update changes or clears when it stops by itself |
create --stop-after-seconds N stops it by itself N seconds after each start, workspace kept; none without it |
Up to 24 h (Pro) or 1 h (Hobby) running; pause resets the window (read) | Default 5 min, up to 24 h; idle timeout (read) | Auto-stop after inactivity, auto-archive after being stopped (read) |
| Observability | events, usage, show |
show returns Docker's inspection; execution state files |
getInfo (read) |
Lifecycle events, readiness probes, poll exit code (read) |
Sandbox states (read) |
| Cost | usage prints what a sandbox ran and cost |
usage measures CPU time, peak memory, processes and workspace size since the last start; provider cost of the host, no retail price |
Per plan (read) | Per-second pricing page (read) | Per class (read) |
| Delete | delete |
delete --confirm NAME, verified absent |
kill (read) |
terminate (read) |
Delete (read) |
| Interactive agent | prompt, steer, interrupt, desktop stream |
Missing | Not stated | Not stated | macOS class with computer use, VNC, SSH (read) |
| Where it runs | Boat's machines | Placed by Stado across registered Linux hosts without --host: the host with the declared cores, RAM and GPUs free and the most free RAM; found by name for every other operation (Placement across the fleet) |
E2B Cloud, or BYOC in the customer's AWS, Google Cloud or Azure VPC for Enterprise (read) | region and cloud on Sandbox.create (read) |
us and eu regions; custom regions with the customer's runner nodes (read) |
| Names, labels and lookup | Boat id | Name unique across the fleet, found on any host; no labels | Metadata key-value pairs; list filtered by state and metadata (read) | Named sandboxes, one running per name in an App; up to 10 tags, list filtered by tag (read) | Labels; get by id or name (read) |
| Warm pool | Missing | Missing | Not stated | Example pool of warm sandboxes behind a readiness probe (read) | Not stated |
| Readiness | Missing | Missing | Start and ready commands in templates (read) | Readiness probes on a port or a command (read) | Wait for state (read) |
| Idle stop and auto-delete | update --ttl-seconds |
--stop-after-seconds from each start; no idle measure, no auto-delete |
Timeout with auto-pause; auto-resume on request (read) | idle_timeout: no command, stdin or tunnel connection (read) |
Auto-stop after inactivity, auto-archive, auto-delete, ephemeral, wall-clock TTL (read) |
| Resize | Missing | update CPU, RAM and process ceilings, running |
Not stated | Not stated | CPU and memory up while running; down, and disk up, while stopped (read) |
| Volumes shared across sandboxes | Missing | Missing: each workspace is its own | Volumes mounted at custom paths (read) | Volumes (read) | Not stated on the pages read |
| Sandboxes that reach each other | Missing | Missing | Not stated | Not stated | Linked sandboxes on the parent's runner, one link network (read) |
| Outbound secret injection | Missing | Missing: --credential hands a value to the command |
Secrets injected into outbound HTTPS outside the sandbox (read) | Secret injection (beta) (read) | Not stated |
| Egress lists | Boat's | Allow-list of host names through the sandbox's proxy | Allow and deny lists of IPs, CIDRs and domains (read) | Outbound access control, CIDR allow-list (read) | Not stated on the pages read |
| Lifecycle events to a URL | webhook |
Missing | Lifecycle webhooks (read) | Lifecycle events (read) | Not stated |
Gaps and their outcome contracts
- GPU in a Stado-driven sandbox. Delivered for fleet sandboxes (
create --gpus N,tests/sandbox/gpu.mjs); the Boat driver has none. - Fleet sandbox snapshot and fork. Delivered as
forkof a stopped sandbox; a named snapshot a new sandbox starts from is still missing. - Fleet placement. Delivered: without
--hosta sandbox goes to the host with room and is found by name. Still missing: a sandbox's hold seen bystado capacity, and moving a sandbox to another host when its host is short. - Fleet labels and filtered list. A caller attaches key-value labels at
createand lists sandboxes across the fleet filtered by them, so an agent finds its own. - Fleet files and ports. A caller reads and writes a file in a sandbox without
exec, and gives a port inside it a URL another host reaches. - Fleet idle stop and auto-delete. A sandbox stops when no command has run for a declared time, and an ephemeral one is deleted when it stops.
- Fleet warm pool and readiness. A declared number of sandboxes from one image stand ready, each having passed a declared readiness command, and
create --from-poolhands one out at once. - Fleet volumes and links. A named volume mounts into several sandboxes; sandboxes of one group reach each other on a private network.
- Cloud overflow. When no registered host has room, a sandbox is placed on a cloud host Stado starts under the operator's Azure credit floor, and the receipt names the host and its price.
- Boat archive. A stopped Boat sandbox kept beyond a user-declared interval moves to cheaper storage and resumes with the same disk; until Boat offers it, Stado says so instead of pretending.
- Fleet interactive agent. Out of scope for gVisor environments without a desktop; recorded as not applicable unless a fleet image declares one.
A third-party "read" cell becomes "verified" only through a real run Stado records, the same as for its own drivers; none is claimed here.
Source: this website