bochka vs Google Agent Runtime

Google Agent Runtime, once called Vertex AI Agent Engine, hosts your agent code on Google Cloud and adds sandboxes that run as an unprivileged user in a locked container. bochka gives every agent a full VM with root, Docker, a desktop and coding agents built in, and it costs less in all five scenarios below.

Where bochka stands out

Root, Docker and a real kernel

On bochka every sandbox is a VM with its own kernel, with root, systemd, Docker and /dev/kvm ready. Google's shell sandbox runs commands as the unprivileged user appuser with no sudo, and custom images must not need root. So apt installs, Docker builds and Android emulators work on bochka and not inside a Google sandbox.

Public URLs for what agents build

A bochka sandbox can serve HTTPS on up to 50 ports with token protection, accept raw TCP and get its own IP address. A Google sandbox is reached through Google's API or a private endpoint inside your own VPC, and its docs describe no public URL. On bochka you can SSH in too.

Coding agents you drive from outside

bochka ships Claude Code, Codex, pi, OpenCode and other agents inside each sandbox, and you drive them from outside with a prompt, steer and events API. Google's Managed Agents API is in Preview and runs its own Antigravity harness. bochka's credentials proxy also keeps real AI keys out of the sandbox and can switch to another account when one runs out of credits.

The companies and products

bochka

bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.

You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.

Isolation: Full VM per sandbox, own kernel
Hardware: Dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Regions: EU: Germany, Finland, France
Plans: From $20 a month, all of it usage credit, 7-day trial

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

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. “3rd cheapest of 367” means 2 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	bochka: price rank	Google Agent Runtime: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Google's sandboxes run without root or Docker, so installs that need sudo, docker compose stacks and emulators do not run there; bochka has all of them on every VM.	3rd cheapest of 367 $634 a month	295th of 367, with limits $5,801 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Google sandbox is deleted when its TTL runs out (7 days at most for a custom container), so a long-lived assistant needs restarts; a bochka VM has no session cap on paid plans.	5th cheapest of 366 $657 a month	28th cheapest of 366 $7,519 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, and new sandboxes start without a plan.	186th of 345, with limits $2,000 a month	254th of 345, with limits $275 a month
Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Your users get a shell through Google's API but no public URL for what they build, while on bochka each sandbox can serve HTTPS on up to 50 ports.	Cheapest of 361 $209 a month	280th of 361, with limits $1,916 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month	34th of 360, with limits $2,000 a month	128th of 360, with limits $8,240 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month	10th cheapest of 364 $200 a month	79th cheapest of 364 $2,060 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 unprivileged sandboxes do not offer; bochka runs Docker and systemd on every VM.	4th cheapest of 377 $86 a month	98th cheapest of 377 $989 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Google has no SSH into a sandbox and each command runs in a new shell, so it does not work as a dev box you log into; bochka gives you SSH and a desktop.	18th cheapest of 368 $26 a month	311th of 368, with limits $241 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Google gives you only a browser, with a VNC view, a click and type API and CDP, so desktop apps are out of reach; bochka streams a full 60fps desktop with Chromium.	6th cheapest of 369 $200 a month	283rd of 369, with limits $1,648 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both run a real Chromium you can drive over CDP with Playwright; Google keeps outbound internet off unless the template turns it on.	7th cheapest of 367 $200 a month	102nd of 367, with limits $824 a month
Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month	6th cheapest of 346 $90 a month	53rd cheapest of 346 $515 a month
Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month	71st of 338, with limits $1,800 a month	210th of 338, with limits $8,240 a month
Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month	2nd cheapest of 360 $200 a month	260th of 360, with limits $412 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
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

Key features

Feature	bochka	Google Agent Runtime
Isolation	Every sandbox is a full VM with its own kernel	Secure container sandboxing inside Google Cloud
Root, Docker and nested virtualization	Root, systemd, Docker and /dev/kvm on every machine	Runs as appuser with no sudo; images must not need root; no Docker or /dev/kvm documented
Shell access	SSH, plus an API for commands	execute_bash() API calls; each command runs in a new shell; no SSH
Desktop and computer use	60fps desktop and Chromium, computer use and browser control, embeddable stream	A browser in a container with a VNC live view, a click, type and screenshot API, and CDP for Playwright
Files after a stop	Snapshots every minute and on stop; a stopped sandbox costs nothing	Pause keeps the file system and costs less (rate not published); the sandbox is deleted when its TTL ends
Memory snapshots and branching	Fork a running sandbox; resume reboots from disk (no memory snapshots)	Snapshots keep memory and files; start many sandboxes from one snapshot (same image and architecture)
How long a sandbox lives	No session cap on paid plans	TTL of up to 7 days for a custom container and 14 days for Code Execution
Reaching the sandbox	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4	Through Google's API, or a private endpoint in your own VPC; no public URL documented
Outbound internet	Open internet on every plan; no provider-side allowlist	Off unless the template turns it on; can route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web Proxy
Coding agents	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API	Managed Agents API (Preview) runs Google's Antigravity harness; no other coding harness named
Keeping keys out of the sandbox	AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out	You provision and scope the credentials the agent uses
Hosting your agent code	You run your own agent loop inside a sandbox	Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed
Machine size	Up to 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from the $100 plan	Runtime: 1, 2, 4, 6 or 8 vCPU and up to 32 GiB; sandbox maximum not published; changing a sandbox means deleting it
Regions	EU only: Germany, Finland, France	23 locations in the US, Europe, Asia, Canada, Australia and Brazil
Compliance and transparency	SOC 2 is in progress. We're open about where we stand: live status and data retention policy.	SOC 2

Every feature Battleships tracks (43)

Feature	bochka	Google Agent Runtime
Full VM (own kernel)	Yes	No
Docker inside	Yes	No
Nested virtualization	Yes	No
Root	Yes	No
Systemd	Yes	Not published
Desktop GUI	Yes	No
Browser	Yes	Yes
Computer-use API	Yes	Yes
SSH	Yes	No
Persistent disk	Yes	Yes
Pause/resume	Yes	Yes
Automatic snapshots	Yes	Yes
Fork/clone	Yes	Yes
Live fork (no pause)	Yes	Yes
Memory fork	No	Yes
Custom image (Docker or snapshot)	Yes	Yes
≥24 h sessions	Yes	Yes
Idle auto-stop	No	No
Wake on request	No	No
HTTPS preview URLs	Yes	No
Raw TCP inbound	Yes	Not published
Public IPv4	No	No
Egress allowlist	No	Yes
Secret proxy	Yes	No
Secret proxy for any API	Yes	No
Preinstalled agents	Yes	Yes
Agent harness API	Yes	Yes
MCP server	No	No
GPU	No	No
Windows	No	No
Arm64	No	Yes
Self-hosting	No	No
BYOC	No	No
Open source	No	No
Scoped API keys	Yes	Not published
Spend limits	Yes	Not published
Usage per sandbox (API)	Yes	Yes
Audit logs	No	Not published
SSO	No	Yes
SOC 2	No	Yes
HIPAA	No	Yes
EU data residency	Yes	Yes
Zero data retention	Yes	Not published

Performance

bochka26.69 runs/s

Google Agent RuntimeNot measured

There is no comparable measurement for Google Agent Runtime or its sandboxes. 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; Google's sandboxes were not part of that run.

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 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	bochka, a month	Google Agent Runtime, 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	$20 · $20/mo	$73 · Pay as you go
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$26 · $20/mo	$301 · Pay as you go
50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside	$317 · $20/mo × 3 seats	$3,626 · Pay as you go · with limits
Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once	$200 · $100/mo × 2 seats	$1,030 · Pay as you go
1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month	$2,000 · $2000/mo · with limits	$2,060 · Pay as you go

bochka: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour for what you allocate, rounded to 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; a paused one costs less at a rate Google does not publish, and disk and egress rates are not published either.

Limits in those scenarios

On Google, a sandbox is deleted when its TTL ends, 7 days at most for a custom container, so an agent that never stops needs to be recreated. The 50-agent fleet does not fit because Google's sandboxes have no Docker inside, and every Google row leaves disk and egress unpriced because those rates are not published. On bochka the 1,000-job burst is the problem: starts are capped at 90 a minute and 2,400 a day on the $2,000 plan, so the jobs get queued.

Scenario	bochka	Google Agent Runtime
One coding agent, workdays	None that bite	disk beyond 0 GiB: price unknown egress price not published
One agent that never stops	None that bite	disk beyond 0 GiB: price unknown egress price not published
50 agents in parallel	None that bite	missing Docker inside disk beyond 0 GiB: price unknown egress price not published
Sandboxes for your users	None that bite	disk beyond 0 GiB: price unknown egress price not published
1,000 short jobs at once	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)	disk beyond 0 GiB: price unknown egress price not published

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

Use bochka when

your agents need a real computer: root, Docker, SSH, a desktop and public URLs on a full VM that keeps its disk, with Claude Code, Codex and other coding agents built in.

Root, Docker and a real kernel. Coding agents reach for sudo apt install and docker compose all the time. On Google you would bake every tool into an image ahead of time, and anything that needs Docker has to run somewhere else.
Public URLs for what agents build. When an agent builds a web app, someone has to open it. On Google you would set up a VPC endpoint, a load balancer or a tunnel yourself to show a preview to a person outside your project.
Coding agents you drive from outside. If your team uses Claude Code or Codex, Google gives you no built-in way to run them: you install them in an image and pass keys in, where code in the sandbox can read them.

Questions people ask

Is bochka cheaper than Google Agent Runtime?

In all five scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $73 on Google, and one agent running all month comes to $26 versus $301. 50 agents in parallel come to $317 versus $3,626, though Google cannot run that fleet without Docker, and sandboxes for your users $200 versus $1,030. For 1,000 short jobs at once, bochka comes to $2,000 and Google to $2,060, but bochka's start limits queue the jobs. Google's numbers assume a sandbox that exists all those hours; a Runtime agent that sits idle between turns bills less.

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. The sandboxes for code, shell and browser use are a separate part of the same platform called Agent Sandbox.

Can I run Docker or sudo in a Google Agent Sandbox?

No. Shell commands run as the unprivileged user appuser with no sudo, and custom images must not need root, so Docker and nested virtualization are not available. On bochka every sandbox is a VM with root, Docker and /dev/kvm.

Can a Google sandbox serve a web app to the public?

Google's docs describe reaching a sandbox through its API or through a private endpoint in your own VPC, not a public URL. On bochka a sandbox can serve HTTPS on up to 50 ports, accept raw TCP and get its own IP address.

Where does my data run?

bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Google runs Agent Runtime and sandboxes in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil, inside your own Google Cloud project.

Is bochka SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.

Start a sandbox

Install the CLI, then run bochka new.

Product preview