Vercel Sandbox vs Sprites
Both run each sandbox in a Firecracker microVM, and both keep files between sessions. Vercel Sandbox runs untrusted code from your own image in 19 regions, in sessions of up to 24 hours that resume from a snapshot. 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, fork sandboxes, mount Drives and set network rules. Sandboxes are persistent by default: each stop saves the filesystem, and the next session resumes from it. Vercel aims it at code interpreters, app builders, test runs, developer environments and agent workspaces. Its docs suggest a VM for 24/7 hosting.
- Default image
- Ubuntu; the universal image adds Node.js 24, Python 3.14, Bun, and Claude Code, Codex, OpenCode and pi preinstalled
- Longest session
- 24 hours on Pro and Enterprise, 45 minutes on Hobby; a persistent sandbox resumes from its last snapshot with no cap on total lifetime
- Biggest sandbox
- 8 vCPU / 16 GB on Pro, 32 vCPU / 64 GB on Enterprise
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 that scales from 2 GB to 16 GB as needed, and a 100 GB ext4 disk backed by object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled. It gets an HTTPS URL that wakes it, and it bills only for the CPU and memory it 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
- 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. “27th cheapest of 336” means 26 of the other 335 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 | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 259th of 365, with limits $3,351 a month | 101st of 365, with limits $546 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB On Vercel a persistent sandbox resumes across 24-hour sessions, and an onResume hook restarts your processes. On Sprites the machine pauses when idle unless a Tasks API hold keeps it awake. boat keeps the machine running once auto-stop is off (default 1 hour). | 75th of 361, with limits $3,657 a month | 214th of 361, with limits $1,166 a month | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit short code runs. Vercel bills CPU only while code uses it and runs up to 10,000 sandboxes at once on Pro. A Sprite sleeps about 30 seconds after the last command and bills only used CPU and memory. boat's start limits slow down large bursts. | 27th cheapest of 336 $216 a month | 99th of 336, with limits $140 a month | 189th of 336, 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. Sprites wakes each user's machine on the first request, but has no published running cap on pay as you go. | 25th cheapest of 349 $1,267 a month | 61st of 349, with limits $428 a month | 3rd cheapest of 349 $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 on pay as you go. | 7th cheapest of 349 $15,761 a month | 114th of 349, with limits $6,540 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 81st cheapest of 359 $1,508 a month | 130th of 359, with limits $545 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit CI runs. boat adds /dev/kvm for Android and VM image builds. | 112th cheapest of 374 $1,144 a month | 63rd cheapest of 374 $476 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Sprites keeps its disk and software with no session cap; you set up SSH yourself, and services run through its services API, not systemd. On Vercel the files stay across sessions, but running processes start again every 24 hours. | 283rd of 371, with limits $145 a month | 120th cheapest of 371 $27 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither has a built-in desktop, so on both you set up a display, a browser and a stream yourself. boat streams a 60 fps desktop. | 263rd of 367, with limits $952 a month | 132nd of 367, with limits $136 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month On Vercel you install Chromium and agent-browser yourself (Vercel has a guide) or connect an external browser. On Sprites you install a browser yourself, for example headless Chromium with Playwright. boat ships Chrome on a desktop you can watch. | 100th of 356, with limits $486 a month | 236th of 356, with limits $122 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 109th cheapest of 343 $468 a month | 279th of 343, with limits $206 a month | 6th cheapest of 343 $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 327, with limits $9,960 a month | 139th of 327, with limits $4,113 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 31st cheapest of 351 $554 a month | 243rd of 351, with limits $223 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Vercel Sandbox | Sprites | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared |
| Longest session | 24 hours per session on Pro and Enterprise, 45 minutes on Hobby; the sandbox then resumes from its snapshot, with no cap on total lifetime | No time cap, but it pauses about 30 seconds after activity stops; a Tasks API hold keeps it awake up to an hour at a time | No session cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour and goes up to 30 days |
| 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 auto-stop or until you stop it, and bills its full size, busy or idle; no compute charge while stopped |
| 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 scales from 2 GB to 16 GB as needed | You choose: 2 to 16 vCPU and 4 to 32 GB; 16 vCPU needs the $100 plan or higher |
| Saving files | Filesystem snapshot at every stop ($0.08/GB-month), kept 30 days after last use by default or set to never; Drives keep mounted storage until you delete them | Disk persists; checkpoints by hand or automatic, restored in place; memory is kept while a Sprite is paused | Disk saved every minute and at each stop; disk kept at least 14 days after a stop, longer with a saved snapshot |
| Images | Your own OCI images from a Dockerfile, via Vercel Container Registry | One managed Ubuntu image; you install on top of it and save that as a checkpoint | boat's image or a saved snapshot (template), shareable by code; you cannot boot your own Docker image |
| Docker and nested virtualization | Docker with sudo; no nested virtualization (Firecracker does not expose /dev/kvm) | Root and Docker (a user reports docker exec fails for non-root containers); services run through the services API, not systemd; 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 SSH server, raw TCP or public IP | One HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLI | Up to 50 HTTPS URLs, token-gated by default; SSH; raw ports over IPv6 (some sandboxes have no IPv4 of their own); no static IP |
| 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 | Optional AI credentials proxy ($1 per day on, plus $1 per 1,000 requests) for model providers and any HTTPS API you add |
| 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 installed, with a prompt, steer and events API to drive them from outside |
| Desktop, browser, computer use | No built-in desktop or computer-use API; you install Chromium and agent-browser yourself (Vercel guide) or connect an external browser | No desktop or browser built in; you install a browser, display server and stream yourself | 1920x1080, 60 fps desktop and Chrome, computer tools and a browser-control API, embeddable stream |
| Regions | 19 regions across the US, Europe, Asia, South America, Africa and Australia | No region option when you create a Sprite | Germany, Finland and France; you cannot pick a region; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Vercel Sandbox | Sprites | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No documented way | Yes |
| Desktop GUI | No documented way | No documented way | Yes |
| Browser | With your own setup | No documented way | Yes |
| Computer-use API | No documented way | No documented way | Yes |
| SSH | No documented way | With your own setup | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No documented way | Yes |
| Live fork (no pause) | Yes | No documented way | Yes |
| Memory fork | No documented way | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No documented way | Yes | No documented way |
| Wake on request | No documented way | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | No documented way | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No documented way | No documented way | Yes |
| Audit logs | Not published | Not published | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | Yes | No documented way | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
On the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, boat did 28.06 runs per second and Vercel Sandbox did 12.66 (about 2.2x), in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host; boat also places sandboxes on Ryzen 7 9700X hosts and does not promise a CPU model. Providers ran on different hardware in different regions. Sprites is not in the public benchmarks we use, so we cannot say how it compares, and a Sprite always has 8 vCPU, so a fair test would need a matching shape. This measures CPU speed only, not start time.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Sprites is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | Vercel Sandbox, a month | Sprites, 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 | $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 | $8,800 · $2000/mo · with limits |
Vercel Sandbox: Vercel charges for CPU only while your code uses it ($0.128 per vCPU-hour in iad1), and for memory for the whole time the sandbox runs ($0.0212 per GB-hour). It adds $0.60 per million sandboxes created, $0.08 per GB-month of snapshots, and $0.05 per GB-month for Drives plus reads and writes. 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. Storage costs about $0.50 per GB-month for hot data while awake and about $0.02 per GB-month for cold data. Pay as you go has no plan fee. Optional plans buy fixed CPU, memory and storage allowances, not credit.
Sprites: boat charges a flat price per size, per second, while the sandbox runs, busy or idle: $0.036 an hour for 4 vCPU / 8 GB. Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A card is required, also for the 7-day trial. A stopped sandbox has no compute charge, but saved snapshots above the plan's count and the optional AI credentials proxy still charge. Starts above the plan's included number cost $0.03 to $0.07 each.
Limits in those scenarios
For one agent that never stops, Vercel ends each session at 24 hours and running processes start again, while a Sprite fits but needs a Tasks API 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. boat does not fit 1,000 short jobs at once: the $2,000 plan includes 600 starts an hour and 2,400 a day, extra starts are paid (about $8,800 a month), and starts above 270 a minute fail with 429.
| Scenario | Vercel Sandbox | Sprites | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario | None for this scenario | None for this scenario |
| One agent that never stops |
| None for this scenario | None for this scenario |
| 50 agents in parallel | None for this scenario |
| None for this scenario |
| Sandboxes for your users | None for this scenario |
| None for this scenario |
| 1,000 short jobs at once | None for this scenario |
|
|
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 has no region option.
- 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.
- One machine, no session cap. Useful when one machine should live for weeks: a Sprite keeps its disk, software and paused memory 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 boat fits
Vercel Sandbox suits bursts of short runs, and Sprites suits machines that mostly sleep. If your agents work for hours on one machine and need Docker, systemd, emulators, many ports or a screen, look at boat: a full VM with a desktop and an API to drive the agents inside. boat bills its full size while it runs, runs only in the EU and limits starts per plan.
Agents that keep working
Vercel stops each session at 24 hours; the sandbox resumes, but running processes start again. A Sprite pauses when idle and drops open connections unless a task hold, renewed every hour, keeps it awake. On boat, turn auto-stop off on a paid plan (default 1 hour) for no session cap.
A full machine with a screen
Neither has a built-in desktop or /dev/kvm, and Sprites runs services through its own API instead of systemd. boat ships a 60 fps desktop, Chrome, 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 through its proxy CLI. Both make you script the agents as commands. boat gives up to 50 token-gated URLs, SSH, raw ports over IPv6 and one agent API.
Use boat 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. Check the start limits of your plan first. Compare it one to one: boat vs Vercel Sandbox and boat vs Sprites.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
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 also lower, but its running limits there are not confirmed. boat is $20 and $317 for the first two.
Which is faster, Vercel Sandbox or Sprites?
We cannot say: Vercel Sandbox did 12.66 V8 Web Tooling Benchmark runs per second at 4 vCPU / 8 GB in StarSling's run of 3 October 2026, and Sprites is not in that benchmark. boat did 28.06 in the same run, on an AMD Ryzen 9 9950X host. 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, then resumes from its filesystem snapshot, and an onResume hook can restart your processes. 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. boat has no session cap once auto-stop is off (default 1 hour).
Can they run Docker?
Both run Docker. Vercel Sandbox runs it with sudo. On Sprites a user reports that docker exec fails for containers that do not run as root, and Sprites runs services through its services API instead of systemd. Neither documents nested virtualization; boat runs Docker, systemd and /dev/kvm.
Do Vercel Sandbox or Sprites have a desktop for computer use?
Not built in. Both are Linux microVMs with root, so you can install a display, a browser and a stream yourself; Vercel has a guide for Chromium and agent-browser. boat includes a 60 fps desktop, Chrome, computer tools and a browser-control API.
Where do they run?
Vercel Sandbox runs in 19 regions, with iad1 in the US as the default. Sprites has no region option. boat runs on machines in Germany, Finland and France, and you cannot pick a region.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Vercel Sandbox
- boat 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