Sprites vs exe.dev
Sprites gives each agent a Firecracker microVM that pauses about 30 seconds after work stops, wakes on the next request and bills only the CPU and memory it really uses. exe.dev gives you KVM VMs with systemd and SSH that run until you stop them, mostly out of a reserved pool you pay for whether it is busy or not.
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
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites ranks 66th of 367 and exe.dev 253rd for a software factory; bochka ranks 3rd and is a full fit, with systemd, /dev/kvm, many ports and a desktop. | 66th of 367, with limits $546 a month | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev ranks 15th and fits always-on assistants fully because its VMs never pause, while Sprites ranks 157th since a Sprite sleeps and drops connections when idle. | 157th of 366, with limits $1,166 a month | 15th cheapest of 366 $3,833 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 Sprites suits short code runs better than exe.dev, ranking 93rd against 235th, because it sleeps right after the last command. | 93rd of 345, with limits $140 a month | 235th of 345, with limits $175 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 Sprites ranks 56th for sandboxes you hand to users thanks to wake on request, exe.dev ranks 257th with its 50 VM cap on Personal, and bochka ranks 1st. | 56th of 361, with limits $428 a month | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 Sprites ranks 63rd and fits CI because it bills only while a job runs; exe.dev ranks 288th since pools bill whether jobs run or not. | 63rd cheapest of 377 $476 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB For a 24/7 dev box exe.dev ranks 25th with SSH and systemd, Sprites ranks 213th without either, and bochka ranks 18th. | 213th of 368, with limits $27 a month | 25th cheapest of 368 $35 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 Both are headless, so computer-use agents have no screen on either; bochka ranks 6th with a 60fps desktop and Chromium. | 85th of 369, with limits $136 a month | 240th of 369, with limits $1,055 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 | 171st of 367, with limits $122 a month | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | KVM VM with Cloud Hypervisor; you can't choose the kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory set and scaled by the platform | Personal pools of 2 to 16 vCPU shared by your VMs; standalone VMs up to 2 GiB per vCPU | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Root, systemd and Docker; nested virtualization on Enterprise only | Root, Docker, systemd and /dev/kvm on every plan |
| When nothing is running | Pauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 ms | Runs until you stop it; a pool bills the same busy or idle | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Saved state | Filesystem checkpoints by hand or automatic; restore replaces the disk in place | Disk persists and is streamed to a second server; no snapshots | Disk saved every minute and on stop; named snapshots to start new sandboxes from |
| Copy a machine | No fork in the public API or CLI | cp copies a VM's disk and config into a new VM | Fork a running sandbox with its disk into a new one |
| Image | One managed Ubuntu image; you install on top | Boot from your own Docker image in about two seconds | Templates from named snapshots; no Dockerfile or OCI images |
| Reaching the machine | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | HTTPS proxy for ports 3000 to 9999 and brokered SSH; no public IP or raw TCP | 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 | Open internet | Open internet, no provider-side allowlist |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Claude Code, Codex, Pi and Shelley; only Shelley takes prompts through the 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 | Headless; no desktop or screen streaming | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Integrations | Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents | MCP server at exe.dev/mcp | REST API, CLI and SDKs for TypeScript and Python |
| Regions | Not selectable | 9 regions in the US, Europe, Asia and Australia | EU only (Germany, Finland, France), with EU data residency |
| Session length | No cap, but an idle Sprite pauses; a task hold keeps it awake for up to an hour at a time | No cap; VMs run until you stop them | No cap on paid plans; you set the time to live |
Every feature Battleships tracks (43)
| Feature | Sprites | exe.dev | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | 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 | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Sprites nor exe.dev is in the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for either, and we don't guess. bochka did 26.69 runs per second on the Node.js build-and-test test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites and exe.dev 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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 | $1,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time 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 include fixed CPU, memory and storage allowances that are not credit.
exe.dev: exe.dev Personal is a flat monthly pool your VMs share, from $15 for 2 vCPU / 4 GiB to $155 for 16 vCPU, billed whether it is busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
exe.dev: Plans start at $20 a month, and the whole fee is usage credit. Sandboxes bill per second while they run, and a stopped one costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal stops at 50 VMs at once, so 300 sandboxes for your users and 1,000 short jobs at once don't fit there. Sprites does not publish how many can run at once on pay as you go, so those two scenarios are not confirmed, and creation is 10 a minute without a plan. A Sprite also pauses when idle and drops open connections, so an always-on agent needs a task hold renewed every hour. bochka has no session cap on paid plans, but even its top plan queues starts for 1,000 short jobs at once.
| Scenario | Sprites | exe.dev | 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 | 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 sit idle most of the day and should wake on a request, or when you want to bill only real CPU use and fence outbound traffic to a domain list.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day, a Sprite stops billing compute and wakes on the next request.
- Pay for what you use. Sprites bills the CPU time and memory a machine actually uses while awake, so bursty work costs little.
- Outbound domain allowlist. For teams that must fence in an agent, a Sprite can be limited to the domains you list.
Use exe.dev when
you want a plain Linux VM with systemd and SSH that stays on, booted from your own Docker image, in a region near users outside Europe.
- A normal Linux server that stays on. exe.dev VMs have systemd and SSH and run until you stop them, so long-lived services just work.
- Your own Docker image. exe.dev boots each VM straight from your own container image, so your setup is ready at start.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
Where bochka fits
Sprites and exe.dev both give an agent a real VM, but both are headless and neither lets you drive Claude Code or Codex inside through one API. If your agents work for hours, need a screen, need /dev/kvm or need many open ports, look at bochka. It keeps exe.dev's always-on, systemd style machine and adds the parts agents keep asking for.
A screen for computer use
Agents that test web apps need a screen to look at. Sprites and exe.dev are both headless, so on either you install a display server, a browser and a streaming layer yourself. bochka streams a 60fps desktop with Chromium.
Saved every minute, and forks
One bad agent step can wreck an install. exe.dev has no snapshots to roll back to, and Sprites checkpoints only restore in place, with no fork. bochka saves the disk every minute and forks a running sandbox.
A full machine you drive from outside
Sprites has no systemd, no /dev/kvm and one public port; exe.dev has nested VMs only on Enterprise and no raw TCP. bochka has all of them, plus one API to prompt and steer agents inside.
Use bochka when your agents need a full machine for hours: systemd, Docker, /dev/kvm, many ports, a desktop and browser, state saved every minute, forks, and an API to drive agents inside from outside. Compare it one to one: bochka vs Sprites and bochka vs exe.dev.
Questions people ask
Is Sprites cheaper than exe.dev?
It depends on how often the machine runs. One coding agent on workdays is $23 a month on Sprites and $35 on exe.dev, and 50 agents in parallel are $1,120 on Sprites against $1,848 on exe.dev. One agent that never stops flips it: $35 on exe.dev against $92 on Sprites.
Which is faster, Sprites or exe.dev?
We can't say: neither is in the hpc-sandbox-benchmarks run we use. A Sprite always has 8 vCPU, while exe.dev VMs share the pool you reserve, so a fair test would need matching shapes.
Can Sprites and exe.dev run Docker and systemd?
exe.dev VMs have root, systemd and Docker. Sprites runs Docker, but a user report says docker exec fails for containers whose main process is not root, and its docs say Sprites don't run systemd. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Can I SSH into a Sprite or an exe.dev VM?
exe.dev gives every VM brokered 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.
Where do Sprites and exe.dev run?
Sprites does not let you choose a region. exe.dev has nine regions in the US, Europe, Asia and Australia. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Does either one have a desktop for computer-use agents?
No. Both are headless, so an agent that needs a screen has nothing to look at unless you build a desktop and stream it yourself. bochka gives every sandbox a 60fps desktop with Chromium and computer-use APIs.
Try bochka
Install the CLI, then run bochka new.
Product preview