The agent
swarm platform
Throw compute at the problem. Sandboxer runs your agent swarm: thousands of isolated agents in parallel, coordinated toward one goal, priced per second.
macOS, Linux and Windows. 7-day free trial with 25 hours of machine time; card required, then $20/month unless you cancel.
Everything a developer expects from a computer. Nothing an agent has to work around.
A whole VM, not a container
Each sandbox is its own Cloud Hypervisor microVM with its own kernel. Install packages, run systemd services and Docker, even boot nested VMs.
Learn morePause with memory, resume mid-thought
Stopping snapshots memory and disk. Resuming restores both, so dev servers, shells and long agent runs carry on as if nothing happened.
Learn moreInstant copy-on-write forks
Clone a running sandbox into an independent one. Disks are reflinked, so a fork costs no copy time and no extra space until it diverges.
Learn moreNamed snapshots as templates
Warm up a stack once, save it under a name, and start every new sandbox from it. Share it with another account through a revocable code.
Learn moreHTTPS for any port
One command turns port 3000 into a stable https URL — private with a token, or public. Services bound to localhost work too.
Learn moreSSH, SCP and port forwarding
sbx ssh tunnels over HTTPS, so it works through any firewall. Plain ssh works too: every VM gets an IPv4 port and its own public IPv6.
Learn moreA desktop you can stream
XFCE and Chrome on a virtual screen, streamed to your browser over VNC. Agents drive the same screen with computer-use tools.
Learn moreCoding agents built in
Claude Code, Codex, OpenCode and others are installed and supervised for you. Prompt, steer and interrupt them over the API.
Learn morePay by the second
Running time is metered per second at a flat price per size. A stopped sandbox keeps its disk and memory for 14 days and costs nothing.
Learn morePause and restart sandboxes
When a sandbox stops, Sandboxer freezes the filesystem, snapshots the VM's memory and device state, and shuts the machine down. Resume restores that snapshot — the same processes, the same open sockets on localhost, the same half-finished build. If the memory image is missing, you resume onto a different size, or no machine with the same CPU type frees up within two minutes, it falls back to a clean boot from disk (or waits up to 30 minutes, if you ask).
- Pauses itself when idle (after 30 minutes on the $20 plan) and wakes on the next request.
- Auto-stop at a deadline you choose (one hour by default), or never.
- Continuous disk snapshots every 10 minutes while it runs.
- Stopped sandboxes are free: no compute, no storage fees.
Same disk either way. The difference is whether your processes survived.
Agents work in familiar environment
Agents do their best work with the same tools you use: a shell, a package manager, a browser, Docker. Sandboxer hands them a whole computer per task, then gets out of the way.
Scoped API keys with expiry, per-sandbox keys injected automatically, and no-env sandboxes that never see your secrets.
Signed webhooks for ready, error, stopped and more, plus an event stream for every prompt, tool call and reply.
Fork a sandbox to try two approaches in parallel, keep the winner, throw the other away.
Idempotent creates, JSON output from every CLI command, and `current` / `self` aliases inside loops.
# Inside an agent loop: give each task its own machine
id=$(sbx new --no-env --json | jq -r 'select(.event=="ready").id')
sbx exec "$id" --cwd app -- npm ci
sbx prompt "$id" --provider claude "Fix the failing tests and open a PR"
sbx events "$id" --follow # stream tool calls and replies
sbx snapshot "$id" app-ready # freeze the warmed-up state
sbx new --from app-ready # every next task starts thereOne HTTP API. Typed clients. A CLI that mirrors it.
Every action in the dashboard is an API call you can make yourself: a standard, documented REST API with an OpenAPI spec, so any HTTP client works. Coming from Daytona? Its TypeScript and Python SDKs work here for sandboxes, commands, files and previews with a new API URL and key.
# Create a sandbox (stops itself after an hour unless you extend it)
curl -sS https://sandboxer.com/api/v1/sandboxes \
-H "Authorization: Bearer $SANDBOXER_API_KEY" \
-H "Content-Type: application/json" \
-d '{"type":"default","ttlSeconds":3600}'
# Run a command and wait for the result (up to 10 minutes)
curl -sS https://sandboxer.com/api/v1/sandboxes/$ID/commands \
-H "Authorization: Bearer $SANDBOXER_API_KEY" \
-H "Content-Type: application/json" \
-d '{"command":"git clone https://github.com/sindresorhus/is-plain-obj && cd is-plain-obj && npm install && npm test","timeoutSeconds":600}'
# Pause it — memory and disk are kept, billing stops
curl -sS -X POST https://sandboxer.com/api/v1/sandboxes/$ID/stop \
-H "Authorization: Bearer $SANDBOXER_API_KEY"How Sandboxer stacks up.
A qualitative comparison from each provider's public documentation. We will publish reproducible performance numbers when the benchmark harness is ready — until then, no made-up charts.
= not documented publicly. Each cell links to the public doc it rests on, checked Oct 15, 2026. Spotted something out of date? Tell us.
One on one, with sources: vs E2B · vs Daytona · vs Modal · vs Vercel Sandbox
Flat per-size prices, metered per second.
No active-CPU guesswork: you know the price before you run anything. Plans from $20/month, and every plan dollar comes back as machine time.
CI jobs, scripts, light agents
Coding agents, dev servers, Docker
Big builds, browsers, many containers
Emulators, nested VMs, heavy parallel work
The $20 plan includes about 555 hours of the default size. Extra time comes in $20 packs that never expire.
Your first sandbox is one command away.
A 7-day free trial with 25 hours once you add a card, then $20/month unless you cancel. Signing up and looking around needs no card.
curl -fsSL https://sandboxer.com/install | sh