Vercel Sandbox vs Beam
Vercel Sandbox gives every sandbox a Firecracker microVM with its own kernel, in 19 regions, but stops each session after 24 hours. Beam gives you gVisor container sandboxes in the US that can run until you stop them, with GPUs and an open-source runtime you can host yourself.
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.
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, systemd, /dev/kvm and a disk that lasts; Vercel Sandbox has no nested virtualization and Beam sandboxes have no systemd, so both are compromises. | 244th of 367, with limits $3,351 a month | 69th of 367, with limits $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month is cut off every 24 hours on Vercel Sandbox; boat ranks 5th, with no session cap and a disk saved every minute. | 257th of 366, with limits $3,657 a month | 115th of 366, with limits $651 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 Both fit short code bursts; Beam ranks 8th and Vercel Sandbox ranks 22nd, while boat's start limits make it a compromise here. | 22nd cheapest of 345 $216 a month | 8th cheapest of 345 $117 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 All three fit sandboxes for your users; boat ranks 1st, Beam ranks 3rd and Vercel Sandbox ranks 15th on cost for the same work. | 15th cheapest of 361 $1,267 a month | 3rd cheapest of 361 $290 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 for many short parallel rollouts thanks to high concurrency, while Beam ranks 341st and only fits with compromises. | 3rd cheapest of 360 $15,761 a month | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 | 12th cheapest of 377 $171 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 fits Beam and boat; on Vercel Sandbox it restarts every 24 hours and loses its running processes. | 276th of 368, with limits $145 a month | 13th cheapest of 368 $21 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 Beam has a desktop or browser, so you would build one yourself; boat streams a 60fps desktop with computer use. | 235th of 369, with limits $952 a month | 111th of 369, with limits $237 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 | 259th of 367, with limits $486 a month | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Only Beam fits GPU eval jobs: it offers GPUs from T4 up to H100 and B200, and neither Vercel Sandbox nor boat has GPUs. | Can't run it | Cheapest of 98 $458 a month | 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 | Beam | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel for every sandbox | gVisor container by default; separate Beam VMs are CPU microVMs with their 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 published cap; default 10 minutes, or set -1 to run until you terminate it | No cap on paid plans; you set the time to live |
| Files between runs | Filesystem snapshot on stop, billed per GB a month, kept 30 days after last use by default | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk | Disk saved every minute and on stop; a stopped sandbox keeps it for free |
| Snapshots of a running sandbox | Filesystem snapshots only; memory is not kept | Memory snapshot with running processes, restored into new sandboxes | Fork a running sandbox with its disk |
| GPUs | No | GPU sandboxes and serverless GPUs, from T4 and RTX 4090 up to H100, H200 and B200 | No, CPU only |
| Nested virtualization | No | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Docker and systemd | Docker with sudo | Docker with docker_enabled; systemd only in Beam VMs, not in sandboxes | Docker, systemd and root, like a normal Ubuntu server |
| Desktop, browser, computer use | None; headless Linux only | No desktop or browser product | 60fps desktop with Chromium, computer-use and browser-control APIs |
| Coding agents | Claude Code, Codex, OpenCode and pi preinstalled; you start them as commands | None preinstalled; you install and run them yourself | Seven agents preinstalled, 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 | A public HTTPS URL per exposed port, no built-in auth; no raw TCP or dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Allow-all, deny-all or a domain and CIDR allowlist, changeable while running; static IPs and VPC peering on Enterprise | Block all outbound traffic or allow up to 10 CIDR ranges, changeable while running | Open internet, no provider-side allowlist; firewall inside the VM |
| Keeping API keys out of the sandbox | Credentials brokering adds headers for any HTTPS domain you allow | Secrets are environment variables inside the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | 19 regions across the US, Europe, Asia, South America, Africa and Australia | US only; no other region is listed | EU only: Germany, Finland, France |
| Self-hosting | No | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No |
Every feature Battleships tracks (43)
| Feature | Vercel Sandbox | Beam | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | 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 | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | No | No |
| Wake on request | No | No | 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 | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | 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 | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the StarSling hpc-sandbox-benchmarks Node.js test at 4 vCPU / 8 GB, boat did 26.69 runs per second and Vercel Sandbox did 12.96, so boat finished about twice as many runs. Beam has no result on that test, so we cannot say how fast its CPUs are next to the other two. Beam's own guide says its sandboxes cold-boot in 1 to 3 seconds.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Beam 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 | Beam, 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 | $5 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $236 · Pro · with limits | $22 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $2,000 · $2000/mo · with limits |
Vercel Sandbox: Vercel charges for CPU only while your code uses it, but for memory for 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.
Beam: Beam bills sandboxes per second for each CPU core (two vCPU) and each GiB of RAM you request, until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team is $89 a month plus usage, with no usage credit, and egress is free.
Beam: boat charges a flat price per size, per second, only while the machine runs, and 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 Sandbox ends each session at 24 hours; it resumes from its snapshot, but running processes start over. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents, user sandboxes and big bursts need its Team plan, and Beam publishes no disk price, so the scenarios count no disk cost for it. For 1,000 short jobs at once, both Vercel Sandbox and Beam fit, while boat's $2,000 plan queues the starts.
| Scenario | Vercel Sandbox | Beam | 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 a microVM with its own kernel for each one, need to run close to users outside the US and Europe, or want network rules by domain.
- A microVM for every sandbox. For running untrusted code, every Vercel sandbox gets a Firecracker microVM with its own kernel, not a shared-kernel container.
- Regions all over the world. Useful if your users are spread out: Vercel Sandbox runs in 19 regions, from Virginia to Tokyo and Sydney, while Beam lists only the US.
- Network rules by domain. A running sandbox can be limited to a list of allowed domains, and brokered credentials keep keys outside it.
Use Beam when
your sandboxes need GPUs, when you want sandboxes that run until you stop them at a low per-second rate in the US, or when you must self-host the runtime.
- GPUs in the same platform. For work that needs a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100, H200 and B200.
- No session cap and memory snapshots. A sandbox can run until you terminate it, and a memory snapshot can restore its running processes into new sandboxes.
- Open source and your own cloud. Its Beta9 runtime is AGPL-3.0 and free to self-host, or Beam can run in your own cloud for a management fee.
Where boat fits
Both are built around short runs of code you start from an SDK. If your agents work for hours on one machine, installing tools, running Docker and emulators, and checking what they built in a browser, look at boat. Each boat sandbox is a full VM with a desktop, its agents and a disk that is saved every minute.
A full VM with /dev/kvm and systemd
Vercel's Firecracker microVMs have no nested virtualization, and Beam sandboxes are gVisor containers without systemd. An agent that needs an Android emulator, a nested VM or a systemd service gets stuck on both.
Agents that work all day and keep their disk
Vercel stops each session at 24 hours and running processes start over. A Beam sandbox ends with its time to live, 10 minutes by default, unless you save an image or volume, and an idle tail is billed.
A desktop and agents you drive from outside
Neither has a desktop or browser, so an agent cannot open the app it built. On Vercel you start agents as plain commands, and Beam has none preinstalled, so you build the harness to prompt and steer them yourself.
Use boat when your agents work for hours on one machine: builds, Docker, emulators and a desktop with a browser on a full VM, with an API to drive the agents inside from outside. Compare it one to one: boat vs Vercel Sandbox and boat vs Beam.
Questions people ask
Is Vercel Sandbox cheaper than Beam?
No. Beam costs less in all five of our scenarios: one workday agent is $57 on Vercel against $5 on Beam, 50 parallel agents are $2,884 against $410, and sandboxes for your users are $828 against $191. Beam publishes no disk price, so those totals count no disk cost for it.
Which is faster, Vercel Sandbox or Beam?
We cannot say for CPU work: Vercel Sandbox did 12.96 runs per second on the StarSling Node.js test, and Beam has no result on it. boat did 26.69 on the same test. Beam says its sandboxes cold-boot in 1 to 3 seconds.
Can Vercel Sandbox and Beam run Docker?
Yes. Vercel Sandbox runs Docker with sudo, and Beam runs it inside a sandbox with docker_enabled. Neither offers /dev/kvm for emulators or nested VMs; boat has Docker, systemd and /dev/kvm.
Can they run 24/7?
Vercel Sandbox cannot as one session: Pro and Enterprise sessions stop after 24 hours, and the resumed sandbox starts its processes over. A Beam sandbox can run until you terminate it if you set its time to live to -1. boat machines have no session cap on paid plans.
Is a Beam sandbox a VM like Vercel Sandbox?
Not by default. Beam sandboxes are containers using gVisor, while every Vercel sandbox is a Firecracker microVM with its own kernel. Beam also sells separate CPU VMs with their own kernel and systemd.
Which one has GPUs?
Only Beam. It offers GPU sandboxes and serverless GPUs, from T4 up to H100, H200 and B200. Vercel Sandbox and boat are CPU only.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Vercel Sandbox
- boat vs Beam
- 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