Sprites vs Deno Sandbox
Both run code in a Firecracker microVM. A Sprite is a persistent 8 vCPU computer that sleeps when idle and wakes on the next request, while a Deno sandbox is a small 2 vCPU machine for short, locked-down runs of up to 30 minutes that starts in under 200 ms.
The companies and products
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “63rd cheapest of 377” means 62 of the other 376 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Sprites: price rank | Deno Sandbox: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Long builds outlast Deno's 30-minute lifetime and its 2 vCPU shape, while a Sprite keeps its 100 GB disk; bochka adds systemd, /dev/kvm and many public ports. | 66th of 367, with limits $546 a month | 290th of 367, with limits $5,665 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month can stay on a Sprite if something holds it awake, while a Deno sandbox ends after 30 minutes; bochka just keeps running. | 157th of 366, with limits $1,166 a month | 287th of 366, with limits $5,803 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both suit short code runs: Deno starts in under 200 ms and bills CPU only while code runs, and a Sprite sleeps about 30 seconds after the last command. | 93rd of 345, with limits $140 a month | 141st of 345, with limits $329 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month A Sprite gives each user a persistent machine with a URL that wakes it, while Deno caps Builder at 20 sandboxes at once per region; bochka gives each user SSH, raw TCP and up to 50 HTTPS ports. | 56th of 361, with limits $428 a month | 148th of 361, with limits $1,863 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 105th of 360, with limits $6,540 a month | 122nd of 360, with limits $7,963 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 125th of 364, with limits $545 a month | 296th of 364, with limits $1,563 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that runs Docker fits Sprites better than Deno, whose docs do not mention Docker; neither documents /dev/kvm for Android builds, which bochka exposes. | 63rd cheapest of 377 $476 a month | 304th of 377, with limits $731 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs a disk that persists, which a Sprite has and a Deno sandbox wipes when it ends; bochka adds direct SSH and systemd. | 213th of 368, with limits $27 a month | 179th of 368, with limits $200 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither has a desktop: Sprites is headless and Deno offers a browser VS Code editor, while bochka streams a 60fps desktop with Chromium. | 85th of 369, with limits $136 a month | 280th of 369, with limits $1,583 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month On both you install and run a headless browser yourself, while bochka ships Chromium on a desktop you can watch. | 171st of 367, with limits $122 a month | 284th of 367, with limits $783 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 229th of 346, with limits $206 a month | 286th of 346, with limits $573 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 141st of 338, with limits $4,113 a month | 247th of 338, with limits $11,923 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 210th of 360, with limits $223 a month | 251st of 360, with limits $367 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Sprites | Deno Sandbox | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | Fixed 2 vCPU, 768 MB to 4 GB memory, 10 GB disk | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No time cap; pauses about 30 seconds after activity stops unless a task holds it awake | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No cap on paid plans; runs until you stop it or its time to live ends |
| Disk that persists | Yes, a 100 GB disk that syncs to object storage | Root disk wiped when the sandbox ends; opt-in volumes of 300 MB to 20 GB, Chicago only | The whole disk is kept, saved every minute and on stop; a stopped sandbox costs nothing |
| Idle behavior | Sleeps when idle and wakes on the next request in 100 to 500 ms, or 1 to 2 s after a cold stop | No sleep; the sandbox ends with its session | Keeps running until stopped; resumes by booting again |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | Read-only volume snapshots that new sandboxes can boot from; no fork of a running sandbox | Automatic disk snapshots, named snapshots, and fork of a running sandbox with its disk |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Root access; Docker and nested virtualization not documented | Root, Docker, systemd and /dev/kvm for Android emulators and VMs |
| Reaching the sandbox | One HTTPS URL to one HTTP port, private by default; SSH and other ports only through the sprite proxy CLI | HTTPS URL per exposed port, public without authentication; SSH | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Host allowlist per sandbox, enforced by a proxy outside the VM | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Connectors hold the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists | Placeholder secrets swapped for real ones on requests to approved hosts | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | A root image with Claude Code, run through the shell command API | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | No desktop; a VS Code editor in the browser | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Start time | Wakes in 100 to 500 ms with memory kept | Under 200 ms for a new sandbox | Boots a full VM |
| Regions | Not selectable | Amsterdam and Chicago | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | Deno Sandbox | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or Deno Sandbox: neither is in the StarSling hpc-sandbox-benchmarks results we use. bochka did 26.69 runs per second on its Node.js build-and-test test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. A Sprite is fixed at 8 vCPU and a Deno sandbox at 2 vCPU, so neither could run that test at the same shape.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites and Deno Sandbox have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Sprites, a month | Deno Sandbox, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $23 · Pay-as-you-go | $53 · Pro · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $92 · Pay-as-you-go | $200 · Builder · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $1,120 · Pay-as-you-go | $2,779 · Builder · with limits | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $314 · Pay-as-you-go · with limits | $783 · Builder · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $1,134 · Pay-as-you-go · with limits | $1,563 · Builder · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time actually used at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans from $20 a month add fixed CPU, memory and storage allowances that are not credit.
Deno Sandbox: Sandboxes need Deno Deploy Pro at $20 a month or Builder at $200 a month, which include CPU, memory and egress allowances shared with your Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Deno Sandbox: Plans start at $20 a month, and the whole fee is usage credit. You pay per second for the size you pick while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Deno Sandbox fits none of the five scenarios as written: a sandbox lives up to 30 minutes on a fixed 2 vCPU / 4 GB shape, and Builder allows 20 at once per region. Sprites fits the three single-agent and fleet scenarios, but it does not publish how many Sprites can run at once on pay as you go, so 300 user sandboxes and 1,000 jobs at once are not confirmed. bochka fits four of the five; at 1,000 short jobs at once its top plan queues starts above 90 a minute and allows 2,400 starts a day, so none of the three fits that burst as published.
| Scenario | Sprites | Deno Sandbox | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops | None that bite |
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Sprites when
your agents or apps need a persistent computer with a big disk that sleeps when idle and wakes on the next request.
- A computer that stays. For agents that come back to the same files: a Sprite keeps a 100 GB disk with no time cap on its life.
- Sleeps when idle, wakes on request. For apps and agents idle most of the day: a Sprite stops billing compute when it sleeps and wakes on the next request.
- Plugs into agent platforms. For teams on Claude Managed Agents or Cursor Cloud Agents: Sprites can be the machine behind them, with a remote MCP server.
Use Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds, reach only the hosts you allow, or run in the US, especially on Deno Deploy.
- Fast fresh starts. For one sandbox per request: a Deno sandbox starts in under 200 ms and CPU bills only while code runs.
- Locked-down outbound traffic. For untrusted code: each sandbox can be limited to a host list, enforced by a proxy outside the VM.
- A US region and a path to Deploy. For teams on Deno Deploy: sandboxes run in Chicago or Amsterdam and can be promoted to a Deploy app.
Where bochka fits
If your agents do hours of real work, such as installs, builds, Docker, emulators or a browser, both products ask for workarounds: Sprites pauses when nothing holds it awake and has no systemd, and Deno ends every sandbox after 30 minutes on 2 vCPU. bochka gives each agent a full VM that runs until you stop it, with a desktop, forks and an API to drive the agents inside from outside.
A full machine that keeps running
A Deno sandbox ends after 30 minutes and wipes its disk, and a Sprite pauses and drops open connections unless a task hold, renewed every hour, keeps it awake. A bochka sandbox has no session cap on paid plans and saves its disk every minute.
systemd, Docker and /dev/kvm
Sprites has no systemd and its docs do not mention /dev/kvm, and Deno documents neither Docker nor nested virtualization. On bochka, services, Docker images and Android emulators work as on any Linux server.
A desktop, forks and agents driven from outside
Neither has a desktop or a fork of a running machine, and both run coding agents through exec or shell commands you parse yourself. bochka streams a 60fps desktop with Chromium, forks a running sandbox, and has a prompt, steer and events API.
Use bochka when your agents work for hours on a full machine: Docker, systemd, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Sprites and bochka vs Deno Sandbox.
Questions people ask
Is Sprites cheaper than Deno Sandbox?
In all five scenarios we priced, yes: one coding agent on workdays is $23 a month on Sprites against $53 on Deno Pro, one agent that never stops is $92 against $200, and 50 agents in parallel are $1,120 against $2,779. Deno does not fit any of them as written. bochka comes to $20, $26 and $317 for those three.
Which is faster, Sprites or Deno Sandbox?
Neither has a comparable CPU measurement in the benchmark we use. A Sprite has 8 vCPU against 2 for a Deno sandbox, so it has more room for builds, while a new Deno sandbox starts in under 200 ms and a sleeping Sprite wakes in 100 to 500 ms.
How long can each one run?
A Deno sandbox lives up to 30 minutes, and longer work can be promoted to a Deno Deploy app. A Sprite has no time cap, but it pauses about 30 seconds after activity stops unless a task holds it awake for up to an hour at a time. A bochka sandbox has no session cap on paid plans.
Can Sprites or Deno Sandbox run Docker?
Users run Docker on Sprites, though some report that docker exec fails for containers that do not run as root. Deno's docs do not say Docker works inside a sandbox. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Do they keep files between runs?
A Sprite keeps its 100 GB disk. A Deno sandbox wipes its root disk when it ends, unless you mount a volume of 300 MB to 20 GB, available only in Chicago. bochka keeps the whole disk, saves it every minute and charges nothing while it is stopped.
Can I SSH into them?
Deno Sandbox offers SSH. On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. bochka sandboxes have SSH, raw TCP and a dedicated IP.
Try bochka
Install the CLI, then run bochka new.
Product preview