Vercel Sandbox vs Google Agent Runtime

Vercel Sandbox gives each run a Firecracker microVM with its own kernel, sudo and Docker, with 24-hour sessions that resume from a snapshot. Google Agent Runtime hosts your agent code on Google Cloud and adds gVisor sandboxes that run as an unprivileged user with no documented Docker; they can live for days, and snapshots (Preview) keep their memory.

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.

Google Agent Runtime

Google Agent Runtime is the agent hosting part of Gemini Enterprise Agent Platform on Google Cloud, renamed from Vertex AI Agent Engine in April 2026.

It is a hyperscaler service, not a sandbox company. Agent Runtime deploys agents you build with ADK, LangGraph, LangChain, AG2 or LlamaIndex and bills them only while they work on a turn. Next to it, Agent Sandbox gives those agents a place to run code: a Code Execution sandbox, a shell or custom container sandbox, and a Computer Use browser. Each sandbox runs in a gVisor-isolated container in a Google-managed tenant project. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster, with gVisor or Kata Containers, and manage it themselves.

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 rankGoogle Agent Runtime: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Both are a compromise for a software factory. Neither has a built-in desktop, and Google's sandboxes have no root or documented Docker. boat has all of them on every VM.
259th of 365, with limits
$3,351 a month
310th of 365, with limits
$5,801 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Google fits always-on assistants: a sandbox lives up to 7 days, a snapshot carries its state forward, and Agent Runtime skips billing between turns. Vercel resumes across 24-hour sessions, but processes start again, so it is a compromise.
75th of 361, with limits
$3,657 a month
34th cheapest of 361
$7,519 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
Vercel Sandbox fits short code bursts and bills CPU only while code uses it. Google's Code Execution sandbox is a ready Python and JavaScript interpreter with no network; in this preset it is a compromise.
27th cheapest of 336
$216 a month
251st of 336, with limits
$275 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 fits sandboxes for your users, with public URLs for up to 15 ports. A Google sandbox is reached through Google's API or a private endpoint in your VPC, with no public URL documented. boat fits at $209 a month here, with HTTPS on up to 50 ports.
25th cheapest of 349
$1,267 a month
275th of 349, with limits
$1,916 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
Vercel Sandbox fits many short parallel rollouts, with fast starts and high concurrency. Google is a compromise here.
7th cheapest of 349
$15,761 a month
132nd of 349, with limits
$8,240 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
90th cheapest of 359
$2,060 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 in this preset. For jobs that build containers, Vercel runs Docker with sudo; Google documents no Docker inside its sandboxes, so you build images elsewhere. boat fits at $86 a month here.
112th cheapest of 374
$1,144 a month
104th cheapest of 374
$989 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
283rd of 371, with limits
$145 a month
317th of 371, with limits
$241 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
Google offers a browser with a click, type and screenshot API but no documented full desktop. Vercel has no built-in screen; you install one with root. boat streams a 60 fps desktop with computer tools.
263rd of 367, with limits
$952 a month
85th of 367, with limits
$1,648 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
Google gives agents a real Chromium with a VNC live view and CDP. On Vercel you install Chromium and agent-browser yourself (Vercel has a guide) or connect a cloud browser. boat ships Chrome with browser control.
100th of 356, with limits
$486 a month
132nd of 356, with limits
$824 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
56th cheapest of 343
$515 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
212th of 327, with limits
$8,240 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
281st of 351, with limits
$412 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 SandboxGoogle Agent Runtimeboat
IsolationFirecracker microVM with its own kernelgVisor-isolated container in a Google-managed tenant projectFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Root and DockerDocker inside, with sudoRuns as appuser with no sudo; images must not need root; no Docker documentedRoot, systemd and Docker on every sandbox
Nested virtualizationNo; Firecracker does not expose /dev/kvm to guestsNo /dev/kvm documentedYes, /dev/kvm (Android emulator, VMs)
How long a sandbox lives24 hours per session on Pro and Enterprise, 45 minutes on Hobby; a persistent sandbox then resumes from its snapshot, with no cap on total lifetimeTTL of up to 7 days for a custom container and 14 days for Code Execution; a snapshot (Preview) carries the state into a new sandboxNo session cap once you turn auto-stop off on a paid plan; auto-stop defaults to 1 hour and goes up to 30 days
Saving stateFilesystem snapshot at every stop, on by default, $0.08/GB-month; expires 30 days after last use, or never if you set it. Plus Drives: mounted storage kept until you delete itSnapshots (Preview) keep memory and files; pause keeps files at a lower rate that is not publishedDisk saved every minute and at each stop, at no charge; a stopped disk is kept at least 14 days; saved snapshots never expire; memory is not saved
Desktop, browser, computer useNo built-in desktop, browser or computer-use API; you install Chromium and agent-browser yourself (root access, Vercel guide) or connect an external cloud browserA browser in a container with a VNC live view, a click, type and screenshot API, and CDP; a full desktop is not documentedBuilt in: 1920x1080, 60 fps desktop and Chrome, computer tools and a browser-control API, embeddable stream
Shell accessSDK and CLI commands; no SSH serverexecute_bash() API calls, each in a new shell; SSH not documentedSSH, plus an API for commands
Inbound accessPublic URLs for up to 15 ports, no built-in auth; no raw TCP or public IPThrough Google's API or a private endpoint in your VPC; no public URL documentedUp 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 internetAllow-all, deny-all or a domain and CIDR allowlist, changeable while running, on every planOff unless the template turns it on; can route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web ProxyNo provider-side allowlist; firewall inside the VM
Custom imagesYour own OCI images from a Dockerfile, via Vercel Container RegistryCustom containers and templates (Preview), built to run without rootStart from boat's image or a saved snapshot (template), shareable by code; you cannot boot your own Docker or OCI image
Coding agentsClaude Code, Codex, OpenCode and pi preinstalled; you start them as commandsManaged Agents API (Preview) runs Google's Antigravity harness; other harnesses you install in a custom imageSeven harnesses installed, with an API to prompt, steer and stream events
Keys kept outside the sandboxCredentials brokering injects headers for any HTTPS domain you allowYou provision and scope the credentials the agent usesOptional AI credentials proxy ($1 per day while on, plus $1 per 1,000 requests) for model providers and any HTTPS API you add
Hosting your agent codeYou run your agent loop in the sandbox or elsewhere on VercelAgent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billedYou run your own agent loop inside a sandbox
Regions19 regions, default iad1 (US East), with failover regions23 locations in the US, Europe, the Middle East, Asia, Canada, Australia and BrazilGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureVercel SandboxGoogle Agent Runtimeboat
Full VM (own kernel)YesNo documented wayYes
Docker insideYesNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesNo documented wayYes
SystemdNot publishedNot publishedYes
Desktop GUINo documented wayNot publishedYes
BrowserWith your own setupYesYes
Computer-use APINo documented wayYesYes
SSHNo documented wayNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneYesYesYes
Live fork (no pause)YesYesYes
Memory forkNo documented wayYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopNo documented wayNo documented wayNo documented way
Wake on requestNo documented wayNo documented wayNo documented way
HTTPS preview URLsYesNo documented wayYes
Raw TCP inboundNo documented wayNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesNo documented wayYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayYesYes
MCP serverYesNo documented wayNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayYesNo 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 wayYesYes
Audit logsNot publishedNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Vercel Sandbox12.66 runs/s
Google Agent RuntimeNot 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 some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions. Google Agent Runtime and its sandboxes are not in the public benchmarks we use, so we cannot say how they compare.

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. Google Agent Runtime 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 monthGoogle Agent Runtime, 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$73 · 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$301 · 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$3,626 · Pay as you go · with limits$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,030 · Pay as you go$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$2,060 · Pay as you go$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.

Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second. The pricing page lists 50 vCPU-hours and 100 GiB-hours free each month but does not say they cover sandboxes. Runtime skips idle time between turns, but sandboxes are billed while they exist. Pause, disk, snapshot and egress rates are not published.

Google Agent Runtime: 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 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 processes start again, so it does not fit. Google fits until the sandbox TTL runs out, then a snapshot (Preview) restores it into a new sandbox. For 50 agents in parallel with Docker inside, Google does not fit because it documents no Docker in its sandboxes; Vercel fits. Every Google row leaves disk and egress unpriced because those rates are not published. For 1,000 short jobs at once both Vercel and Google fit. boat does not: even the $2,000 plan includes 90 starts a minute and 2,400 a day, starts above that are paid, and starts above 270 a minute fail with 429. Other boat limits: a stopped disk is kept at least 14 days unless you save a snapshot, no GPU, and no US or Asia region.

ScenarioVercel SandboxGoogle Agent Runtimeboat
One coding agent, workdaysNone for this scenario
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
One agent that never stops
  • Pro: sessions capped at 24 h
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
50 agents in parallelNone for this scenario
  • missing Docker inside
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
Sandboxes for your usersNone for this scenario
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
1,000 short jobs at onceNone for this scenario
  • disk beyond 0 GiB: price unknown
  • egress price not published
  • 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 that need sudo or Docker, want public preview URLs, or already build images from a Dockerfile.

  • Sudo and Docker inside. Useful if agents install packages or build containers: each Vercel sandbox is a microVM with sudo and Docker.
  • Public preview URLs. Useful if people outside need to open what the code serves: Vercel gives public URLs for up to 15 ports.
  • Images from your Dockerfile. Useful if you already have a Dockerfile: build it into an OCI image and boot sandboxes straight into it.

Use Google Agent Runtime when

you build agents with ADK or LangGraph on Google Cloud and want them hosted inside your own project, with sandboxes that can live for days and a browser for computer use.

  • A managed home for agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and skips billing for idle time between turns.
  • Sandboxes that last for days. Useful if a task runs longer than a day: a Google sandbox can live up to 7 days, and snapshots (Preview) keep its memory.
  • A browser for computer use. Useful if your agent works in web pages: Google's Computer Use sandbox gives a browser with a live view and CDP.

Where boat fits

Look at boat if your agents work for hours on one machine and need a full computer. Vercel resumes across 24-hour sessions and has no built-in screen, and Google's sandboxes run without root or documented Docker. boat gives every agent a full VM with root, Docker, SSH, a built-in desktop and public URLs. boat runs only in Europe and caps starts per plan.

No session cap, disk saved every minute

On Vercel a session stops at 24 hours and running processes start again. On Google a sandbox is deleted when its TTL ends, 7 days at most, and a snapshot carries it into a new one. On boat, turn auto-stop off (default 1 hour) on a paid plan. Memory is not saved, and a machine failure loses writes after the last good snapshot.

Root, Docker and /dev/kvm together

Google's sandboxes run as appuser with no sudo, so docker compose and apt installs do not run there. Vercel has Docker but no nested virtualization, so Android emulators and VMs do not run. boat has root, Docker, systemd and /dev/kvm on every VM.

A desktop, and agents you drive from outside

Vercel has no built-in screen, and Google offers a browser with no documented full desktop. boat streams a 60 fps desktop and gives you one API to prompt and steer Claude Code, Codex and other agents inside.

Use boat when your agents need a full computer for hours: root, Docker, /dev/kvm, SSH, a built-in desktop and public URLs, with the disk saved every minute and coding agents you drive from outside. Check the start limits of your plan first. Compare it one to one: boat vs Vercel Sandbox and boat vs Google Agent Runtime.

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 Google Agent Runtime?

In four of our five scenarios, yes. One workday agent comes to $57 a month on Vercel and $73 on Google, and sandboxes for your users come to $828 and $1,030. For 1,000 short jobs at once Google is cheaper at $2,060 against $3,152. boat comes to $20 for the workday agent and $200 for the user sandboxes; it does not fit the 1,000-job burst.

Which is faster?

Vercel Sandbox did 12.66 V8 Web Tooling runs per second at 4 vCPU / 8 GB, and boat did 28.06 on a Ryzen 9 9950X host, in StarSling's run of 3 October 2026. Google's sandboxes are not in that run, so we cannot compare speed with Google.

Can Vercel Sandbox or Google Agent Runtime run Docker?

Vercel Sandbox can: each microVM runs Docker with sudo. Google's managed sandboxes run as the unprivileged user appuser with no sudo, and Google documents no Docker inside; you build images outside and push them to Artifact Registry. boat runs Docker with root and systemd on every VM.

How long can a sandbox run on each?

A Vercel session lasts up to 24 hours on Pro and Enterprise, then resumes from its filesystem snapshot with processes started again. A Google sandbox lives until its TTL ends, up to 7 days for a custom container and 14 days for Code Execution. boat has no session cap once auto-stop is off on a paid plan (default 1 hour).

Is Google Agent Runtime the same as Vertex AI Agent Engine?

Yes. Google renamed Vertex AI Agent Engine to Agent Runtime in April 2026, as part of Gemini Enterprise Agent Platform. Its code, shell and browser sandboxes are a separate part of the same platform called Agent Sandbox.

Where do they run?

Vercel Sandbox runs in 19 regions, with iad1 in the US as the default. Google runs in 23 locations across the US, Europe, the Middle East, Asia, Canada, Australia and Brazil. boat runs on machines in Germany, Finland and France, and you cannot pick a region. boat's snapshot copies can be stored outside the EU.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons