Google Agent Runtime vs Modal VM Sandboxes
Google Agent Runtime hosts your agent code on Google Cloud and gives it sandboxes that run as an unprivileged user in a locked container. Modal VM Sandboxes give each agent a real VM with its own kernel, root and Docker, but each one ends within 24 hours.
The companies and products
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. All of them run as secure containers inside your Google Cloud project.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
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. “28th cheapest of 366” means 27 of the other 365 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 | Google Agent Runtime: price rank | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Modal's VM runs Docker and sudo installs that Google's unprivileged sandboxes cannot, but it ends within 24 hours; boat has Docker too and keeps its disk with no session cap on paid plans. | 295th of 367, with limits $5,801 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent Runtime can host a long-lived assistant on Google Cloud, while a Modal VM Sandbox stops at 24 hours; a boat VM has no session cap on paid plans. | 28th cheapest of 366 $7,519 a month | Can't run it | 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 This is where Google fits best: its Code Execution sandbox is a ready Python interpreter with no network. | 254th of 345, with limits $275 a month | Can't run it | 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 Google gives your users a shell through its API but no public URL, Modal offers tunnels, and boat serves HTTPS on up to 50 ports and stops for free between visits. | 280th of 361, with limits $1,916 a month | Can't run it | 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 Huge bursts of short rollouts are what Modal is built for, with 5,000 containers at once on Team, while boat's per-plan start limits queue large bursts. | 128th of 360, with limits $8,240 a month | 171st of 360, with limits $16,322 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 | 79th cheapest of 364 $2,060 a month | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Jobs that build containers need Docker, which Modal's VM has and Google's sandboxes do not; boat also gives every plan /dev/kvm, which Modal offers only on Team and Enterprise on request. | 98th cheapest of 377 $989 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Google has no SSH and runs each command in a new shell, and a Modal VM ends within 24 hours; a boat VM gives you SSH and a desktop and keeps its disk. | 311th of 368, with limits $241 a month | Can't run it | 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 Google gives you a browser with a VNC view and CDP, Modal leaves you to install Xvfb and VNC yourself, and boat streams a full 60fps desktop with Chromium. | 283rd of 369, with limits $1,648 a month | Can't run it | 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 | 102nd of 367, with limits $824 a month | Can't run it | 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 | 53rd cheapest of 346 $515 a month | Can't run it | 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 | 210th of 338, with limits $8,240 a month | Can't run it | 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 | 260th of 360, with limits $412 a month | 294th of 360, with limits $642 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 | Google Agent Runtime | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | Secure container sandboxing inside your Google Cloud project | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker, systemd | Runs as appuser with no sudo; images must not need root; no Docker documented | Yes; start dockerd yourself as the entrypoint | Yes, in every sandbox |
| Nested virtualization | No /dev/kvm documented | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan |
| CPU benchmark (4 vCPU / 8 GB) | Not measured | 15.54 runs/s | 26.69 runs/s |
| Longest session | TTL of up to 7 days for a custom container, 14 days for Code Execution | 24 hours (default 5 minutes); continue with a filesystem snapshot | No cap on paid plans; you set the time to live |
| Files after a stop | Pause keeps the file system at a lower, unpublished rate; deleted when the TTL ends | No paused state; only Volumes and snapshots keep files | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Memory snapshots and branching | Snapshots keep memory and files; start many sandboxes from one | Filesystem snapshots boot many sandboxes; memory snapshots are alpha and end the sandbox | Fork a running sandbox with its disk; no memory snapshots |
| Shell access | execute_bash() API calls; each command runs in a new shell; no SSH | Run commands from Python, TypeScript or Go code | SSH, plus an API for commands |
| Desktop and computer use | A browser in a container with a VNC live view, a click and type API, and CDP | Not offered; an example shows how to set up Xvfb and VNC yourself | 60fps desktop, Chromium and a computer-use API built in |
| Reaching the sandbox | Through Google's API or a private endpoint in your VPC; no public URL documented | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP |
| Outbound network rules | Off unless the template turns it on; route through your VPC with Cloud NAT, Cloud NGFW or Secure Web Proxy | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Coding agents and keys | Managed Agents API (Preview) runs Google's Antigravity harness; you scope the credentials | Examples only; secrets are environment variables or your own sidecar proxy | Claude Code, Codex and others preinstalled with a prompt, steer and events API; a credentials proxy keeps real keys out |
| Hosting your agent code | Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed | Sandboxes sit next to Modal's functions, inference and training | You run your own agent loop inside a sandbox |
| Regions | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Google Agent Runtime | Modal VM Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | No | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | 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 | Yes | Yes | 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 | No | No |
| HTTPS preview URLs | No | Yes | Yes |
| Raw TCP inbound | Not published | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public hpc-sandbox-benchmarks run of 29 September 2026 at 4 vCPU / 8 GB, boat did 26.69 Node.js build-and-test runs per second and Modal's VM runtime did 15.54, so boat did about 1.7 times the CPU work in the same time. Google Agent Runtime and its sandboxes were not part of that run, so there is no comparable measurement for Google.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. Google Agent Runtime 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 | Google Agent Runtime, a month | Modal VM Sandboxes, 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 | $73 · Pay as you go | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $301 · Pay as you go | $178 · Starter · with limits | $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 | $3,626 · Pay as you go · with limits | $2,229 · Starter · 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 | $1,030 · Pay as you go | $792 · 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 | $2,060 · Pay as you go | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour for what you allocate, by the second, with the first 50 vCPU-hours and 100 GiB-hours free each month. Runtime skips idle time between turns, but sandboxes are billed while they exist, and disk, egress and paused rates are not published.
Modal VM Sandboxes: Modal bills by the second for the higher of the CPU and memory you request or use, until the sandbox ends. Starter is free with $30 of monthly credit, Team adds a monthly fee with $100 of credit, and pinning a region costs 1.15x to 1.75x.
Modal VM Sandboxes: boat plans start at $20 a month and the whole fee becomes usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Modal's 24-hour cap and lost root disk are why the workday, always-on and fleet scenarios do not fit on Modal: only files in a Volume or a snapshot survive. Google fits those one-agent rows, but its sandboxes have no Docker, so the 50-agent fleet does not fit, and every Google row leaves disk and egress unpriced. In the 1,000-job burst, Modal's small CPU request bursts onto shared cores, and boat queues the jobs because even the $2,000 plan starts 90 sandboxes a minute.
| Scenario | Google Agent Runtime | Modal VM Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted inside your own project, network rules and regions, with short code runs in a locked sandbox.
- A managed home for your agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and skips billing for idle time between turns.
- Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and routed through your own firewall.
- Memory snapshots in 23 locations. Useful if you branch sandboxes with their memory, or need to run in Canada, Australia or Brazil as well as the US, Europe and Asia.
Use Modal VM Sandboxes when
you need root and Docker in a real VM for jobs that finish within a day, run huge bursts of them, or already run your models on Modal.
- A real VM with root and Docker. Useful if agents run sudo installs or Docker builds: each Modal VM Sandbox has its own kernel, root and systemd.
- Very large bursts of short jobs. Useful for huge bursts that finish within a day: Modal runs 5,000 containers at once on Team.
- One platform with inference and training. Useful if you already serve or train models on Modal: sandboxes and models sit on one account and one bill.
Where boat fits
Look at boat if your agents work for hours or days on one machine and come back to it. Google locks them in an unprivileged container and Modal cuts them off at 24 hours, while boat gives each one a full VM that keeps its disk, with root, Docker, a desktop and coding agents built in.
A machine that keeps its work
A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container, and a Modal VM ends within 24 hours, losing files outside a Volume. boat saves the disk every minute, stops for free and has no session cap.
Root, Docker and /dev/kvm everywhere
Google's sandboxes run as appuser with no sudo, so the 50-agent Docker fleet does not fit there. Modal runs Docker, but nested virtualization needs the Team plan and a request to support. boat has root, Docker and /dev/kvm on every plan.
Desktop, agents and a faster CPU
Google gives you a browser only and Modal gives you none, so you install VNC and the agent harness yourself. boat ships a 60fps desktop, Claude Code and Codex, keeps real keys out with a proxy, and did 26.69 CPU runs per second to Modal's 15.54.
Use boat when your agents work for hours or days on a machine they come back to: root, Docker, /dev/kvm, SSH and a desktop on a faster VM that keeps its disk and never cuts them off. Compare it one to one: boat vs Google Agent Runtime and boat vs Modal VM Sandboxes.
Questions people ask
Is Google Agent Runtime cheaper than Modal VM Sandboxes?
Mostly no. One agent running all month comes to $301 a month on Google against $178 on Modal, and sandboxes for your users $1,030 a month against $792 on Modal. Google is cheaper for 1,000 short jobs at once, $2,060 against $3,193 on Modal. boat comes to $26 and $200 a month for the first two.
Which is faster, Google Agent Runtime or Modal VM Sandboxes?
Google's sandboxes have no public CPU measurement, so there is no fair comparison. Modal's VM runtime did 15.54 Node.js runs per second at 4 vCPU / 8 GB in the same run where boat did 26.69.
Can Google Agent Runtime run Docker?
No. Shell commands in a Google sandbox run as the unprivileged user appuser with no sudo, and custom images must not need root. Modal VM Sandboxes run Docker if you start dockerd yourself, and boat runs Docker, systemd and /dev/kvm on every sandbox.
How long can a sandbox run on each?
A Google custom container sandbox lives up to 7 days and a Code Execution sandbox up to 14 days, then it is deleted. A Modal VM Sandbox defaults to 5 minutes and runs 24 hours at most. boat has no session cap on paid plans.
Can either one serve a web app to the public?
Google's docs describe reaching a sandbox through its API or a private endpoint in your VPC, not a public URL. Modal offers encrypted and raw TCP tunnels. boat serves HTTPS on up to 50 ports with token protection, plus raw TCP.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs Google Agent Runtime
- boat vs Modal VM Sandboxes
- E2B vs Google Agent Runtime
- Daytona vs Google Agent Runtime
- Modal vs Google Agent Runtime
- Vercel Sandbox vs Google Agent Runtime
- Cloudflare Sandbox vs Google Agent Runtime
- Blaxel vs Google Agent Runtime
- Runloop vs Google Agent Runtime
- Tensorlake vs Google Agent Runtime
- Morph Cloud vs Google Agent Runtime
- CodeSandbox SDK vs Google Agent Runtime