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.

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.

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 workloadVercel Sandbox: price rankSprites: price rankboat: 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 requirementNot ranked: misses a requirementNot 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureVercel SandboxSpritesboat
IsolationFirecracker microVM with its own kernelFirecracker microVM with its own kernelFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Longest session24 hours per session on Pro and Enterprise, 45 minutes on Hobby; the sandbox then resumes from its snapshot, with no cap on total lifetimeNo time cap, but it pauses about 30 seconds after activity stops; a Tasks API hold keeps it awake up to an hour at a timeNo session cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour and goes up to 30 days
Idle behaviorNo idle auto-stop; runs until its timeout or stop, with memory billed the whole timeSleeps when idle and wakes on the next request in 100 to 500 ms, or 1 to 2 s after a cold stopRuns until auto-stop or until you stop it, and bills its full size, busy or idle; no compute charge while stopped
Machine sizeYou choose, up to 8 vCPU / 16 GB on Pro and 32 vCPU / 64 GB on EnterpriseFixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as neededYou choose: 2 to 16 vCPU and 4 to 32 GB; 16 vCPU needs the $100 plan or higher
Saving filesFilesystem 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 themDisk persists; checkpoints by hand or automatic, restored in place; memory is kept while a Sprite is pausedDisk saved every minute and at each stop; disk kept at least 14 days after a stop, longer with a saved snapshot
ImagesYour own OCI images from a Dockerfile, via Vercel Container RegistryOne managed Ubuntu image; you install on top of it and save that as a checkpointboat's image or a saved snapshot (template), shareable by code; you cannot boot your own Docker image
Docker and nested virtualizationDocker 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 docsRoot, Docker, systemd and /dev/kvm for emulators and VMs
Reaching the sandboxPublic URLs for up to 15 ports, no built-in auth; no SSH server, raw TCP or public IPOne HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLIUp 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 rulesAllow-all, deny-all or a domain and CIDR allowlist, changeable while running; static IPs on EnterpriseOptional DNS-based domain allowlist set from outside; private IPs always blockedOpen internet, no provider-side allowlist; firewall inside the VM
Keys kept outside the sandboxCredentials brokering injects headers for any HTTPS domain you allowConnectors gateway holds the token for any HTTP API, with path allow and block listsOptional AI credentials proxy ($1 per day on, plus $1 per 1,000 requests) for model providers and any HTTPS API you add
Coding agentsClaude Code, Codex, OpenCode and pi preinstalled; you start them as commandsClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a consoleSeven agents installed, with a prompt, steer and events API to drive them from outside
Desktop, browser, computer useNo built-in desktop or computer-use API; you install Chromium and agent-browser yourself (Vercel guide) or connect an external browserNo desktop or browser built in; you install a browser, display server and stream yourself1920x1080, 60 fps desktop and Chrome, computer tools and a browser-control API, embeddable stream
Regions19 regions across the US, Europe, Asia, South America, Africa and AustraliaNo region option when you create a SpriteGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureVercel SandboxSpritesboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesYesYes
SystemdNot publishedNo documented wayYes
Desktop GUINo documented wayNo documented wayYes
BrowserWith your own setupNo documented wayYes
Computer-use APINo documented wayNo documented wayYes
SSHNo documented wayWith your own setupYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)YesNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopNo documented wayYesNo documented way
Wake on requestNo documented wayYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesYesYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsYesNot publishedYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesNo documented wayNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Vercel Sandbox12.66 runs/s
SpritesNot measured
boat28.06 runs/s

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.

ScenarioVercel Sandbox, a monthSprites, a monthboat, 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.

ScenarioVercel SandboxSpritesboat
One coding agent, workdaysNone for this scenarioNone for this scenarioNone for this scenario
One agent that never stops
  • Pro: sessions capped at 24 h
None for this scenarioNone for this scenario
50 agents in parallelNone for this scenario
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None for this scenario
Sandboxes for your usersNone for this scenario
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
None for this scenario
1,000 short jobs at onceNone for this scenario
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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