Claude Managed Agents vs Google Agent Runtime
Claude Managed Agents is Anthropic's ready-made agent: you send events and Claude works in a container that Anthropic runs. Google Agent Runtime, once called Vertex AI Agent Engine, hosts agent code you build with ADK or LangGraph inside your Google Cloud project, with separate locked sandboxes for code, shell and browser.
The companies and products
Claude Managed Agents
Claude Managed Agents is Anthropic's ready-made agent harness: Claude runs as an autonomous agent in a cloud sandbox that Anthropic manages, and you talk to it through an events API.
This is an agent platform, not a sandbox you rent. You define an agent (model, prompt, tools, MCP servers, skills) and an environment, then start sessions, send messages as events and stream back what Claude does; the harness handles tool calls, prompt caching and compaction. Each session gets its own Ubuntu container, or runs its tools on a worker you host yourself. It is built for teams that want Claude doing long tasks without building their own agent loop or sandbox.
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. “106th cheapest of 367” means 105 of the other 366 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 | Claude Managed Agents: 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 Neither gives a coding agent root and a full Docker: Managed Agents lists Docker as limited availability and Google's sandboxes run as an unprivileged user; bochka has root, Docker and systemd on every VM. | 106th of 367, with limits $964 a month | 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 Managed Agents sessions sleep for free and wake on the next message but keep files only 30 days, Google sandboxes are deleted after a TTL of up to 7 days, and a bochka VM has no session cap on paid plans. | 219th of 366, with limits $2,511 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 Google's Code Execution sandbox is a ready Python interpreter, and Managed Agents bills runtime only while the agent works, so both handle short bursts of code well. | 163rd of 345, with limits $756 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 Neither offers a public URL for what a user builds, since both are reached only through their own APIs; bochka gives each sandbox HTTPS URLs on up to 50 ports. | 231st of 361, with limits $823 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 | 252nd of 360, with limits $3,978 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 | 244th of 364, with limits $320 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 containers need Docker, which Google's sandboxes do not have and Managed Agents has only in limited availability; bochka runs Docker and /dev/kvm on every VM. | 227th of 377, with limits $96 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 Neither has SSH into the sandbox, so neither works as a dev box you log into; bochka gives you SSH, a desktop and a disk that lasts. | 224th of 368, with limits $48 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 Computer Use browser with a VNC view and a click and type API, Managed Agents has only headless Chromium, and bochka streams a full Linux desktop at 60fps. | 127th of 369, with limits $288 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 All three can drive Chromium with Playwright; Google keeps outbound internet off unless the template turns it on, and bochka lets you watch or take over the browser on a live desktop. | 126th of 367, with limits $288 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 | 127th of 346, with limits $390 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 | 155th of 338, with limits $4,798 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 | 179th of 360, with limits $160 a month | 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 | 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 | Claude Managed Agents | Google Agent Runtime | bochka |
|---|---|---|---|
| What it is | Anthropic's hosted Claude agent: its harness runs Claude in a sandbox and you send it events | Hosting for agent code you build, plus code, shell and browser sandboxes on Google Cloud | A sandbox platform: each agent gets its own full Linux machine, with coding agents built in |
| Isolation | Isolated Linux container per session | Secure container sandboxing inside your Google Cloud project | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and /dev/kvm | Docker in limited availability; root, systemd and /dev/kvm not documented | Runs as appuser with no sudo; images must not need root; no Docker or /dev/kvm | Root, systemd, Docker and nested virtualization on every machine |
| Machine size | Up to 8 GB memory and 10 GB disk; vCPU not published; not configurable | Runtime: 1 to 8 vCPU and up to 32 GiB; sandbox maximum not published | Up to 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from the $100 plan |
| Agent loop | Anthropic's harness with Claude models, caching, compaction, memory stores and webhooks | Deploys your ADK, LangGraph, LangChain, AG2 or LlamaIndex agent; Managed Agents API in Preview runs Google's Antigravity harness | Claude Code, Codex and more preinstalled, driven from outside with a prompt, steer and events API |
| Idle time | Idle sessions are checkpointed, not billed, and wake on the next message | Runtime skips idle time between turns, but sandboxes are billed while they exist | A stopped sandbox costs nothing and keeps its disk; you start it again by API |
| How long state lasts | Sandbox state is kept only 30 days after the sandbox is created | Sandbox is deleted when its TTL ends: up to 7 days for a custom container, 14 for Code Execution | The whole disk, saved every minute, for as long as you keep the sandbox |
| Snapshots and branching | File checkpoint on idle; no fork or clone of a session | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox with its disk; resume reboots from disk |
| Reaching the sandbox | No inbound ports or SSH; only the sessions and events API | Google's API or a private endpoint in your VPC; no public URL or SSH documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH |
| Browser and desktop | Headless Chromium with Playwright; no desktop or computer-use tool | A browser in a container with a VNC live view, a click and type API and CDP | Full Linux desktop streamed at 60fps, with Chromium and computer use |
| Outbound rules | Unrestricted, or limited to listed hosts plus package registries and MCP servers | Off unless the template turns it on; route through your VPC with Cloud NAT, a static IP or Cloud NGFW | Open internet on every plan, no provider-side allowlist |
| Keeping API keys out of the sandbox | Vault secrets sit in the sandbox as placeholders and are swapped in at egress | You provision and scope the credentials the agent uses | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Running on your own infrastructure | Self-hosted sandboxes run tool calls on workers you host | Everything runs inside your own Google Cloud project | No; sandboxes run on bochka's hosts |
| Where data lives | US workspace geo only | 23 locations across the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France, with zero data retention |
Every feature Battleships tracks (43)
| Feature | Claude Managed Agents | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | Not published | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | No | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | 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 | Yes | No | No |
| HTTPS preview URLs | No | No | Yes |
| Raw TCP inbound | No | Not published | 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 | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | No | Not published | Yes |
Performance
There is no comparable measurement for either Claude Managed Agents or Google Agent Runtime: neither was part of the hpc-sandbox-benchmarks run, and neither publishes the vCPU count of its sandboxes. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. On both platforms much of a session is often spent waiting on the model rather than on the CPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Claude Managed Agents and Google Agent Runtime 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 | Claude Managed Agents, 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 | $13 · Claude API (pay-as-you-go, usage tiers) · 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 | $53 · Claude API (pay-as-you-go, usage tiers) · 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 | $634 · Claude API (pay-as-you-go, usage tiers) · 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 | $360 · Claude API (pay-as-you-go, usage tiers) · with limits | $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 | $796 · Claude API (pay-as-you-go, usage tiers) · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
Claude Managed Agents: Managed Agents bills model tokens at API rates plus a flat session runtime fee, measured only while the session is running, including time spent waiting on the model. The table shows runtime only, and tokens usually cost more.
Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, with a monthly free amount. Runtime skips idle time between turns, but sandboxes are billed while they exist, and disk and egress rates are not published.
Google Agent Runtime: Plans start at $20 a month, and the whole fee is usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
No scenario counts as a clean fit for Managed Agents, because its sandbox size is not published and it is a different kind of product with model tokens on top. Google fits most scenarios but not the 50-agent fleet, since its sandboxes have no Docker, and every Google row leaves disk and egress unpriced. Managed Agents allows 300 session creates a minute and usage-tier spend caps that pause all API use; bochka's limit is the 1,000-job burst, where the $2,000 plan queues starts above 90 a minute.
| Scenario | Claude Managed Agents | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Claude Managed Agents when
you want Claude itself to do long tasks with no agent loop to build, idle time that costs nothing, and the option to run tools on your own workers.
- No agent loop to build. Teams that want Claude doing long tasks get Anthropic's harness, caching, compaction, memory and webhooks ready to use.
- Idle sessions sleep for free. Agents that wait a long time between messages pay runtime only while working, and resume on the next message.
- Tools on your own workers. Teams with strict rules can run every tool call on their own machines while Anthropic keeps the orchestration.
Use Google Agent Runtime when
you build your own agents with ADK or LangGraph on Google Cloud and want them hosted in your project, network and region of choice.
- Host the agent you wrote. Teams building with ADK, LangGraph or LangChain get a managed home for that code, with idle time between turns not billed.
- Inside your Google Cloud network. Teams on Google Cloud keep agents in their own project, with egress off by default and routed through their firewall.
- Memory snapshots and many regions. Teams that branch sandboxes with their memory, or need the US, Europe or Asia, get both in 23 locations.
Where bochka fits
Both Claude Managed Agents and Google Agent Runtime put the agent in a small locked container that you reach only through an API. If your agents need a real computer, with Docker, ports people can open and a disk that lasts, look at bochka. It gives every agent a full VM and runs Claude Code, Codex and other agents you drive from outside.
A full VM with root and Docker
Coding agents reach for sudo, docker compose and emulators. Google's sandboxes have no root or Docker, and Managed Agents has Docker only in limited availability, so you bake tools into an image or run that work somewhere else.
Links to what the agent builds
Neither platform gives a sandbox a public URL or SSH. On Managed Agents you copy the code elsewhere to try it; on Google you set up a VPC endpoint or tunnel. bochka serves HTTPS on up to 50 ports.
A disk that outlives the session
Managed Agents keeps sandbox state 30 days and Google deletes a sandbox after a TTL of up to 7 days, so a long-lived agent redoes its setup. bochka saves the disk every minute and has no session cap on paid plans.
Use bochka when your agents need a real machine: root, Docker, SSH, a desktop, public URLs and a disk that lasts, with Claude Code, Codex and other agents built in. Compare it one to one: bochka vs Claude Managed Agents and bochka vs Google Agent Runtime.
Questions people ask
Is Claude Managed Agents cheaper than Google Agent Runtime?
For runtime alone, yes in every scenario we priced: one coding agent on workdays is $13 a month on Managed Agents against $73 on Google, and one agent all month is $53 against $301. But Managed Agents adds model tokens on top, which usually cost more than the runtime, and Google bills models separately too.
Which is faster?
We can't say. Neither was measured in the hpc-sandbox-benchmarks run, and neither publishes how many vCPUs a sandbox gets. bochka did 26.69 runs per second at 4 vCPU / 8 GB in that run.
Can Claude Managed Agents or Google Agent Runtime run Docker?
Managed Agents lists Docker as limited availability. Google's sandboxes run as the unprivileged user appuser with no sudo, so Docker is not available there. On bochka every sandbox is a VM with root, Docker and /dev/kvm.
Can I use models other than Claude?
Managed Agents runs only Claude models through Anthropic's harness. Google Agent Runtime hosts agent code you write with frameworks like ADK, LangGraph or LangChain. bochka ships Claude Code, Codex and other agents in each VM.
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.
Where does my data run?
Managed Agents stores data and runs code in the US workspace geo only. Google runs in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Claude Managed Agents
- bochka vs Google Agent Runtime
- E2B vs Claude Managed Agents
- Daytona vs Claude Managed Agents
- Modal vs Claude Managed Agents
- Vercel Sandbox vs Claude Managed Agents
- Cloudflare Sandbox vs Claude Managed Agents
- Blaxel vs Claude Managed Agents
- Runloop vs Claude Managed Agents
- Tensorlake vs Claude Managed Agents
- Morph Cloud vs Claude Managed Agents
- CodeSandbox SDK vs Claude Managed Agents