Vercel Sandbox vs Runloop
Vercel Sandbox is built for short runs of untrusted code in 19 regions, with each session capped at 24 hours. Runloop is built for coding agents on devboxes that can run as long as an idle policy allows, with a desktop, a browser and arm64.
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.
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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 | Runloop: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Runloop fits a software factory fully with a desktop and browser to check the UI; Vercel Sandbox is headless and stops each session at 24 hours, and boat adds /dev/kvm on top. | 244th of 367, with limits $3,351 a month | 20th cheapest of 367 $8,152 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Runloop devboxes can run with an idle policy in place of a fixed lifetime; Vercel's docs say sandboxes are not designed to run continuously. | 257th of 366, with limits $3,657 a month | 32nd cheapest of 366 $10,194 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 ranks 22nd here against Runloop's 44th, because it bills CPU only while code uses it. | 22nd cheapest of 345 $216 a month | 44th cheapest of 345 $525 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 Both fit sandboxes for your own users; boat ranks 1st, Vercel Sandbox ranks 15th and Runloop ranks 26th on cost for the same work. | 15th cheapest of 361 $1,267 a month | 26th cheapest of 361 $3,301 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 Vercel Sandbox ranks 3rd and Runloop ranks 4th for RL rollouts, both starting large waves of short runs; boat's start limits make it a compromise. | 3rd cheapest of 360 $15,761 a month | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 | 107th cheapest of 377 $1,144 a month | 121st cheapest of 377 $1,554 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays up all day fits Runloop and boat; on Vercel it restarts every 24 hours and loses its running processes. | 276th of 368, with limits $145 a month | 113th cheapest of 368 $410 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 Runloop ships a desktop and a browser an agent can control; Vercel Sandbox has none, so you would have to build one yourself. | 235th of 369, with limits $952 a month | 39th cheapest of 369 $2,306 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 Runloop includes browser control; Vercel Sandbox has no browser feature, and boat ships Chromium with a browser-control API. | 259th of 367, with limits $486 a month | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 | 10th cheapest of 360 $770 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 | Runloop | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Micro-VM on a custom bare-metal hypervisor, plus a container layer | 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 | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it with no documented cap | No cap on paid plans (--no-auto-stop); default TTL 1 hour, changeable |
| Keeping files | Filesystem snapshot on every stop, billed per GB a month, kept 30 days after last use by default | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox | Snapshot every minute and on stop, on every plan; a stopped sandbox costs nothing |
| Desktop, browser, computer use | None; headless Linux only | Desktop and browser with desktop-control and browser-control | 60fps desktop and Chromium, computer-use and browser-control APIs, embeddable stream |
| Nested virtualization | No | Not documented; Docker-in-Docker blueprints only | Yes, /dev/kvm (Android emulator, VMs) |
| Docker inside | Yes, with sudo | Yes, on the dnd blueprints, as root | Yes, with root and systemd |
| Images | Your own OCI images from a Dockerfile, via Vercel Container Registry | Blueprints built from Dockerfiles, plus disk snapshots | Templates from named snapshots, no Dockerfile builds |
| CPU architecture | x86_64 | x86_64 and arm64 | x86_64 only |
| Coding agents | Claude Code, Codex, OpenCode and pi preinstalled; you start them as commands | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe, with an API to prompt, steer and stream events |
| Inbound access | Public URLs for up to 15 ports, no built-in auth; no raw TCP or public IP | One HTTPS tunnel per devbox covering its ports, open or bearer token; SSH through a TLS proxy; no public IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Egress rules | Allow-all, deny-all or a domain and CIDR allowlist, changeable while running; static IPs on Enterprise | Hostname allowlist with wildcards, or block all | 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 | Agent gateways for any API endpoint with bearer, header or basic auth | Credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when one runs out |
| Idle sleep and wake | No idle auto-stop; sessions run until their timeout or stop() | Suspend after idle, wake on an HTTP request to the tunnel (Pro) | No idle timer; TTL based, and a stopped sandbox costs nothing |
| Where it runs | 19 regions across the US, Europe, Asia, South America, Africa and Australia | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Vercel Sandbox | Runloop | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | 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 | 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 | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | 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 | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
All three were measured on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29). boat scored 26.69 runs a second, Vercel Sandbox 12.96 and Runloop 8.29, so Vercel was about 1.6 times Runloop's speed and boat about twice Vercel's. The test measures CPU work only, not start time or network speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite.
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 | Runloop, 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 | $113 · Basic | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $236 · Pro · with limits | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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 | $3,184 · Basic | $2,000 · $2000/mo · with limits |
Vercel Sandbox: Vercel charges for CPU only while your code uses it, but charges 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.
Runloop: Runloop bills per second for the CPU and memory you allocate while a devbox is starting, running, suspending or resuming, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
Runloop: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
For one agent that never stops, Vercel does not fit: each session ends at 24 hours, and the resumed sandbox starts every process over. Runloop fits it with an idle policy, which replaces its 48-hour fixed lifetime. Runloop publishes no egress price and no concurrency cap for paid plans. Both fit 1,000 short jobs at once, where boat's start limits queue the burst.
| Scenario | Vercel Sandbox | Runloop | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| None that bite |
| One agent that never stops |
|
| 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 CPU billed only while it works, 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, from Virginia to Tokyo and Sydney.
- Pay for CPU only while it works. Useful for short code bursts: Vercel bills CPU only while your code uses it, so idle waits cost less CPU.
- A firewall you change while running. A running sandbox can switch to deny-all, or a list of allowed domains and CIDRs, without a restart.
Use Runloop when
your coding agents need long-lived devboxes with a desktop and browser, hostname allowlists, arm64, or a deploy into your own AWS, GCP or Azure account.
- A desktop and a browser for agents. Useful for computer-use and browser agents: Runloop devboxes include a desktop and a browser the agent can control.
- Long runs that sleep when idle. An idle policy replaces the fixed lifetime, and on Pro a devbox can suspend and wake on an HTTP request.
- Your own cloud and arm64. On Enterprise, Runloop deploys into your AWS, GCP or Azure account, and it offers arm64 blueprints.
Where boat fits
Look at boat if your agents do real work for hours on one machine: installs, builds, tests, Docker and emulators. boat gives each one a full VM with /dev/kvm, a disk saved every minute on every plan, a 60fps desktop, and CPUs that ran about twice as fast as Vercel Sandbox and about three times as fast as Runloop on the same benchmark.
Faster CPUs for builds and tests
On the same Node.js benchmark boat ran 26.69 runs a second, Vercel Sandbox 12.96 and Runloop 8.29. An agent waits on installs and tests, so each wait takes about two times longer on Vercel and three times longer on Runloop.
Work that is never cut off or lost
Vercel stops each session at 24 hours and restarts every process. On Runloop a devbox is gone once it shuts down, so keeping its disk means Pro suspend or snapshot code you write. boat saves the disk every minute on every plan.
A full machine with ways in
Neither offers /dev/kvm, so an Android emulator or a VM will not start. Vercel has no desktop, and both reach sandboxes only through HTTPS. boat adds a 60fps desktop, raw TCP and a dedicated IP.
Use boat when your agents work for hours on one machine: builds, tests, Docker, emulators and a desktop with a browser, on faster CPUs, with files saved every minute on every plan. Compare it one to one: boat vs Vercel Sandbox and boat vs Runloop.
Questions people ask
Is Vercel Sandbox cheaper than Runloop?
In all five of our scenarios, yes. One coding agent on workdays costs $57 a month on Vercel and $113 on Runloop, and 50 agents in parallel cost $2,884 versus $5,268. For one agent that never stops, Vercel is $236 against $429 but still restarts every 24 hours; boat is $20, $317 and $26 for those three.
Which is faster, Vercel Sandbox or Runloop?
On CPU, Vercel Sandbox. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, Vercel ran 12.96 runs a second and Runloop 8.29. boat ran 26.69.
Can Vercel Sandbox or Runloop run 24/7?
Runloop can, with an idle policy in place of its 48-hour fixed lifetime. Vercel Sandbox sessions stop at 24 hours, and its docs say sandboxes are not designed to run continuously. boat has no session cap on paid plans.
Do they have a desktop or browser for computer use?
Runloop does: its devboxes include a desktop and a browser an agent can control. Vercel Sandbox is headless Linux only. boat streams a 60fps desktop with Chromium and computer-use and browser-control APIs.
Can Vercel Sandbox and Runloop run Docker or Android emulators?
Both run Docker inside: Vercel with sudo, Runloop on its Docker-in-Docker blueprints. Neither offers nested virtualization, so Android emulators and VMs do not run. boat exposes /dev/kvm for both.
Where do they run?
Vercel Sandbox runs in 19 regions, with iad1 in the US as the default. Runloop does not document its regions, but on Enterprise it deploys into your own AWS, GCP or Azure account. boat runs only in the EU.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Vercel Sandbox
- boat vs Runloop
- E2B vs Vercel Sandbox
- Daytona vs Vercel Sandbox
- Modal vs Vercel Sandbox
- Vercel Sandbox vs Cloudflare Sandbox
- Vercel Sandbox vs Blaxel
- Vercel Sandbox vs Tensorlake
- Vercel Sandbox vs Morph Cloud
- Vercel Sandbox vs CodeSandbox SDK
- Vercel Sandbox vs Northflank
- Vercel Sandbox vs Fly.io Machines