Sprites vs Upstash Box
Both give an AI agent a computer that pauses when idle and wakes on the next request. A Sprite is a Firecracker microVM with a fixed 8 vCPU and a 100 GB disk that can run Docker, while an Upstash box is a lighter Docker container in three sizes that bills only the CPU it uses and does not run Docker inside.
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
Upstash Box
Upstash Box is a cloud computer for AI agents from Upstash, the company known for serverless Redis, Vector and QStash.
Each box is a Docker container with its own filesystem, shell, git and an optional coding agent such as Claude Code, Codex or OpenCode, which you drive from TypeScript or Python SDKs. A box pauses when it sits idle, keeps its files, and you pay for the CPU it actually uses. Upstash built it to run its own Context7 service and opened it to everyone in March 2026.
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 | Upstash Box: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A Sprite can run Docker for databases and test services, which an Upstash box cannot, and bochka adds systemd, /dev/kvm and up to 50 public ports. | 66th of 367, with limits $546 a month | 61st of 367, with limits $464 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Upstash keeps an agent on all month with a flat keep-alive box, while a Sprite pauses about 30 seconds after work stops unless a task holds it awake; bochka just keeps the machine running. | 157th of 366, with limits $1,166 a month | 103rd of 366, with limits $475 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 Upstash fits short code runs best of the three: an idle box costs no CPU, RAM is not billed, and 1,000 boxes can run at once. | 93rd of 345, with limits $140 a month | 10th cheapest of 345 $119 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 Upstash Box ranks 2nd here and bochka ranks 1st, while Sprites does not publish how many machines can run at once on pay as you go. | 56th of 361, with limits $428 a month | 2nd cheapest of 361 $222 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 | 352nd of 360, with limits $8,068 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 | 52nd cheapest of 364 $1,011 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 fits CI better than Upstash because it can run Docker, and bochka adds /dev/kvm for Android builds and VM images. | 63rd cheapest of 377 $476 a month | 120th cheapest of 377 $1,520 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A flat keep-alive box on Upstash makes a cheap light dev box, while a Sprite gives a bigger 100 GB disk; bochka gives a full VM with SSH and systemd. | 213th of 368, with limits $27 a month | 10th cheapest of 368 $20 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: Sprites is headless, Upstash has only a headless Chromium, and bochka streams a 60fps desktop. | 85th of 369, with limits $136 a month | 73rd of 369, with limits $76 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 Upstash ships a managed headless Chromium with AI page actions, Sprites has no browser product, and bochka gives the agent a desktop browser you can watch. | 171st of 367, with limits $122 a month | 49th of 367, with limits $38 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 | 37th cheapest of 346 $400 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 | 200th of 338, with limits $8,000 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 | 225th of 360, with limits $259 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 | Upstash Box | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Docker container per box on AWS | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU; memory set and scaled by the platform | Small 2 vCPU / 4 GB, Medium 4 vCPU / 8 GB, Large 8 vCPU / 16 GB | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Disk | Fixed 100 GB disk that syncs to object storage | 5, 10 or 20 GB by size, billed per GB-month | 50 GB at the default 4 vCPU / 8 GB size, 12 to 251 GB by size |
| Docker inside | Yes, with rough edges users report; no systemd | Not documented; the box is itself a Docker container | Yes, Docker and systemd run as on any Linux server |
| Nested virtualization | No /dev/kvm in the docs | No; boxes are containers | Yes, /dev/kvm for Android emulators and VMs |
| Idle and wake | Pauses about 30 seconds after activity stops; wakes on the next request in 100 to 500 ms, or 1 to 2 s after a cold stop | An idle box costs no CPU; a paused box wakes when a request reaches its public URL | Runs until you stop it; a stopped sandbox costs nothing and is started again by API |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | Snapshot a running box and start many new boxes from it | Disk saved every minute and on stop; fork a running sandbox with its disk |
| Running at once | Not published on pay as you go; optional plans list 20 to 2,000 running Sprites | 1,000 boxes on Pay as You Go, raised on request | No session cap on paid plans; starts are rate limited, at most 90 a minute on the $2,000 plan |
| Reaching the sandbox | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | HTTPS URL per port, public unless you add a token; SSH through a gateway; no raw TCP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IP; SSH |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Allow all, deny all, or allow and deny by domain and CIDR, changeable on a running box | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Connectors hold the token for any HTTP API, with path allow and block lists | Host proxy injects headers into outbound HTTPS; set when the box is created | 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 | Claude Code, Codex and OpenCode built in, with run and stream APIs, webhooks and scheduled prompts | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | Managed headless Chromium with AI page actions and CDP; no desktop | 60fps Linux desktop with Chromium and computer-use tools |
| Regions | Not selectable | US only (AWS us-east-1) | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | Upstash Box | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | 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 | Yes | No |
| Wake on request | Yes | Yes | 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 | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | 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 | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Sprites nor Upstash Box has a result in the hpc-sandbox-benchmarks CPU test we use, so there is no comparable measurement for either. bochka did 26.69 runs per second on that 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 Upstash Box 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 | Upstash Box, 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 | $21 · Pay as You Go | $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 | $21 · 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 | $1,120 · Pay-as-you-go | $900 · Pay as You Go · 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 | $306 · Pay as You Go | $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,822 · Pay as You Go | $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 buy fixed CPU, memory and storage allowances that are not credit.
Upstash Box: A standard box is billed for the CPU it uses, at $0.10, $0.20 or $0.40 per active CPU hour for Small, Medium and Large, plus $0.10 per GB-month of storage, and RAM is free. A keep-alive box costs a flat $8, $16 or $32 a month.
Upstash Box: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Upstash does not run Docker inside a box, so 50 agents in parallel with Docker do not fit there, and its disks stop at 20 GB. Sprites does not publish how many machines can run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed, while Upstash runs 1,000 boxes by default. A Sprite pauses when nothing holds it awake and its open connections drop, so an always-on agent needs a task hold that lasts at most an hour and must be renewed. bochka has no session cap on paid plans, but for 1,000 short jobs at once it queues starts above 90 a minute.
| Scenario | Sprites | Upstash Box | 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 need Docker and a big disk on a machine that sleeps when idle, or you already run on Fly.io or Claude Managed Agents.
- A real VM that can run Docker. Agents that start a database or test service in Docker can do it inside a Sprite, which an Upstash box does not offer.
- A big fixed disk. Every Sprite has 8 vCPU and a 100 GB disk, so big repos and build caches fit without picking a size.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, next to the rest of Fly.io.
Use Upstash Box when
your agents mostly wait, you want to pay only for active CPU, you need 1,000 boxes at once, or you must run in the US.
- Pay only for active CPU. Good for agents that wait a lot: an idle box costs no CPU, RAM is free, and a keep-alive box is a flat monthly price.
- Big bursts out of the box. Pay as You Go runs 1,000 boxes at once by default, so a burst of short jobs starts without waiting.
- Agent APIs and network rules. Built-in agents come with run and stream APIs, webhooks and scheduled prompts, and outbound rules work by domain or IP range.
Where bochka fits
Sprites and Upstash Box both pause when idle, which suits agents that wait a lot. If your agents work for hours and need a full machine, with Docker, systemd, emulators, many ports, a desktop and forks, bochka gives them that, and a stopped sandbox costs nothing while it keeps its disk.
A full Linux machine
An Upstash box cannot run Docker inside, so the 50-agent scenario does not fit there. A Sprite runs Docker with rough edges and no systemd. Neither documents /dev/kvm, so Android emulators and nested VMs are out on both.
A screen for computer use
Sprites is headless and Upstash has only a headless Chromium. A computer-use agent there has no desktop to look at, so you would install a display server and a streaming layer yourself. bochka streams a 60fps desktop.
Reach it and branch it
On Sprites, a second port or SSH goes through the sprite proxy on your own machine, and checkpoints restore in place. Upstash has no raw TCP. bochka gives SSH, raw TCP, 50 HTTPS ports and a fork of a running sandbox.
Use bochka when your agents need a full machine for hours: 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 Upstash Box.
Questions people ask
Is Sprites cheaper than Upstash Box?
In most of our scenarios, no. One agent that never stops comes to $21 a month on Upstash against $92 on Sprites, and one coding agent on workdays is $21 against $23. For 1,000 short jobs at once Sprites comes to $1,134 against $1,822, but how many Sprites can run at once is not published.
Which is faster, Sprites or Upstash Box?
We cannot say: neither has a result in the hpc-sandbox-benchmarks CPU test we use. A Sprite always has 8 vCPU, while Upstash sizes go from 2 to 8 vCPU. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Sprites or Upstash Box run Docker?
Users run Docker inside Sprites, though a community report says docker exec fails for containers whose main process is not root, and Sprites do not run systemd. Upstash does not offer Docker inside a box, since each box is itself a Docker container. bochka runs Docker and systemd in every sandbox.
Can I SSH into a Sprite or an Upstash box?
On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. Upstash gives SSH through a gateway. bochka sandboxes have SSH, raw TCP and a dedicated IP.
Do they keep running when idle?
A Sprite pauses about 30 seconds after activity stops, unless a task holds it awake for up to an hour at a time. A standard Upstash box pauses after it sits idle, and a keep-alive box stays on all month for a flat price. A bochka sandbox runs until you stop it.
Where do Sprites and Upstash Box run?
Sprites does not let you choose a region. Upstash Box runs in AWS us-east-1 in the US. bochka runs in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview