Agent Sandboxesagentsandboxes.org
Sandbox profile · Open-source project

Zeroboot

Answer in brief

Apache-2.0 Rust exec server that forks a pre-warmed Firecracker snapshot into a new copy-on-write KVM VM for every code run, with Python and TypeScript SDKs. A prototype snapshot-forking exec server for stateless, sub-millisecond-spawn code runs, self-hosted on Linux with KVM.

By the Agent Sandboxes editors · Updated

Overview

Zeroboot is an Apache-2.0 server written in Rust that runs untrusted code snippets for AI agents in VMs created by copy-on-write forking. A template is made once by booting a Firecracker VM, pre-loading a runtime and snapshotting its memory and CPU state; each request then creates a new KVM VM, maps the snapshot memory with MAP_PRIVATE and restores the CPU state, which the README benchmarks at a 0.79 ms p50 spawn (vendor benchmark). The HTTP API offers /v1/exec and /v1/exec/batch for Python (the default) and Node.js/JavaScript, plus health and Prometheus metrics endpoints, with optional API-key auth rate-limited at 100 requests per second per key. Python and TypeScript SDKs wrap the API, and it self-hosts on any Linux machine with KVM.

The README calls the project a "Working prototype" whose fork primitive, benchmarks and API are real but "not production-hardened yet". Documented limitations: one vCPU per fork, no networking inside forks, userspace random-number generators that need explicit reseeding per fork because forks share the snapshot's CSPRNG state, and a full re-snapshot for template changes. Each exec has a 30-second default timeout and no state carries between runs. A managed API is in early access with no pricing published; zeroboot.dev redirects to the GitHub repository.

Notable

  • Created in March 2026 by Adam Miribyan; no tagged release (the changelog lists 0.1.0 as untagged); 2,483 GitHub stars at verification.
  • README benchmark table: 0.79 ms p50 and 1.74 ms p99 spawn, ~265 KB per sandbox (vendor benchmark).
  • Status in the README: "Working prototype", "not production-hardened yet".

Zeroboot specifications

AttributeDetails
IsolationEach execution runs in its own KVM virtual machine forked from a Firecracker template snapshot: snapshot memory is mapped copy-on-write with mmap(MAP_PRIVATE) and CPU state is restored, so forks cannot see each other's writes (hardware-enforced via Intel VT-x/AMD-V)
DeploymentOpen-source project · Self-hostable
Open sourceYes (Apache-2.0)
SDKs and interfacesPython, JavaScript/TypeScript, REST API
Cold start (vendor claim)README (vendor benchmark): spawn latency p50 0.79 ms and p99 1.74 ms; fork plus Python exec ~8 ms; 1,000 concurrent forks in 815 ms; ~265 KB of memory per sandbox
Max session lengthEach exec has a timeout_seconds parameter that defaults to 30 seconds; a maximum and long-lived sandboxes are not documented
PersistenceNone between runs: every exec forks fresh from the template snapshot. Templates (for example Python with numpy and pandas pre-loaded, or Node.js) are built once by booting Firecracker and snapshotting memory and CPU state (~15 s); template updates require a full re-snapshot
GPUNot documented
NetworkingNo networking inside forks; sandboxes communicate with the host over serial I/O only (README known limitations)
PricingFree to self-host under Apache-2.0. A managed API at api.zeroboot.dev is offered as early access through a sign-up form; no pricing published
Free tierFree to self-host; the README includes a demo key for the managed endpoint
ComplianceNot documented
RegionsNot documented
Company headquartersNot documented

Facts from Zeroboot’s public documentation, verified November 18, 2026. Performance numbers are vendor claims.

Strengths and trade-offs

Strengths

  • You run large numbers of short, independent Python or Node.js snippets and want a separate VM for each one.
  • You want a small, self-hostable exec server with a two-endpoint HTTP API and batch execution.
  • You want each run isolated by KVM rather than by a container or namespace.

Trade-offs

  • Labelled a working prototype that is not production-hardened.
  • No networking inside forks and a single vCPU per fork.
  • No state carries between runs; long-lived sandboxes are not documented.
  • Userspace PRNGs must be reseeded per fork, and the managed API has no published pricing.

Good fit for: Very high-rate, short Python or Node.js snippet execution where each call gets its own VM.

How Zeroboot compares

SandboxCompany HQIsolationOpen sourceSelf-host / BYOCCold start (vendor)Max sessionSnapshots / pauseGPUSDKs
ZerobootNot documentedCoW KVM fork of Firecracker snapshotYesYes / Not documented0.79 ms p50 (claim)30 s default timeoutNot documented / Not documentedNot documentedPython, JavaScript/TypeScript, REST API
smol machines (smolvm)Not documentedlibkrun microVMYesYes / Not documented<200 ms (claim)Not documentedYes / YesYesJavaScript/TypeScript, Python, Rust, Go, CLI, REST API
FirecrackerUnited StatesKVM microVMYesYes / No<125 ms (spec)Not documentedYes / YesNot documentedREST API, CLI
E2BUnited StatesFirecracker microVMYesYes / YesNot documented1 h / 24 h (Pro)Yes / YesNoPython, JavaScript/TypeScript
MicrosandboxNot documentedMicroVM (libkrun)YesYes / Yes<100 msNot documentedYes / Not documentedNot documentedTypeScript, Python, Rust, Go, Ruby, CLI, MCP server
DaytonaUnited StatesContainers or VMsNoNot documented / Yes<90 msUnlimitedYes / YesYesPython, TypeScript, Ruby, Go, Java

Head-to-head: smol machines (smolvm) vs Zeroboot

Frequently asked questions

What is Zeroboot?
Apache-2.0 Rust exec server that forks a pre-warmed Firecracker snapshot into a new copy-on-write KVM VM for every code run, with Python and TypeScript SDKs. A prototype snapshot-forking exec server for stateless, sub-millisecond-spawn code runs, self-hosted on Linux with KVM.
How does Zeroboot isolate code?
Zeroboot documents its isolation as: Each execution runs in its own KVM virtual machine forked from a Firecracker template snapshot: snapshot memory is mapped copy-on-write with mmap(MAP_PRIVATE) and CPU state is restored, so forks cannot see each other's writes (hardware-enforced via Intel VT-x/AMD-V).
Is Zeroboot open source?
Yes (Apache-2.0). It can be self-hosted.
How much does Zeroboot cost?
Free to self-host under Apache-2.0. A managed API at api.zeroboot.dev is offered as early access through a sign-up form; no pricing published Check the official pricing page for current rates.
How long can Zeroboot sessions run?
Each exec has a timeout_seconds parameter that defaults to 30 seconds; a maximum and long-lived sandboxes are not documented.
What are the alternatives to Zeroboot?
Common alternatives include smol machines (smolvm), Firecracker, E2B, Microsandbox, Daytona.

Sources

  1. github.com/zerobootdev/zeroboot
  2. github.com/zerobootdev/zeroboot/blob/main/docs/API.md
  3. github.com/zerobootdev/zeroboot/blob/main/docs/ARCHITECTURE.md
  4. github.com/zerobootdev/zeroboot/blob/main/docs/DEPLOYMENT.md
  5. github.com/zerobootdev/zeroboot/blob/main/CHANGELOG.md
  6. zeroboot.dev

Check before you rely on it. Products change quickly, and this page reflects public documentation as of November 18, 2026. Confirm anything that matters in the provider’s own documentation.

Cite this page

Agent Sandboxes. (2026). Zeroboot. agentsandboxes.org. Last reviewed November 18, 2026. https://agentsandboxes.org/sandboxes/zeroboot/