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"
    }
  }
}
Apache 2.0 ~27 ms per fork ~3 MiB per subagent Firecracker microVMs

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.

vm-0.1 vm-0.2 vm-0.3 vm-0.4 vm-0.5 vm-0.6 vm-0.7 vm-0.8 vm-0
~27 msper fork
~3 MiBper subagent
N-waylive fork

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

01

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")
02

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)
03

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]
Firecracker microVMs KVM isolation Kubernetes CRDs Copy-on-write fork Memory snapshots Apache 2.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.

Get started

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 MitosE2BModalDaytonaMorph
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 architecture

Pay for divergence, not duplication

Forks share the parent's memory until they write, so you pay for the pages they dirty, about 3 MiB each, not whole VMs. Hard spend caps are on by default.

See pricing

Questions 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.

Give your agents a swarm of computers.