Modal vs Google Agent Runtime
Modal is a serverless AI cloud whose sandboxes start fast, scale to huge bursts and sit next to GPUs, but end within 24 hours. Google Agent Runtime hosts your agent code inside Google Cloud and gives it unprivileged sandboxes that can pause and live up to 7 days.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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.
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. “19th cheapest of 345” means 18 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 | Modal: price rank | Google Agent Runtime: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Software factories need Docker and root: Modal has Docker only on its VM runtime, Google's sandboxes run without root or Docker, and every bochka sandbox has both. | Can't run it | 295th of 367, with limits $5,801 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on agent hits Modal's 24-hour sandbox limit, Google's sandboxes last up to 7 days and can pause, and a bochka sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 28th cheapest of 366 $7,519 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 For many short code runs, Modal's fast starts and large fleets fit well, while Google's ready Code Execution sandbox is a simpler Python interpreter with no network. | 19th cheapest of 345 $181 a month | 254th of 345, with limits $275 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 For sandboxes your users open, Modal can expose ports through tunnels while Google documents no public URL; bochka serves HTTPS on up to 50 ports per sandbox. | 11th cheapest of 361 $811 a month | 280th of 361, with limits $1,916 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 RL rollouts launch many short sandboxes at once, which is what Modal is built for, with up to 5,000 containers on its Team plan. | 5th cheapest of 360 $19,038 a month | 128th of 360, with limits $8,240 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 | 59th cheapest of 364 $1,244 a month | 79th cheapest of 364 $2,060 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 CI jobs that build container images need Docker, which Google's sandboxes lack and Modal offers only on its VM runtime; bochka runs Docker on every VM. | 126th cheapest of 377 $1,793 a month | 98th cheapest of 377 $989 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 138th of 368, with limits $23 a month | 311th of 368, with limits $241 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 Google ships a browser with a VNC view and a click and type API, Modal leaves the desktop to you, and bochka streams a full 60fps desktop with Chromium. | 98th of 369, with limits $183 a month | 283rd of 369, with limits $1,648 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 | 177th of 367, with limits $136 a month | 102nd of 367, with limits $824 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 | 267th of 346, with limits $394 a month | 53rd cheapest of 346 $515 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 | 223rd of 338, with limits $8,795 a month | 210th of 338, with limits $8,240 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 | Can't run it | 260th of 360, with limits $412 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 Modal rents GPUs from T4 to B300 and neither Google's sandboxes nor bochka have any, so Modal is the pick for GPU jobs. | 19th cheapest of 98 $1,187 a month | 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 | Modal | Google Agent Runtime | bochka |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel is available | Secure container sandboxing inside your Google Cloud project | Every sandbox is a full VM with its own kernel |
| Root and Docker | Root; Docker only with the VM runtime | Runs as appuser with no sudo; no Docker documented | Root, systemd, Docker and /dev/kvm on every machine |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | A browser with a VNC live view, a click, type and screenshot API, and CDP | 60fps desktop, Chromium and a computer-use API built in |
| Stop and resume | No paused state; only Volumes keep files after a sandbox ends | Pause keeps the file system and costs less, at a rate not published | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Longest session | 24 hours (default 5 minutes) | TTL up to 7 days for a custom container, 14 days for Code Execution | No session cap on paid plans |
| Memory snapshots and branching | Memory snapshots in alpha; snapshotting ends the sandbox, snapshots expire after 7 days | Snapshots keep memory and files; start many sandboxes from one | Fork a running sandbox without stopping it; no memory snapshots |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None in the sandboxes | None |
| Custom images | Build images in code or pull any linux/amd64 registry image | Custom containers in Preview; images must not need root | Named snapshots used as templates; no Dockerfile builds |
| Reaching the sandbox | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | Through Google's API or a private endpoint in your VPC; no public URL documented | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP and SSH |
| Outbound network rules | Block all, IP-range allowlist, domain allowlist (beta) | Off unless the template turns it on; route through your VPC with Cloud NAT or Cloud NGFW | Open internet on every plan; no provider-side allowlist |
| Hosting your agent code | You run your agent loop in your own Modal functions or sandboxes | Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed | You run your own agent loop inside a sandbox |
| Coding agents and keys | Examples only; secrets are environment variables or your own sidecar proxy | Managed Agents API (Preview) runs Google's Antigravity harness; you provision the credentials | Claude Code, Codex and others preinstalled with a prompt API; a credentials proxy keeps real keys out |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
| CPU speed (4 vCPU / 8 GB) | 12.79 runs/s (default gVisor sandbox) | Not measured | 26.69 runs/s |
Every feature Battleships tracks (43)
| Feature | Modal | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | Not published | 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 | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | 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) | Not published | Yes | Yes |
| Audit logs | Yes | Not published | 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 Node.js build-and-test run of 29 September 2026 at 4 vCPU / 8 GB, Modal's default gVisor sandbox finished 12.79 runs per second and bochka finished 26.69, about twice as much work. Google Agent Runtime and its sandboxes were not part of that run, so there is no comparable score 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 measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Google Agent Runtime, a month | bochka, 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 | $15 · Starter · with limits | $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 | $178 · Starter · 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,229 · Starter · with limits | $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 | $792 · Team | $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,193 · Team · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of what you request or use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit and Team is $250 a month with $100 of credit; pinning a region costs 1.15x to 1.75x.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, 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.
Google Agent Runtime: bochka plans start at $20 a month and the whole fee becomes usage credit, spent per second only while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Modal's sandboxes last at most 24 hours and reset everything outside a Volume, so the workday and always-on scenarios do not fit, and its 1,000-job burst runs on shared vCPUs. Google's sandboxes fit those rows but leave disk and egress unpriced, and are deleted when their TTL ends. Neither runs the 50-agent fleet, because neither has Docker in the default sandbox. On bochka the limit that bites is the burst: starts are capped at 90 a minute and 2,400 a day on the $2,000 plan, so 1,000 jobs at once get queued.
| Scenario | Modal | Google Agent Runtime | bochka |
|---|---|---|---|
| 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 Modal when
your sandboxes need GPUs, must start in huge bursts of short jobs, or should run images you build in code, anywhere in the US, EU or Asia-Pacific.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Huge bursts of short jobs. Useful for RL rollouts and code runs at scale: Modal starts sandboxes fast and runs up to 5,000 containers on Team.
- Any image, built in code. Useful if your tools ship as images: Modal builds images in code or pulls any linux/amd64 registry image.
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted inside your own project and network, with locked sandboxes that can pause.
- A managed home for agent code. Useful if you build with ADK or LangGraph: Agent Runtime hosts your agents and skips billing for idle time between turns.
- Sandboxes that pause and branch. Useful for agents that come back later: sandboxes pause with their files, and memory snapshots can start many copies.
- Inside your Google Cloud network. Useful if agents must stay in your project: egress is off by default and can run through your own VPC firewall.
Where bochka fits
If what you are really running is coding agents that work for hours or days, neither Modal nor Google gives each one a full computer by default. bochka gives every agent a full VM with root, Docker, a desktop and public URLs, keeps its disk when it stops, and has Claude Code and Codex built in.
Root, Docker and a real kernel in every sandbox
Google's sandboxes run as appuser with no sudo or Docker, and Modal's default gVisor sandbox has no Docker. On Modal you switch to the VM runtime; on Google, anything needing Docker runs somewhere else. bochka has root, Docker, systemd and /dev/kvm on every VM.
A disk that stays, with no session cap
A Modal sandbox ends within 24 hours and loses everything outside a Volume. A Google sandbox is deleted when its TTL ends, 7 days at most. A bochka sandbox saves its disk every minute, stops for free and has no session cap on paid plans.
A desktop, public URLs and agents ready to go
Modal leaves the desktop and agent harness to you, and Google offers only a browser and no public URL. bochka ships a 60fps desktop, HTTPS on 50 ports, Claude Code and Codex you drive from outside, and a proxy that keeps real API keys out.
Use bochka when your agents need a real computer for hours or days: root, Docker, a desktop and public URLs on a fast VM that keeps its disk, with coding agents built in. Compare it one to one: bochka vs Modal and bochka vs Google Agent Runtime.
Questions people ask
Is Modal cheaper than Google Agent Runtime?
In most of our scenarios, yes: one always-on agent costs $178 a month on Modal against $301 on Google, and sandboxes for your users $792 against $1,030, though Modal's 24-hour limit means the always-on case does not truly fit. For 1,000 short jobs at once Google is lower, $2,060 against $3,193. bochka comes to $26 and $200 in those first two scenarios.
Which is faster, Modal or Google Agent Runtime?
Only Modal has a public score: 12.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run. Google's sandboxes were not measured. bochka finished 26.69 in the same run.
Can Modal or Google Agent Runtime run Docker?
Modal runs Docker only on its VM runtime, chosen with runtime="vm". Google's sandboxes run as the unprivileged user appuser with no sudo, and no Docker is documented. Every bochka sandbox runs Docker with no extra setting.
How long can a sandbox run on Modal and on Google?
A Modal sandbox has a default timeout of 5 minutes and a maximum of 24 hours. A Google sandbox lives up to 7 days for a custom container and 14 days for Code Execution, and can be paused. bochka has no session cap on paid plans.
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 called Agent Sandbox.
Which one has GPUs?
Modal rents GPUs from T4 to B300, 10 at once on Starter and 50 on Team. Google's agent sandboxes have no GPUs, and bochka sandboxes are CPU machines too.
Try bochka
Install the CLI, then run bochka new.
Product preview