Vercel Sandbox vs Sprites
Both run each sandbox in a Firecracker microVM. Vercel Sandbox is built for short runs of untrusted code from your own image in 19 regions, with sessions capped at 24 hours, while a Sprite is a persistent machine that sleeps when work stops and wakes on the next request.
The companies and products
Vercel Sandbox
Vercel is a cloud platform for web apps and agents, and Vercel Sandbox is its product for running untrusted or agent-written code in isolated Linux microVMs.
Each sandbox is a Firecracker microVM with its own kernel, started from a Vercel image, your own OCI image, or a saved snapshot. You drive it with the JavaScript or Python SDK or the sandbox CLI: run commands, move files, open ports, and set network rules. It is aimed at code interpreters, app builders, test runs and agent tools, and Vercel's docs say it is not meant to run nonstop.
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. “22nd cheapest of 345” means 21 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 | Vercel Sandbox: 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 | 244th of 367, with limits $3,351 a month | 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 assistant hits Vercel's 24-hour session cap, and on Sprites it pauses when idle unless a task holds it awake; bochka keeps the machine running. | 257th of 366, with limits $3,657 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 Vercel Sandbox fits short code bursts best of the three: Vercel ranks 22nd and Sprites 93rd, and bochka's start limits slow down large bursts. | 22nd cheapest of 345 $216 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 Vercel Sandbox fits sandboxes for your users at scale, while Sprites has no published running cap on pay as you go; bochka ranks first here. | 15th cheapest of 361 $1,267 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 Many short parallel rollouts suit Vercel Sandbox, which handles high concurrency; Sprites does not publish how many can run at once. | 3rd cheapest of 360 $15,761 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 | 69th cheapest of 364 $1,508 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 Both run CI; Sprites ranks 63rd and Vercel 107th, and bochka adds /dev/kvm for Android and VM image builds. | 107th cheapest of 377 $1,144 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 Neither fits a 24/7 dev box cleanly: Vercel restarts every 24 hours and Sprites has no systemd or direct SSH, while bochka has both. | 276th of 368, with limits $145 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 Neither Vercel Sandbox nor Sprites has a desktop, so computer-use agents need one built by hand; bochka streams a 60fps desktop. | 235th of 369, with limits $952 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 Both are headless, so you install and run a browser yourself; bochka ships Chromium on a desktop you can watch. | 259th of 367, with limits $486 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 | 277th of 346, with limits $468 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 | 234th of 338, with limits $9,960 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 | 283rd of 360, with limits $554 a month | 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 | 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 | Vercel Sandbox | Sprites | 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 |
| Longest session | 24 hours on Pro and Enterprise, 45 minutes on Hobby; resume starts a new session | No time cap, but it pauses about 30 seconds after activity stops; a task hold keeps it awake up to an hour at a time | No cap on paid plans (--no-auto-stop); default TTL 1 hour, changeable |
| Idle behavior | No idle auto-stop; runs until its timeout or stop, with memory billed the whole time | Sleeps when idle and wakes on the next request in 100 to 500 ms, or 1 to 2 s after a cold stop | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Machine size | You choose, up to 8 vCPU / 16 GB on Pro and 32 vCPU / 64 GB on Enterprise | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Saving files | Filesystem snapshot on stop, billed per GB a month and kept 30 days after last use | Disk persists; checkpoints by hand or automatic, restored in place | Disk saved every minute and on stop; named snapshots to start new sandboxes from |
| Images | Your own OCI images from a Dockerfile, via Vercel Container Registry | One managed Ubuntu image; you install on top of it | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Docker and nested virtualization | Docker with sudo; no nested virtualization | Docker with rough edges users report; no systemd, and no /dev/kvm in the docs | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Reaching the sandbox | Public URLs for up to 15 ports, no built-in auth; no raw TCP or public IP | One HTTPS URL to one HTTP port, private by default; other ports and SSH only through the sprite proxy CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Allow-all, deny-all or a domain and CIDR allowlist, changeable while running; static IPs on Enterprise | Optional DNS-based domain allowlist set from outside; private IPs always blocked | Open internet, no provider-side allowlist; firewall inside the VM |
| Keys kept outside the sandbox | Credentials brokering injects headers for any HTTPS domain you allow | Connectors gateway holds the token for any HTTP API, with path allow and block lists | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Claude Code, Codex, OpenCode and pi preinstalled; you start them as commands | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop, browser, computer use | None; headless Linux only | None; headless | 60fps desktop and Chromium, computer-use and browser-control APIs, embeddable stream |
| Regions | 19 regions across the US, Europe, Asia, South America, Africa and Australia | Region not selectable | EU only: Germany, Finland, France, with EU data residency |
| CPU speed (Node.js test, 4 vCPU / 8 GB) | 12.96 runs/s | Not measured | 26.69 runs/s |
Every feature Battleships tracks (43)
| Feature | Vercel Sandbox | Sprites | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | 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 | No | 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 | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | 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
On the same hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Vercel Sandbox did 12.96, so bochka finished about twice as many runs. Sprites has no comparable measurement yet, and a Sprite always has 8 vCPU, so a fair test would need a matching shape. 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. 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 | Vercel Sandbox, 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 | $57 · Pro | $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 | $236 · Pro · 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,884 · Pro | $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 | $828 · Pro | $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,152 · Pro | $1,134 · Pay-as-you-go · with limits | $2,000 · $2000/mo · with limits |
Vercel Sandbox: Vercel charges for CPU only while your code uses it, but for memory the whole time the sandbox runs, plus a small fee per sandbox created and a monthly fee per GB of snapshots. The $20 Pro credit is shared with your other Vercel usage.
Sprites: Sprites bills actual 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, not credit.
Sprites: bochka charges a flat price per size, per second, only while the machine runs; a stopped sandbox costs nothing. Plans start at $20 a month, and all of the fee is usage credit.
Limits in those scenarios
For one agent that never stops, Vercel ends each session at 24 hours and running processes start over, while a Sprite fits but needs a task hold to stay awake. Sprites does not publish how many Sprites can run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed there; Vercel fits both. bochka does not fit 1,000 short jobs at once: even the $2,000 plan allows 600 starts an hour and 2,400 a day.
| Scenario | Vercel Sandbox | Sprites | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | 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 |
| None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Vercel Sandbox when
you run many short bursts of untrusted code, want to boot from your own Dockerfile, or need to run close to users around the world.
- Regions all over the world. Useful if your users are spread out: Vercel Sandbox runs in 19 regions, while Sprites does not let you pick one.
- Boot from your own Dockerfile. Useful if you already have a Dockerfile: build it into an OCI image and start sandboxes straight from it.
- Built for big bursts. Useful for code interpreters and RL rollouts that start thousands of short sandboxes, with a firewall you can change while one runs.
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, keeping one persistent machine with no session time limit.
- Sleeps when idle, wakes on request. Useful for agents and apps that sit idle most of the day: a Sprite stops billing compute and wakes on the next request.
- No 24-hour cap. Useful when one machine should live for weeks: a Sprite keeps its disk and software with no session time limit.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, with a remote MCP server.
Where bochka fits
Vercel Sandbox suits short bursts and Sprites suits machines that mostly sleep. If your agents work for hours on one machine and need Docker, emulators, many ports or a screen, look at bochka: a full VM that keeps running, with a desktop and an API to drive the agents inside from outside.
Agents that keep working
Vercel stops each session at 24 hours and running processes start over. A Sprite pauses when idle and drops open connections unless a task hold, renewed every hour, keeps it awake. bochka has no session cap on paid plans.
A full machine with a screen
Neither has a desktop or /dev/kvm, and Sprites has no systemd, so computer-use agents, Android emulators and service stacks need workarounds. bochka ships a 60fps desktop, Chromium, systemd and /dev/kvm.
Reach it and drive it from outside
Vercel gives up to 15 open ports and Sprites one HTTP port, with SSH only through its proxy CLI. Both make you script the agents as commands. bochka gives 50 token-protected ports, raw TCP, SSH and one agent API.
Use bochka when your agents work for hours on one machine: Docker, systemd, emulators, many ports, a desktop with a browser, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Vercel Sandbox and bochka vs Sprites.
Questions people ask
Is Vercel Sandbox cheaper than Sprites?
Not in our scenarios. One coding agent on workdays comes to $57 a month on Vercel Sandbox and $23 on Sprites, and 50 agents in parallel are $2,884 versus $1,120. Sprites' figures for 300 user sandboxes and 1,000 jobs at once are lower, but its running limits there are not confirmed.
Which is faster, Vercel Sandbox or Sprites?
We cannot say yet: Vercel Sandbox did 12.96 runs per second on our Node.js test at 4 vCPU / 8 GB, and Sprites has no comparable measurement. bochka did 26.69 on the same test. For waking up, a Sprite resumes in 100 to 500 ms with its memory, or 1 to 2 seconds from a cold stop.
Can Vercel Sandbox or Sprites run 24/7?
Vercel Sandbox cannot as one session: it stops after 24 hours and resumes from its filesystem snapshot with processes started over. A Sprite has no time cap, but it pauses about 30 seconds after activity stops unless a task hold keeps it awake for up to an hour at a time.
Can they run Docker?
Both run Docker. Vercel Sandbox runs it with sudo; on Sprites users report that some containers fail with docker exec, and Sprites does not run systemd. Neither offers nested virtualization, while bochka runs Docker, systemd and /dev/kvm.
Do Vercel Sandbox or Sprites have a desktop for computer use?
No. Both are headless Linux microVMs, so a computer-use or browser agent needs a display, browser and stream you set up yourself. bochka includes a 60fps desktop, Chromium, and computer-use and browser-control APIs.
Where do they run?
Vercel Sandbox runs in 19 regions, with iad1 in the US as the default. Sprites does not let you pick a region. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Vercel Sandbox
- bochka vs Sprites
- E2B vs Vercel Sandbox
- Daytona vs Vercel Sandbox
- Modal vs Vercel Sandbox
- Vercel Sandbox vs Cloudflare Sandbox
- Vercel Sandbox vs Blaxel
- Vercel Sandbox vs Runloop
- Vercel Sandbox vs Tensorlake
- Vercel Sandbox vs Morph Cloud
- Vercel Sandbox vs CodeSandbox SDK
- Vercel Sandbox vs Northflank