A computer for every agent. Pay only while it works.
Give each AI agent its own persistent Linux VM. When it goes quiet, the VM pauses with its memory intact and compute billing drops to $0. The next request brings it back, exactly where it left off.
Free plan: 20 hours of default, 2 concurrent VMs, no card.
$0.030per active hour, 4 vCPU / 8 GB
$0compute while paused
< 1 sresume with RAM (target p95 < 800 ms)
×50fork a running VM in one call
The life of one agent VM: it is created, does work and is billed per second, goes idle, pauses with RAM and disk snapshotted at $0 compute, resumes with memory restored on the next request, and is forked into 50 copies. Use the step buttons to show each stage.
sbx_7f3k2a · default · 4 vCPU / 8 GBcreating
$ dormo create --template base
Ubuntu 24.04 · own kernel · root, systemd, Docker
✓ sbx_7f3k2a running
$ git clone acme/app && npm test
agent edits files, runs tests, keeps a browser open
import { Client } from"@dormo/sdk";
const client = newClient(); // reads DORMO_API_KEY// A full VM that pauses itself after 5 idle minutesconst sbx = await client.sandboxes.create({
template: "base", size: "default",
auto_pause: { enabled: true, idle_timeout_seconds: 300 },
});
const run = await sbx.exec("npm ci && npm test");
console.log(run.exit_code, run.stdout);
await sbx.pause(); // RAM + disk snapshot, $0 computeawait sbx.resume(); // same processes, same PIDs// 50 copies of the running VM, memory included (all or nothing)const forks = await sbx.forkMany(50);
const port = await sbx.ports.expose({ port: 3000, visibility: "public" });
console.log(port.url); // https://<short_id>-3000.dormo.host
from dormo import Client
client = Client() # reads DORMO_API_KEY# A full VM that pauses itself after 5 idle minutes
sbx = client.sandboxes.create(
template="base", size="default",
auto_pause={"enabled": True, "idle_timeout_seconds": 300},
)
run = sbx.exec("pip install -e . && pytest")
print(run.exit_code, run.stdout)
sbx.pause() # RAM + disk snapshot, $0 compute
sbx.resume() # same processes, same PIDs# 50 copies of the running VM, memory included (all or nothing)
forks = sbx.fork_many(50)
port = sbx.ports.expose(3000, visibility="public")
print(port.url) # https://<short_id>-3000.dormo.host
# One static binary for macOS and Linux (see docs/cli)
dormo login # paste an API key
ID=$(dormo create --template base --size default -q)
dormo exec $ID -- npm ci '&&' npm test # exit code = command's exit code
dormo pause $ID # $0 compute while paused
dormo resume $ID # RAM back, same PIDs
dormo fork $ID --count 50 -q # prints 50 sandbox IDs
dormo port expose $ID 3000 --public # https://<short_id>-3000.dormo.host
dormo ssh $ID # via ssh.dormo.host
# Claude Code: give the agent its own VMs (local stdio server).# During the beta @dormo/mcp is shared with participants; npm soon.
claude mcp add dormo --env DORMO_API_KEY=$DORMO_API_KEY -- npx -y @dormo/mcp
# Cursor, Claude Desktop and other clients: mcp.json
{
"mcpServers": {
"dormo": {
"command": "npx",
"args": ["-y", "@dormo/mcp"],
"env": { "DORMO_API_KEY": "dormo_sk_..." }
}
}
}
# Tools: create_sandbox, exec, read_file, write_file, list_files,# pause_sandbox, resume_sandbox, fork_sandbox, expose_port,# desktop_stream_url, screenshot, computer_input, ...
Field names follow the OpenAPI spec and are linted in CI. TypeScript · Python · CLI · MCP
How it works
Snapshot the memory, not just the disk
Most platforms keep an idle VM running (and billing) or stop it and boot it again later. Dormo freezes the whole machine instead, then thaws it on the next request.
01 · CREATE
A full VM per agent
A Firecracker microVM with its own kernel, from a built-in template, your snapshot or any OCI image.
POST /sandboxes {"template": "base"}
02 · WORK
Billed per second
Exec, files, PTY, ports, SSH and a live desktop. You pay for the seconds the VM runs.
POST /sandboxes/{id}/exec
03 · PAUSE
Idle? $0 compute
After 5 idle minutes (configurable) RAM and disk are snapshotted and the vCPUs are released.
auto_pause: {"idle_timeout_seconds": 300}
04 · WAKE
Back with its memory
An HTTP request, SSH session or API call restores it in under a second (target p95 < 800 ms).
Own kernel, systemd and Docker inside. Isolated with jailer, cgroups and a network namespace per VM.
TARGET P95 < 800 MS
Pause with memory
Processes, open windows and sessions survive the pause. Auto-pause when idle, wake on request.
1–50 COPIES PER CALL
Fork a running VM
Clone a live VM with its memory to branch an agent's work or fan out identical eval environments.
1920×1080 · KASMVNC
Desktop & computer use
Stream an XFCE desktop to the browser and drive it via screenshot and input APIs. Learn more
https://<short_id>-<port>.dormo.host
Preview URLs & SSH
Expose any port over HTTPS for app previews. SSH through our gateway. Terminal over WebSocket.
TS · PYTHON · CLI · MCP
Built for agents
SDKs built against the OpenAPI spec, a CLI, an MCP server, signed webhooks and llms.txt.
Real cost, not list price
1,000 agent VMs, active 10% of the time
Most agent VMs sit idle most of the day. With per-second billing and $0 while paused, your bill follows the work, not the number of sign-ups.
Dormo~$2,190
E2B~$24,163
Monthly compute at list prices for 4 vCPU / 8 GB per hour, per battleships.dev (October 2026): Dormo $0.030 and E2B $0.331 for 73 active hours. Storage and plan fees excluded. Providers that bill while a VM runs and stop it on a timer (boat.dev) depend on your auto-stop setting; model that in the bill calculator. Full table with Daytona and Modal on the compare page.
One agent VM, one day, 15-minute slotsbilled: 2.5 h of 24 h
00:0006:0012:0018:0024:00
Running: billed per secondPaused: RAM + disk kept, $0 compute
This VM, this day
2.5 h × $0.030 = $0.075
Batch at night
−50% in the EU night window (22:00–07:00 CET) or with priority: "batch"
Never pauses?
Always-on: $19.90/month for a default VM
Console
Watch every agent's machine from the browser Coming soon
A web console for teams: every sandbox with its state and cost, a live terminal and the desktop stream in one tab, plus teams and roles. Until it ships, everything here is available through the API, CLI and MCP.
app.dormo.dev/sandboxes
Console in demo mode: a screenshot of the real console running against its built-in sample data, not a live account.
Built for
Three ways teams use a VM per agent
Evals & RL
Hundreds of identical environments
Prepare an environment once, then fork the running VM, memory included, for every rollout.
Up to 50 forks per call, all or nothing
Batch jobs at −50% in the EU night window or with priority: "batch"
Coding agents, "AI developer" products and app builders that give every user their own machine.
Bill grows with active work, not with sign-ups
Users return to the exact state they left
Preview URLs, scoped keys, spend limits and a usage API for re-billing
FAQ
Questions developers ask first
Can I use Dormo today?
Dormo is in private beta. Create an account to get the Free plan (20 hours of default, 2 concurrent VMs, no card); we enable beta access in batches while we add capacity. Planning a fleet? Tell us about your workload.
What exactly does "pay only while it works" mean?
Compute is billed per second while the VM is running. A paused VM costs $0 in compute. Its snapshot is stored free for 30 days, then $0.03 per GB per month. Disk beyond the included size is $0.05 per GB per month. Plan credit on Starter and Team does not roll over: unused credit expires at the end of the period. Full details on the pricing page.
How is pause different from stopping a VM?
Stopping keeps the disk and throws away memory, so the next start is a fresh boot: services restart, shells are gone, browser tabs are closed. Pause snapshots memory and disk, so resuming continues the same processes. Our target is p95 resume under 800 ms; we will publish measured numbers on the status page.
Is it a container or a real VM?
A real VM. Each sandbox is a Firecracker microVM with its own Linux kernel, running Ubuntu 24.04 with root, systemd and Docker. See security for the isolation model.
How does fork work?
Fork copies a running VM, memory included, into new sandboxes that continue from the same state. One call creates 1–50 copies (more on request), all or nothing. It also works with priority: "batch" for the night discount. See snapshots and fork.
Where does my data live?
On dedicated servers in the EU. We do not offer regions outside the EU yet.
Can I migrate from E2B?
We are building an adapter compatible with the E2B API so most code can switch by changing the SDK import and API key. It is planned for the beta, not shipped yet. Meanwhile see the migration guide.
Do you have GPUs, SOC 2 or open source?
Not yet. There are no GPUs (desktops use software rendering), no SOC 2 report (planned for year two) and the core is not open source today. These are on the roadmap, not in the beta.
Teams & fleets
Running hundreds of agent VMs? Talk to us
During the private beta we onboard eval and RL teams, agent platforms and larger fleets in batches. Tell us about your workload and we will reach out with a slot, capacity planning and a bill estimate based on your usage.
Just trying it out? Create a free account instead: 20 hours of default, 2 concurrent VMs, no card.
You're on the list.
We could not reach our server just now, so your sign-up is saved in this browser only. We will send it automatically the next time you open this site, or email hello@dormo.dev.