Google Agent Runtime vs Agent 37

Google Agent Runtime hosts agent code on Google Cloud and runs code in short-lived sandboxes as a user with no root. Agent 37 gives each of your users one persistent sandbox with SSH and HTTPS URLs that sleeps when idle and keeps its memory.

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.

Kind of product: Managed agent hosting plus code, shell and browser sandboxes on Google Cloud
Former name: Vertex AI Agent Engine, renamed Agent Runtime in April 2026
Isolation: Secure container sandboxing; commands run as the unprivileged user appuser with no sudo
Launch stage: Shell and Computer Use sandboxes GA since 2026-09-09; custom containers, templates and snapshots launched in Preview on 2026-05-26
Regions: 23 locations across the US, Europe, Asia, Canada, Australia and Brazil
Billing: $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, first 50 vCPU-hours and 100 GiB-hours free each month

Agent 37

Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.

You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.

Isolation: gVisor by default; opt-in full VM type with its own kernel and KVM
Where it runs: Dedicated servers in the United States
Billing: Prepaid wallet, metered per minute, no plan fee or seat charge
Instance types: Default (shared), Performance (dedicated cores), VM
Compliance: SOC 2 Type I, Type II in progress
Company: Y Combinator company based in New York

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	Agent 37: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Google's sandboxes have no root or Docker; Agent 37 needs its VM type for Docker, at 2.5x the compute rate; bochka has Docker and systemd on every VM.	295th of 367, with limits $5,801 a month	2nd cheapest of 367 $551 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Agent 37 is built for this: one always-on assistant per user that sleeps when idle and wakes on the next message, while a Google sandbox is deleted when its TTL ends.	28th cheapest of 366 $7,519 a month	Cheapest of 366 $279 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 Google's Code Execution sandbox is a ready Python interpreter with no network, and Agent 37's small default sandboxes also suit short code runs.	254th of 345, with limits $275 a month	Cheapest of 345 $22 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 Agent 37 holds up to 200 instances on its top self-serve tier, counting sleeping ones; Google gives users no public URL; bochka serves HTTPS on up to 50 ports per sandbox.	280th of 361, with limits $1,916 a month	30th of 361, with limits $79 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	128th of 360, with limits $8,240 a month	6th of 360, with limits $363 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	90th of 364, with limits $58 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 containers need Docker, which Google's sandboxes lack and Agent 37 offers only on its VM type.	98th cheapest of 377 $989 a month	2nd cheapest of 377 $84 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Agent 37 gives you SSH into a machine that stays around; Google has no SSH and runs each command in a new shell.	311th of 368, with limits $241 a month	3rd cheapest of 368 $12 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 offers a browser with a VNC view and CDP, Agent 37 adds a noVNC desktop through a template, and bochka streams a 60fps desktop out of the box.	283rd of 369, with limits $1,648 a month	Cheapest of 369 $53 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	102nd of 367, with limits $824 a month	48th of 367, with limits $29 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	53rd cheapest of 346 $515 a month	Cheapest of 346 $32 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	210th of 338, with limits $8,240 a month	36th of 338, with limits $648 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 bochka can fork a running sandbox to try many paths at once; Google can start many sandboxes from one memory snapshot; Agent 37 has no fork.	260th of 360, with limits $412 a month	Cheapest of 360 $43 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	Agent 37	bochka
Isolation	Secure container sandboxing inside Google Cloud	gVisor by default; full VM as an opt-in instance type	Every sandbox is a full VM with its own kernel
Root and Docker	Runs as appuser with no sudo; images must not need root; no Docker	Root by default; Docker only on the VM type, at 2.5x the default compute rate	Root, systemd and Docker on every machine
Nested virtualization	No /dev/kvm documented	/dev/kvm on the VM type, with a ready Android template	/dev/kvm in every sandbox, Android emulator works
Shell access	execute_bash() API calls; each command runs in a new shell; no SSH	Exec API, plus SSH through a WebSocket tunnel	SSH, plus an API for commands
How long a sandbox lives	TTL of up to 7 days for a custom container and 14 days for Code Execution	No time limit; runs until you stop it or it sleeps	No session cap on paid plans
Idle and memory	Pause keeps files and costs less; snapshots keep memory and files	Opt-in auto-sleep (default 15 minutes) that checkpoints memory and wakes on the next request	Disk saved every minute and on stop; a stopped sandbox costs nothing; resume reboots
Fork and branching	Start many sandboxes from one memory snapshot (same image and architecture)	No fork; daily backups plus one on-demand backup, restored in place only	Fork a running sandbox; named snapshots as shareable templates
Reaching the sandbox	Through Google's API or a private endpoint in your VPC; no public URL documented	HTTPS URL per port, signed URLs, custom domains; no public IP	HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv6 or IPv4
Outbound internet	Off unless the template turns it on; can route through your VPC, Cloud NAT and firewall	Open internet	Open internet on every plan; no provider-side allowlist
Desktop and computer use	A browser with a VNC live view, a click and type API, and CDP	noVNC desktop through a template build or the Ubuntu VM template	60fps desktop and Chromium in every sandbox, embeddable stream
Agents and agent code	Hosts ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns not billed	Templates for Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode, Pi, with a chat API	Claude Code, Codex, pi, OpenCode and more preinstalled, with a prompt, steer and events API
Keeping keys out of the sandbox	You provision and scope the credentials the agent uses	Managed LLM, search and Composio through a per-instance token; your own keys go in as env vars	Proxy for model providers and any HTTPS API you register; switch to another account when credits run out
Custom images	Custom container images that must not need root	Your own linux/amd64 Docker image as a template	Templates from named snapshots, no Dockerfile builds
Regions	23 locations in the US, Europe, Asia, Canada, Australia and Brazil	United States	EU only (Germany, Finland, France), EU data residency

Every feature Battleships tracks (43)

Feature	Google Agent Runtime	Agent 37	bochka
Full VM (own kernel)	No	No	Yes
Docker inside	No	No	Yes
Nested virtualization	No	No	Yes
Root	No	Yes	Yes
Systemd	Not published	Not published	Yes
Desktop GUI	No	Yes	Yes
Browser	Yes	Yes	Yes
Computer-use API	Yes	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	Yes	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	No	Yes	Yes
Raw TCP inbound	Not published	Not published	Yes
Public IPv4	No	No	No
Egress allowlist	Yes	No	No
Secret proxy	No	Yes	Yes
Secret proxy for any API	No	No	Yes
Preinstalled agents	Yes	Yes	Yes
Agent harness API	Yes	Yes	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	Yes	Yes
Usage per sandbox (API)	Yes	Yes	Yes
Audit logs	Not published	Not published	No
SSO	Yes	No	No
SOC 2	Yes	Yes	No
HIPAA	Yes	No	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

Google Agent RuntimeNot measured

Agent 37Not measured

bochka26.69 runs/s

There is no comparable CPU measurement for Google Agent Runtime or for Agent 37. In StarSling's public run of 2026-09-29, bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Agent 37 says its default instances share host resources and sells dedicated cores on its Performance type.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Google Agent Runtime and Agent 37 have 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	Agent 37, 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	$73 · Pay as you go	$6 · Wallet (any top-up)	$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	$12 · Wallet (any top-up)	$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	$329 · Wallet ($100 lifetime top-ups)	$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	$33 · Wallet ($250 lifetime top-ups) · with limits	$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	$73 · Wallet ($250 lifetime top-ups) · with limits	$2,000 · $2000/mo · with limits

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. Sandboxes are billed while they exist, and disk and egress rates are not published.

Agent 37: Agent 37 uses a prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while asleep. Performance compute costs 4x and VM compute 2.5x.

Limits in those scenarios

Google cannot run the 50-agent fleet because its sandboxes have no Docker, and a sandbox is deleted when its TTL ends, 7 days at most for a custom container. Agent 37 holds at most 200 instances on its top self-serve tier, counting sleeping and stopped ones, so the 300 user sandboxes and the 1,000-job burst do not fit. Its 50-agent fleet is priced on the VM type, since that needs Docker. bochka's start limits queue the 1,000-job burst too.

Scenario	Google Agent Runtime	Agent 37	bochka
One coding agent, workdays	disk beyond 0 GiB: price unknown egress price not published	egress price not published	None that bite
One agent that never stops	disk beyond 0 GiB: price unknown egress price not published	egress price not published	None that bite
50 agents in parallel	missing Docker inside disk beyond 0 GiB: price unknown egress price not published	egress price not published	None that bite
Sandboxes for your users	disk beyond 0 GiB: price unknown egress price not published	max 200 concurrent egress price not published	None that bite
1,000 short jobs at once	disk beyond 0 GiB: price unknown egress price not published	max 200 concurrent shared vCPUs on this tier: heavy, sustained CPU use can be slowed by other tenants egress price not published	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

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. 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. If agents must stay in a Google Cloud perimeter, egress is off by default and can route through your own firewall.
Memory snapshots and regions worldwide. If you need to branch a sandbox with its memory, or run in Asia or Brazil, Google offers both in 23 locations.

Use Agent 37 when

you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.

Sleeps when idle and keeps its memory. For assistants idle most of the day, an instance sleeps, keeps its memory and wakes on the next message.
A machine you can log into. Each instance has root, SSH and HTTPS URLs and runs with no time limit, so it works like a small server per user.
Bring a Dockerfile, pick dedicated cores. Agent 37 builds templates from your own Docker image and sells a Performance type on dedicated cores.

Where bochka fits

If your agents do real work for hours, like installs, builds, tests and Docker, look at bochka. Every bochka sandbox is a full VM with its own kernel, root, Docker and systemd, with a 60fps desktop, public URLs and coding agents built in. You can fork one while it runs, and it runs in the EU.

Docker and root on every machine

Google's sandboxes run as a user with no sudo and no Docker, so a docker compose stack never starts there. Agent 37 runs Docker only on its VM type, which costs 2.5x and has no systemd.

Fork a running sandbox

Agent 37 has no fork, so each new try rebuilds its state from the start. Google can branch from a memory snapshot, but only inside a sandbox that is deleted when its TTL ends.

Keys stay outside, for any API

On Agent 37 your own API keys sit as env vars inside a machine the agent controls, and on Google you pass keys into the sandbox yourself. bochka's proxy keeps them outside for any HTTPS API.

Use bochka when your agents need a real computer for hours: root, Docker, systemd, SSH, a desktop and public URLs on a full VM you can fork while it runs, with keys kept outside. Compare it one to one: bochka vs Google Agent Runtime and bochka vs Agent 37.

Questions people ask

Is Google Agent Runtime cheaper than Agent 37?

No, not in the scenarios we priced. One coding agent on workdays comes to $73 a month on Google and $6 on Agent 37, and one agent running all month comes to $301 versus $12. bochka comes to $20 and $26 for the same two.

Which is faster?

Neither Google Agent Runtime nor Agent 37 has a comparable CPU measurement. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public run.

Can Google Agent Runtime or Agent 37 run Docker?

Google's sandboxes cannot: commands run as appuser with no sudo, and images must not need root. Agent 37 runs Docker only on its VM type, at 2.5x the compute rate. bochka runs Docker in every sandbox.

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 called Agent Sandbox.

Where do they run?

Google runs in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil. Agent 37 runs on dedicated servers in the United States. bochka runs only in the EU, in Germany, Finland and France.

Can I SSH into the sandbox?

Not on Google, where each command is an API call in a new shell. Agent 37 offers SSH through a WebSocket tunnel. bochka gives every sandbox SSH and its own IP address.

Try bochka

Install the CLI, then run bochka new.

Product preview