bochka vs Google Agent Platform Sandbox
Google's Agent Platform gives agents three managed sandboxes: one for Python and JavaScript, one for shell commands and one with a browser. bochka gives each agent a whole Linux machine with root, Docker and a full desktop, while Google fits best when your agents already live inside Google Cloud.
Where bochka stands out
A whole machine with root, not a locked-down container
A bochka sandbox is a full VM with its own kernel, root, Docker, systemd and /dev/kvm, and you can SSH in. Google's shell sandbox runs each command in a new shell as an unprivileged user with no sudo, and custom images must not need root.
A full desktop, not only a browser
bochka streams a full Linux desktop at 60fps, with Chromium and computer use, so an agent can open any app on the machine. Google's Computer Use sandbox is a browser in a container that you drive over CDP and watch through VNC.
Agents and keys built in, and a URL you can open
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API. Real API keys stay outside the sandbox in a credentials proxy, and HTTPS URLs on up to 50 ports let you open what the agent built.
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
- Regions
- EU: Germany, Finland, France
Google Agent Platform Sandbox
Gemini Enterprise Agent Platform, formerly Vertex AI Agent Engine, is Google Cloud's platform for building and running AI agents, and its sandboxes are the places those agents run code and use a browser.
This is a hyperscaler's agent platform, not a sandbox company. It offers three sandbox types you drive through Google Cloud APIs: Code Execution runs Python or JavaScript with preinstalled libraries and no network, a shell sandbox runs one command at a time in an unprivileged Linux container, and a Computer Use sandbox runs a browser you control over Chrome DevTools Protocol with a VNC live view. It is built for teams already on Google Cloud who want agents to stay inside their project, IAM and VPC.
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 Platform Sandbox: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs to install packages, run Docker and start a dev server; Google's shell sandbox runs each command in a new shell as a user with no sudo, while bochka gives it a full machine with root. | 3rd cheapest of 367 $634 a month | 296th of 367, with limits $5,801 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on one machine all month needs a Google TTL set to cover the whole month, since the sandbox is deleted when it runs out; on bochka it simply keeps running with its disk. | 5th cheapest of 366 $657 a month | 290th of 366, with limits $6,015 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 built for this: quick Python or JavaScript runs with preinstalled libraries and state kept for up to 14 days. | 186th of 345, with limits $2,000 a month | 131st 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 want to open the app their sandbox is running; Google reaches sandboxes only through its APIs or a private endpoint in your VPC, while bochka gives each one HTTPS URLs on up to 50 ports. | Cheapest of 361 $209 a month | 149th 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 Google can snapshot a sandbox with its memory and start many copies from it, which suits rollouts that branch from the same state. | 34th of 360, with limits $2,000 a month | 129th 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 | 176th of 364, with limits $1,648 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that run Docker or build Android apps need root and /dev/kvm; bochka has both, and Google's containers run without root. | 4th cheapest of 377 $86 a month | 99th cheapest of 377 $989 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 312th 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's Computer Use sandbox is a browser only; bochka streams a full Linux desktop at 60fps for agents that use other apps too. | 6th cheapest of 369 $200 a month | 55th 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 browser your agent drives over CDP; Google keeps it inside your Google Cloud project, and bochka runs Chromium on a full machine you control. | 7th cheapest of 367 $200 a month | 38th cheapest of 367 $1,030 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 | 54th 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 | 211th 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 | 261st 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 Platform Sandbox |
|---|---|---|
| What it is | A sandbox platform: each agent gets its own full Linux machine | Google Cloud's agent platform, with managed Code Execution, Shell and Computer Use sandboxes |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Managed, isolated Linux container per sandbox |
| Root, Docker and /dev/kvm | Root, Docker, systemd and nested virtualization for Android emulators and VMs | Commands run as an unprivileged user with no sudo; images must not require root |
| How you reach it | SSH, a persistent shell, and an API | API calls only; each shell command runs in a new shell, so cd and variables do not carry over |
| Browser and desktop | Full Linux desktop streamed at 60fps, with Chromium and computer use | A browser in a container, driven over CDP, with a VNC live view; no full desktop |
| Lifetime | No session cap on paid plans; you set the time to live | Deleted when its TTL runs out; Computer Use defaults to 2 hours, and you can set a longer TTL |
| Pause and resume | Disk is saved every minute and on stop; a stopped sandbox costs nothing | Pause frees compute and keeps the file system; resume takes seconds |
| Snapshots and fork | Automatic snapshots every minute; fork a running sandbox with its disk | Snapshots on request that include memory; start many sandboxes from one snapshot; not for Code Execution |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | Private Service Connect endpoint in your VPC, or IAM-signed API and WebSocket calls; no public URL |
| Outbound network | Open internet, no provider-side allowlist | Off by default; turn on internet per template, or route egress through your VPC with Cloud NGFW or Secure Web Proxy rules |
| Coding agents | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API | Google's Antigravity harness through the Managed Agents API, a Pre-GA offering |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | No ambient credentials in the sandbox; MCP header tokens are sent only to the MCP endpoints you configure |
| Regions | EU only (Germany, Finland, France) | Google Cloud regions you pick, such as us-central1 |
| 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 Platform Sandbox |
|---|---|---|
| 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 | No |
| 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 | No |
| 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
There is no comparable measurement: Google's Agent Platform sandboxes were not part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on its Node.js build-and-test loop at 4 vCPU / 8 GB. Google does not publish the CPU type behind its sandboxes.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Google Agent Platform Sandbox 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 Platform Sandbox, 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 | $58 · Usage based · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $241 · Usage based · with limits |
| 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 | $2,900 · Usage based · 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 | $824 · Usage based · with limits |
| 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 | $1,648 · Usage based · with limits |
bochka: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Google Agent Platform Sandbox: Sandboxes bill per second for the vCPU and memory allocated, at $0.085 per vCPU-hour and $0.009 per GiB-hour on demand. The scenario table uses the 3-year Flexible Savings Plan rate, 20% below on demand, and disk and egress prices for sandboxes are not published.
Limits in those scenarios
None of the scenarios fit Google cleanly. The table prices Google at its 3-year savings plan rate, there is no Docker inside, and a sandbox is deleted when its TTL runs out, so an always-on agent needs a TTL long enough to cover its whole life. Google publishes quotas for Code Execution sandboxes only, so how many Computer Use or shell sandboxes can run at once for 300 or 1,000 users is not confirmed. bochka has no session cap, but at 1,000 short jobs at once its plans queue starts above 90 per minute.
| Scenario | bochka | Google Agent Platform Sandbox |
|---|---|---|
| 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 Google Agent Platform Sandbox when
your agents are built on Gemini and must stay inside your Google Cloud project and VPC, or need memory snapshots to branch many runs from one state.
- Memory snapshots and branching. Useful for rollouts and experiments: snapshot a sandbox with its memory and start many copies from that exact state.
- It lives inside your Google Cloud project. Teams on Google Cloud keep agents behind their own IAM, VPC Service Controls and egress firewall rules, in the regions they choose.
- Ready-made code execution for Gemini agents. For short Python or JavaScript runs, Code Execution is ready to call with preinstalled libraries and no network.
Use bochka when
your agents do real work on a machine for hours: installs, builds, Docker, emulators, a full desktop and a browser, with root, a disk that keeps everything and a URL you can open.
- A whole machine with root, not a locked-down container. Coding agents install system packages, start Docker and run long-lived dev servers. In Google's container that means baking everything into an image first, and Docker or an Android emulator is not documented to run at all.
- A full desktop, not only a browser. Agents that test a desktop app, open a file in an office suite or use a tool outside the browser have nowhere to do it in a browser-only sandbox.
- Agents and keys built in, and a URL you can open. Google's managed harness is its own Antigravity agent and is Pre-GA. To run another coding agent you build the harness, hand it keys, and proxy any preview through your own VPC endpoint.
Questions people ask
Is bochka cheaper than Google Agent Platform Sandbox?
In four of the five scenarios on this page, yes, even with Google priced at its 3-year savings plan rate. For 1,000 short jobs at once Google costs less in the table, but its concurrency for that many sandboxes is not confirmed and bochka queues starts above 90 per minute, so neither fits cleanly.
Can I run Docker in a Google Agent Platform sandbox?
It is not documented. The shell sandbox runs commands as an unprivileged user with no sudo, and custom images must not require root, which Docker normally needs. bochka runs Docker as root and also exposes /dev/kvm for emulators and VMs.
Does the Computer Use sandbox give a full desktop?
No, it is a browser in a container that you drive over Chrome DevTools Protocol, with a VNC view to watch it. bochka streams a full Linux desktop at 60fps with Chromium, so an agent can use other apps too.
Do Google's sandboxes have internet access?
Code Execution has none. Shell and Computer Use sandboxes have internet off unless the template turns it on, and you can route egress through your own VPC with firewall rules. bochka sandboxes reach the open internet by default.
How long can a Google Agent Platform sandbox run?
Until its TTL runs out, then it is deleted. Computer Use sandboxes default to 2 hours, Code Execution keeps state up to 14 days, and Managed Agents sandboxes last 7 days from the last interaction. bochka has no session cap on paid plans.
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