Modal vs Sprites
Modal gives you short-lived sandboxes inside a big AI compute platform, with GPUs, regions around the world and a 24-hour limit per sandbox. Sprites gives each agent a persistent Linux microVM with its own disk that sleeps when idle and wakes on the next request.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | Sprites: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 66th of 367, with limits $546 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent hits Modal's 24-hour sandbox limit and Sprites' pause after idle, while a bochka sandbox keeps running with no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 157th of 366, with limits $1,166 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 For short code runs Modal's fast starts and large concurrency fit well, and Sprites also suits them because it bills only real CPU and memory while awake. | 19th cheapest of 345 $181 a month | 93rd of 345, with limits $140 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 Modal handles 300 user sandboxes at once on its Team plan; Sprites does not publish a running cap on pay as you go, and bochka keeps each user's disk while stopped. | 11th cheapest of 361 $811 a month | 56th of 361, with limits $428 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 RL rollouts launch many short sandboxes at once, which is what Modal is built for; Sprites does not publish how many can run at once. | 5th cheapest of 360 $19,038 a month | 105th of 360, with limits $6,540 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 | 59th cheapest of 364 $1,244 a month | 125th of 364, with limits $545 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 jobs that build Docker images work on Sprites and in every bochka sandbox, while Modal needs its VM runtime for Docker. | 126th cheapest of 377 $1,793 a month | 63rd cheapest of 377 $476 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box kept for months fits Sprites and bochka, which keep their disk, better than Modal, whose sandboxes end within 24 hours. | 138th of 368, with limits $23 a month | 213th of 368, with limits $27 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 Computer-use agents need a screen: bochka streams a 60fps desktop with Chromium, while Modal and Sprites are headless and you set up the desktop yourself. | 98th of 369, with limits $183 a month | 85th of 369, with limits $136 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 | 177th of 367, with limits $136 a month | 171st of 367, with limits $122 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 | 267th of 346, with limits $394 a month | 229th of 346, with limits $206 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 | 223rd of 338, with limits $8,795 a month | 141st of 338, with limits $4,113 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 | Can't run it | 210th of 360, with limits $223 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 Modal has GPUs from T4 to B300; Sprites and bochka have none, so Modal is the pick for GPU jobs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | Sprites | bochka |
|---|---|---|---|
| Isolation | gVisor by default; VM runtime with its own kernel available | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Disk between sessions | No paused state; a finished sandbox is gone, only Volumes keep files | Persistent 100 GB disk that syncs to object storage | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Longest session | 24 hours (default 5 minutes) | No time cap, but pauses about 30 seconds after activity stops | No cap on paid plans (default TTL 1 h, changeable) |
| Idle behavior | Pays the full request until the idle timeout ends the sandbox | Sleeps when idle, wakes on the next request in 100 to 500 ms | Runs until you stop it or its time to live ends |
| Docker and systemd | Docker only with the VM runtime | Docker (with rough edges users report); no systemd | Docker, systemd and /dev/kvm in every sandbox |
| Machine size and image | Size set in code; build images in code or pull any registry image | Fixed 8 vCPU and one managed Ubuntu image | You choose, up to 16 vCPU / 32 GB; named snapshots as templates |
| Fork and snapshots | Filesystem snapshots into images; memory snapshots in alpha | Checkpoints that restore in place; no fork | Fork a running sandbox without stopping it |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Reaching the sandbox | Encrypted and raw TCP tunnels, connect tokens | One HTTPS URL to one HTTP port; SSH only through the sprite proxy CLI | HTTPS on up to 50 ports, raw TCP, dedicated IP and SSH |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | DNS-based domain allowlist; private IPs always blocked | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets are environment variables, or your own proxy in a sidecar | Connectors gateway holds tokens for any HTTP API, with path rules | Credentials proxy for model providers and any HTTPS API |
| Coding agents | Examples only | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec | Seven agents preinstalled, with an API to prompt and steer them from outside |
| Desktop and browser | Not offered; an example shows how to set up VNC | Headless | 60fps desktop, Chromium and computer use built in |
| Regions | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | Not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Modal | Sprites | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | 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) | Not published | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the hpc-sandbox-benchmarks Node.js build-and-test run at 4 vCPU / 8 GB on 29 September 2026, bochka finished 26.69 runs per second and Modal's default gVisor sandbox 12.79, so bochka did about twice the work. Sprites is not in those results, so there is no comparable measurement for it, and a Sprite always has 8 vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Sprites, 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 | $15 · Starter · with limits | $23 · Pay-as-you-go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $92 · Pay-as-you-go | $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 | $2,229 · Starter · with limits | $1,120 · Pay-as-you-go | $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 | $792 · Team | $314 · Pay-as-you-go · 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 | $3,193 · Team · with limits | $1,134 · Pay-as-you-go · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, and an idle sandbox pays until it ends. Starter is free with $30 of monthly credit and Team is $250 a month with $100 of credit.
Sprites: Sprites bills the CPU time and memory a Sprite actually uses while awake, at $0.0385 per CPU-hour and $0.021875 per GB-hour, plus storage on the bytes you write. Optional plans include fixed CPU, memory and storage allowances that are not credit.
Sprites: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit.
Limits in those scenarios
On Modal the 24-hour cap and the wiped root disk mean the workday, always-on and fleet scenarios keep only what you put in a Volume, and the 50-agent fleet needs the VM runtime for Docker. Sprites fits those three, 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, and creation is 10 a minute without a plan. Modal handles the 300 user sandboxes on Team, while its 1,000-job burst runs on shared vCPUs. bochka's limit is start speed: even its $2,000 plan queues starts above 90 a minute.
| Scenario | Modal | Sprites | 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, must run in a chosen region, or are huge bursts of short jobs that finish in minutes.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Huge bursts of short jobs. Modal runs up to 5,000 containers on Team, which suits RL rollouts and big fan-outs that finish in minutes.
- Regions and custom images. Modal runs in the US, EU and Asia-Pacific, and builds images in code or pulls any registry image.
Use Sprites when
each agent or user needs a persistent machine that sits idle most of the day and should wake on a request.
- A computer that stays yours. Each Sprite keeps its 100 GB disk and software between sessions, with no 24-hour limit.
- Sleeps when idle, wakes on request. For agents idle most of the day: a Sprite stops billing compute when idle and wakes in under a second.
- Docker and stored credentials. Docker runs in every Sprite, and Connectors keep API tokens outside the machine with per-path rules.
Where bochka fits
If your agents work for hours or days, Modal cuts them off at 24 hours and Sprites pauses them when they go quiet. bochka gives each agent a full VM that keeps running, keeps its disk, and comes with a desktop, many ports and an API to drive the agents inside from outside.
A full machine that keeps running
On Modal a sandbox ends within 24 hours and its root disk goes with it unless you save to a Volume. On Sprites an agent waiting on a queue pauses and drops its connections unless a task hold, renewed every hour, keeps it awake.
Docker, systemd and /dev/kvm together
Modal needs its VM runtime for Docker, and Sprites has Docker but no systemd and no /dev/kvm in its docs, so services must be rewritten and Android emulators will not run. bochka has all three in every sandbox.
A screen, many ports and forks
Both Modal and Sprites are headless, so a computer-use agent needs a display and stream you build yourself. Sprites exposes one HTTP port and has no fork; bochka streams a 60fps desktop, serves 50 HTTPS ports and forks a running sandbox.
Use bochka when your agents work for hours or days and need a full machine: Docker, systemd, emulators, a desktop, many ports, forks and an API to drive the agents inside from outside. Compare it one to one: bochka vs Modal and bochka vs Sprites.
Questions people ask
Is Modal cheaper than Sprites?
In most of our scenarios Sprites costs less: one agent that never stops is $92 a month on Sprites against $178 on Modal, and 50 parallel agents are $1,120 against $2,229. Modal is a little cheaper for one agent on workdays ($15 against $23), but its files reset between days unless you use a Volume. bochka comes to $26 and $317 a month for those two scenarios.
Which is faster, Modal or Sprites?
We have no comparable measurement for Sprites. Modal's default sandbox did 12.79 runs per second at 4 vCPU / 8 GB in the hpc-sandbox-benchmarks Node.js test, and bochka did 26.69 in the same run.
Can Modal and Sprites run Docker?
Modal runs Docker only with its VM runtime. Docker runs inside a Sprite, though users report that docker exec fails for containers whose main process is not root. Every bochka sandbox runs Docker, with systemd and /dev/kvm too.
How long can a session last on Modal and on Sprites?
A Modal sandbox lasts at most 24 hours, with a default of 5 minutes. A Sprite has no time cap but pauses about 30 seconds after activity stops, and a task hold keeps it awake for up to an hour at a time. bochka has no session cap on paid plans.
Do Modal or Sprites have GPUs?
Modal rents GPUs from T4 to B300 on its gVisor runtime. Sprites has no GPUs, and neither does bochka.
Can I choose where my sandbox runs?
Modal runs in the US, EU and Asia-Pacific, and pinning a region costs 1.15x to 1.75x. Sprites does not let you choose a region. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview