Fork a microVM into an agent swarm.
Isolated, forkable computers for your agents.
pip install mitos-run import mitos sb = mitos.create("python") # fork a warm VM into a swarm. each fork is its own microVM swarm = sb.fork(8) for i, agent in enumerate(swarm): print(agent.exec(f"python3 -c 'print({i} ** 2)'").stdout)
import { SandboxServer } from "@mitos/sdk"; const sb = await new SandboxServer().fork("python"); // divide a warm VM into a swarm. each fork is its own microVM const swarm = await sb.fork(8); const runs = await Promise.all(swarm.map((a, i) => a.exec(`python3 -c 'print(${i} ** 2)'`))); runs.forEach((r) => console.log(r.stdout));
mitos sandbox create --pool python mitos fork <sandbox-id> --count 8 mitos sandbox exec <fork-id> python3 -c 'print(42)'
{
"mcpServers": {
"mitos": {
"command": "mitos-mcp"
}
}
} Most sandboxes cold-boot or restore a snapshot.
Mitos forks the running machine.
A fork copies the live VM, memory and all, not just the disk. Daughters share the parent's pages and pay only for what they change: about 3 MiB each, not eight whole VMs.
Built for the work that needs many of them
One warm machine becomes a swarm, then collapses back to zero.
Best-of-N attempts
Run N attempts in parallel, commit the one that worked, drop the rest.
RL rollouts and fan-out
Thousands of parallel environments from one warm template, then back to zero.
Tree search
Branch a running agent mid-thought for MCTS. Parallel beats serial.
Multi-agent evals
Every agent its own computer, isolated from the rest.
Untrusted code
Model-written code in a microVM with its own kernel.
From one computer to a swarm in three calls
Grab a warm sandbox
Ask for an image and get a running, isolated computer back in milliseconds. The pool was already warm, so there is no cold start.
sb = mitos.create("python") Fork it
Copy the running VM as many times as you want. Each fork is its own microVM and shares the parent in memory.
swarm = sb.fork(8)
Keep what worked
Fork the sandbox that succeeded and throw the rest away. Forks are cheap, so the winner becomes the new starting point whenever you want.
keeper = winner.fork(1)[0]
We run the cluster. You call the API.
We keep the bare-metal fleet alive, warm, and scaled. You ship against an API and never touch a cluster.
No cluster to run
No KVM hosts to patch, no snapshot storage to babysit, no 3am page.
Pools stay warm
Pre-forked VMs stay hot, so forks land in milliseconds, one or five hundred.
No lock-in
The engine is open source, so you are never trapped in our cloud.
Dev and prod match
Same engine, same API, laptop to production.
Live fork, microVM isolation, and actually open
Plenty of runtimes do one of these. Mitos does all of them. Capabilities from each project's public docs, not a head-to-head benchmark.
| Capability | Mitos | E2B | Modal | Daytona | Morph |
|---|---|---|---|---|---|
| Live fork of a running VM (memory + processes) | ✓ | ✗ snapshot | ✗ snapshot | ◐ filesystem | ◐ snapshot |
| Published marginal cost per fork | ✓ ~3 MiB | ✗ | ✗ | ✗ | ✗ |
| microVM isolation (own kernel) | ✓ KVM | ✓ | ✗ gVisor | ✗ gVisor | ◐ undisclosed |
| Open source | ✓ Apache 2.0 | ✓ Apache 2.0 | ✗ | ✗ closed | ✗ |
| Fully managed cloud | ✓ | ✓ | ✓ | ✓ | ✓ |
Every fork is a real microVM, not a shared kernel
Each subagent runs in its own Firecracker microVM with its own kernel. A prompt injection that turns into a shell stays inside one disposable fork, not your host and not the other agents.
Read the architectureQuestions worth asking
Is the fork really unique?
No, and we will not pretend it is. A few others can branch a VM. No one else combines a live fork of running memory at about 27ms and 3 MiB per fork, microVM-isolated, managed, and Apache-2.0.
How many forks can I run at once?
Hundreds to thousands from one warm parent. They share its memory, so cost grows with what each one writes, not with the count.
Can I run it myself?
Yes. The engine is Apache-2.0 on GitHub, the same code the managed service runs.
How are subagents isolated?
Each fork is a Firecracker microVM with its own kernel, isolated by KVM.
Will I get a surprise bill?
Hard spend caps are on by default, and copy-on-write means you pay for dirtied pages, not whole VMs.
Which languages and SDKs?
Python, TypeScript, and a CLI, plus an MCP server. The sandbox runs any Linux workload.