Sprites vs Modal VM Sandboxes
A Sprite is a persistent Linux machine that sleeps about 30 seconds after work stops and wakes on the next request. A Modal VM Sandbox is a fuller VM with systemd and a choice of regions, but it lasts at most 24 hours and keeps files only in Volumes or snapshots.
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
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
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 | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites keeps the disk between days but has no systemd and one public HTTP port; a Modal VM runs systemd but ends within 24 hours; boat keeps the disk and runs systemd. | 66th of 367, with limits $546 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month does not fit Modal's 24-hour cap, and on Sprites it must hold the machine awake with a task that lasts at most an hour. | 157th of 366, with limits $1,166 a month | Can't run it | 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 Short code runs fit both: Sprites bills only the CPU and memory it really uses, and Modal starts many short sandboxes fast. | 93rd of 345, with limits $140 a month | Can't run it | 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 Users who come back to the same sandbox fit Sprites, which wakes on their first request, better than Modal, whose VMs end within a day. | 56th of 361, with limits $428 a month | Can't run it | 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 Huge bursts of short rollouts are what Modal is built for, with 5,000 containers at once on Team; Sprites does not publish its pay-as-you-go limit. | 105th of 360, with limits $6,540 a month | 171st of 360, with limits $16,322 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 | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both run Docker builds; Modal adds /dev/kvm on Team and Enterprise on request, Sprites does not mention it, and boat has it on every plan. | 63rd cheapest of 377 $476 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you return to every day fits Sprites, which keeps its disk, better than Modal, which loses its root disk after 24 hours. | 213th of 368, with limits $27 a month | Can't run it | 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: on Modal you set up Xvfb and VNC yourself, on Sprites you install a display and browser yourself, while boat streams a 60fps desktop. | 85th of 369, with limits $136 a month | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | 294th of 360, with limits $642 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 | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | VM on Cloud Hypervisor with its own Linux 7.2 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 by the platform | You request CPU and memory per sandbox | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Image | One managed Ubuntu image; you install on top | Your own images, same as Modal's other sandboxes | Docker and seven coding agents preinstalled; named snapshots to start new sandboxes from |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Root, Docker (start dockerd yourself) and systemd; /dev/kvm on Team and Enterprise on request | Root, Docker, systemd and /dev/kvm on every plan |
| Longest session | No time cap, but it pauses when idle unless a task holds it awake | 24 hours (default 5 minutes) | No cap on paid plans; you set the time to live |
| Idle and resume | Pauses about 30 seconds after activity stops, wakes on the next request in 100 to 500 ms | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files | Stop for free, resume later with the whole disk; disk saved every minute |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | Filesystem snapshots to boot new sandboxes; memory snapshots in alpha | Named snapshots, and fork of a running sandbox with its disk |
| Reaching the sandbox | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | 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 | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Connectors gateway holds tokens for any HTTP API, with path allow and block lists | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec | Examples only | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| CPU benchmark (4 vCPU / 8 GB) | Not measured | 15.54 runs/s | 26.69 runs/s |
| Regions | Not selectable | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | Modal VM Sandboxes | boat |
|---|---|---|---|
| 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 | 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 | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | 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 | Not published | Yes |
| Usage per sandbox (API) | No | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | 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 measurement for Sprites yet: it is not in the hpc-sandbox-benchmarks results we use. In the same run at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 runs per second and boat did 26.69, about 1.7 times the CPU work in the same time. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. Sprites has 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 | Modal VM Sandboxes, a month | boat, 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 | $15 · Starter · 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 | $178 · Starter · 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,229 · Starter · 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 | $792 · Team | $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 | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills measured 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 buy fixed CPU, memory and storage allowances that are not credit.
Modal VM Sandboxes: Modal bills by the second for the higher of what you request and what you use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region costs 1.15x to 1.75x.
Modal VM Sandboxes: 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
A Modal VM Sandbox lives at most 24 hours and its root disk goes with it, so the workday, always-on and 50-agent scenarios do not fit unless you keep files in a Volume. Sprites fits those, but it does not publish how many machines can run at once on pay as you go, so 300 user sandboxes and 1,000 jobs at once are not confirmed. Modal fits 300 user sandboxes on Team, and its 1,000-job burst runs on shared CPU that other tenants can slow. boat fits every scenario but the 1,000-job burst, where starts above 90 a minute queue.
| Scenario | Sprites | Modal VM Sandboxes | boat |
|---|---|---|---|
| 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 | 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, should keep their files, and should wake on the next request.
- Keeps its disk and sleeps when idle. For agents and apps that sit idle most of the day: a Sprite keeps its files, stops billing compute and wakes on a request.
- Bills what you really use. For bursty, mostly idle work: Sprites bills measured CPU time and actual memory only while awake, not a reserved size.
- Agents and connectors ready to go. For teams that want agents fast: four coding agents come preinstalled, and Connectors keep API tokens out of the machine.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need regions outside Europe or strict outbound rules, or already run models on Modal.
- Huge bursts of short jobs. For many short sandboxes that finish within a day: Modal runs 5,000 containers at once on Team.
- Regions and strict outbound rules. For teams outside Europe or with tight network rules: pick US, EU or Asia-Pacific, and block or allowlist outbound traffic.
- A fuller VM with your own image. For stacks that need systemd or a custom image: Modal's VM runs systemd, FUSE and Docker from the image you build.
Where boat fits
Sprites and Modal VM Sandboxes each give up something an agent working for hours needs. Sprites keeps its disk but has no systemd, one public port and a machine that naps, and Modal has a fuller VM that is gone within a day. If your agents need a full machine that keeps running, keeps its work and can be watched and driven from outside, look at boat.
A machine that keeps running and keeps its work
A Sprite pauses when idle and drops open connections, so it needs a task hold renewed every hour. A Modal VM ends within 24 hours and loses its root disk. boat has no session cap and saves the disk every minute.
A full Linux server inside
Sprites has no systemd, no /dev/kvm and one public HTTP port. Modal has systemd but gives /dev/kvm only on Team and Enterprise on request. boat has systemd, Docker, /dev/kvm, SSH, raw TCP and HTTPS on 50 ports.
A desktop, a browser and agents you drive
Both are headless, so a computer-use agent means installing a display, a browser and a stream yourself. boat streams a 60fps desktop with Chromium, lets you drive agents inside from outside, and forks a running sandbox.
Use boat when your agents work for hours or days on a full machine they come back to: systemd, Docker, emulators, many ports, a desktop and browser, forks, and agents you drive from outside. Compare it one to one: boat vs Sprites and boat vs Modal VM Sandboxes.
Questions people ask
Is Sprites cheaper than Modal VM Sandboxes?
In most of our scenarios, yes: one agent that never stops is $92 a month on Sprites against $178 on Modal, and 50 agents in parallel are $1,120 against $2,229. For one agent on workdays Modal is $15 and Sprites $23, but Modal's files reset between days. boat comes to $20, $26 and $317 for those.
Which is faster, Sprites or Modal VM Sandboxes?
We have no comparable CPU measurement for Sprites. On the hpc-sandbox-benchmarks test at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 runs per second and boat did 26.69.
Can Sprites and Modal VM Sandboxes run Docker and systemd?
Both run Docker. Modal's VM runtime also runs systemd, and offers /dev/kvm on Team and Enterprise on request. Sprites does not run systemd and its docs do not mention /dev/kvm. boat runs Docker, systemd and /dev/kvm in every sandbox.
How long can each one run?
A Modal VM Sandbox runs 5 minutes by default and 24 hours at most. 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. boat has no session cap on paid plans.
Do Sprites and Modal VM Sandboxes keep files?
A Sprite keeps its whole 100 GB disk between runs and can restore checkpoints in place. A Modal VM keeps files only in Volumes or snapshots, since the sandbox and its root disk are gone when it ends. boat saves the whole disk every minute and on stop.
Where do Sprites and Modal VM Sandboxes run?
Sprites does not let you choose a region. Modal runs in the US, the EU and Asia-Pacific, and pinning a region costs 1.15x to 1.75x. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial