OpenAI Containers vs Google Agent Runtime
OpenAI Containers are a tool inside OpenAI's model API: the model runs code in a short-lived box that is thrown away after 20 minutes without use. Google Agent Runtime hosts your agent code on Google Cloud and gives it sandboxes that can live up to 7 days, pause, and save their memory in snapshots.
The companies and products
OpenAI Containers
OpenAI Containers are the sandboxes OpenAI runs for its own model tools: Code Interpreter, Hosted Shell and the Agents API's hosted sandbox.
This is a different kind of product from bochka: a tool inside OpenAI's model API, not a machine you rent. You create a container through the API or let a Responses call make one, and the model runs Python or shell commands in it on a fixed Debian 12 image without sudo, until it expires after 20 minutes without use. It is built for apps that already call OpenAI models and want them to run code, read files and make charts without running any servers.
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. “356th cheapest of 367” means 355 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 | OpenAI Containers: 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 or Docker, so sudo installs and docker compose stacks fail on both; bochka has root, Docker and systemd on every VM. | 356th of 367, with limits $17,371 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 An assistant that lives on its machine all month fits Google better, since a sandbox can last 7 days and pause, while an OpenAI container is deleted after 20 idle minutes; bochka has no session cap on paid plans. | 341st of 366, with limits $13,140 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 This is home ground for both: OpenAI runs the model's Python in the same API call, and Google's Code Execution sandbox is a ready Python interpreter with no network. | 194th of 345, with limits $6,000 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 gives your users a public URL for what they build; on bochka each sandbox can serve HTTPS on up to 50 ports and accept SSH. | 361st of 361, with limits $3,780 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 | 191st of 360, with limits $30,000 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 Google's memory snapshots let you start many sandboxes from one saved state, which OpenAI containers cannot do; bochka forks a running sandbox with its disk. | 360th of 364, with limits $5,760 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 neither OpenAI nor Google sandboxes offer; bochka runs Docker on every VM. | 345th of 377, with limits $1,728 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 or works as a box you log into and keep all month; bochka gives you SSH, a desktop and a disk that stays. | 362nd of 368, with limits $1,051 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 Both offer a hosted browser for computer use, OpenAI inside the Agents API beta and Google with a VNC view and CDP; bochka streams a full 60fps desktop. | 351st of 369, with limits $5,280 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 | 328th of 367, with limits $1,440 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 | 328th of 346, with limits $1,755 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 | 311th of 338, with limits $35,100 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 | 308th of 360, with limits $870 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 | OpenAI Containers | Google Agent Runtime | bochka |
|---|---|---|---|
| What it is | A sandbox tool the model uses inside OpenAI's API | Managed agent hosting plus code, shell and browser sandboxes on Google Cloud | A cloud VM you create, keep, stop and reach from outside |
| Isolation | A fully sandboxed virtual machine; hypervisor not named | Secure container sandboxing inside your Google Cloud project | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | Commands do not run with sudo; no Docker or /dev/kvm documented | Runs as appuser with no sudo; images must not need root; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every machine |
| How long a sandbox lives | Expires after 20 minutes without use; Agents API sandboxes after an hour without activity | TTL of up to 7 days for a custom container and 14 days for Code Execution | No session cap on paid plans; you set the time to live |
| Files after a stop | Data is discarded when the container expires | Pause keeps the file system and costs less; deleted when the TTL ends | Disk saved every minute and on stop; a stopped sandbox costs nothing and comes back |
| Snapshots and branching | No snapshots or fork | Snapshots keep memory and files; start many sandboxes from one snapshot | Fork a running sandbox with its disk; resume reboots from disk (no memory snapshots) |
| Custom image | Fixed Debian 12 image; you upload files or skills into each container | Custom container images (Preview), which must not need root | Named snapshots of a set-up machine, reused as templates |
| Machine size | 1, 4, 16 or 64 GB of memory; vCPU not published | Runtime: 1 to 8 vCPU and up to 32 GiB; sandbox maximum not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB from the $100 plan |
| Reaching the sandbox | Only through the API; no ports, URLs or SSH | Through Google's API or a private endpoint in your VPC; no public URL documented; no SSH | SSH, HTTPS URLs for up to 50 ports, raw TCP |
| Outbound internet | Code Interpreter and Hosted Shell: off until an admin sets an org domain allowlist; Agents API sandboxes on by default | Off unless the template turns it on; can 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 | domain_secrets: a sidecar adds the real header for approved domains | 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 |
| Coding agents | Agents API (beta) drives a managed Codex harness from outside | Managed Agents API (Preview) runs Google's Antigravity harness | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | Hosted browser for the Agents API computer_use tool | A browser in a container with a VNC live view, a click and type API, and CDP | 60fps desktop and Chromium, computer use, embeddable stream |
| Regions | US or EU processing for Code Interpreter; Agents API data residency US only | 23 locations in the US, Europe, Asia, Canada, Australia and Brazil | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | OpenAI Containers | Google Agent Runtime | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | No | No | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | Yes |
| SSH | No | No | Yes |
| Persistent disk | No | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | No | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | 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 | No | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | Yes | 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) | No | Yes | Yes |
| Audit logs | Not published | 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
There is no comparable measurement for OpenAI Containers or Google Agent Runtime: neither is in the public CPU benchmark, and OpenAI does not publish the vCPU behind each container size. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's hpc-sandbox-benchmarks run of 2026-09-29.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. OpenAI Containers 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 | OpenAI Containers, 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 | $228 · API pay as you go · 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 | $1,051 · API pay as you go · 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 | $11,405 · API pay as you go · 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 | $1,620 · API pay as you go · 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 | $6,000 · API pay as you go · with limits | $2,060 · Pay as you go | $2,000 · $2000/mo · with limits |
OpenAI Containers: OpenAI bills each container session by the minute for the memory size you pick, with a 5-minute minimum, and model tokens are billed on top. There is no plan fee.
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.
Google Agent Runtime: 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.
Limits in those scenarios
OpenAI Containers fit none of the five scenarios: no persistent disk, no Docker, no internet in Code Interpreter and Hosted Shell until an admin allows domains, and no published vCPU or limit on how many run at once. Google fits four of them, but the 50-agent fleet fails because its sandboxes have no Docker inside, and disk and egress stay unpriced. 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 | OpenAI Containers | 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 OpenAI Containers when
your app already calls OpenAI models and the model only needs to run short pieces of code or shell commands on files you give it.
- Built into the model call. Useful if your app already calls OpenAI models: one tool line in a request gives the model a place to run code.
- Nothing to clean up. Useful for short code runs: a container goes away by itself after 20 idle minutes, billed by the minute with a 5-minute minimum.
- Secrets the model never sees. Useful if code calls outside APIs: domain_secrets adds the real header in a sidecar, so the model only sees a placeholder.
Use Google Agent Runtime when
you build agents with ADK or LangGraph on Google Cloud and want them hosted in your own project, with sandboxes that last days, pause and snapshot their memory.
- 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.
- Sandboxes that last and branch. Useful if work spans days: a sandbox can live up to 7 days, pause, and save its memory in a snapshot you can start many times.
- Inside your Google Cloud network. Useful if agents must stay in your own project and regions, with egress off by default and routed through your own firewall.
Where bochka fits
Both OpenAI and Google give agents a locked box with no root, no Docker and no way in from outside. If your agents need a real computer they keep, with a disk that stays, ports you can open and any coding agent built in, look at bochka instead.
Root and Docker on a full VM
Coding agents reach for sudo apt install and docker compose. Neither OpenAI nor Google allows sudo or Docker, so on Google you bake every tool into an image ahead of time and on OpenAI you have to host your own sandbox.
A disk that stays, with no session cap
An OpenAI container loses its files after 20 idle minutes, and a Google sandbox is deleted when its 7-day TTL ends. bochka saves the disk every minute, a stopped sandbox costs nothing, and paid plans have no session cap.
Ports and SSH you can reach
When an agent builds a web app, someone has to open it. OpenAI containers accept no inbound connections, and Google needs a VPC endpoint or a tunnel you set up. bochka gives HTTPS on up to 50 ports, raw TCP and SSH.
Use bochka when your agents need a real machine they keep: root, Docker, a disk that persists, SSH and public ports, with Claude Code, Codex and other coding agents built in. Compare it one to one: bochka vs OpenAI Containers and bochka vs Google Agent Runtime.
Questions people ask
Is OpenAI Containers cheaper than Google Agent Runtime?
In the scenarios on this page, Google costs less: one coding agent on workdays comes to $73 a month on Google and $228 on OpenAI, and one agent running all month comes to $301 versus $1,051. OpenAI also bills model tokens on top. bochka comes to $20 and $26 a month for the same two scenarios.
Which is faster, OpenAI Containers or Google Agent Runtime?
There is no public CPU measurement for either, and OpenAI does not publish how many vCPU each container size gets. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js loop at 4 vCPU / 8 GB.
Can OpenAI Containers or Google Agent Runtime run Docker?
No. OpenAI's hosted shell runs commands without sudo, and Google's sandboxes run as the unprivileged user appuser with images that must not need root. Neither documents Docker. bochka gives every sandbox root, systemd, Docker and /dev/kvm.
How long does a sandbox last on each?
An OpenAI container expires after 20 minutes without use and its data is discarded. A Google sandbox can live up to 7 days as a custom container or 14 days for Code Execution, and can pause in between. A bochka sandbox has no session cap on paid plans and keeps its disk when it stops.
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.
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.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs OpenAI Containers
- bochka vs Google Agent Runtime
- E2B vs OpenAI Containers
- Daytona vs OpenAI Containers
- Modal vs OpenAI Containers
- Vercel Sandbox vs OpenAI Containers
- Cloudflare Sandbox vs OpenAI Containers
- Blaxel vs OpenAI Containers
- Runloop vs OpenAI Containers
- Tensorlake vs OpenAI Containers
- Morph Cloud vs OpenAI Containers
- CodeSandbox SDK vs OpenAI Containers