bochka vs OpenAI Containers
OpenAI Containers are the short-lived boxes behind Code Interpreter and Hosted Shell: the model runs code there, then the box expires. bochka gives each agent a full VM with root, Docker and a disk that stays, that you can reach from outside and keep for as long as you want.
Where bochka stands out
A whole machine with root
A bochka sandbox is a full VM with root, systemd, Docker and /dev/kvm, so an agent can install system packages, run databases and start Android emulators. OpenAI's hosted shell runs commands without sudo on a fixed Debian 12 image, and no Docker or nested virtualization is documented.
A disk that stays
bochka saves the disk every minute and when the sandbox stops, and a stopped sandbox costs nothing and starts again with its files. An OpenAI container expires after 20 minutes without use, and all its data is discarded with no way to bring it back.
Reachable from outside, open to the internet
Each bochka sandbox has SSH, HTTPS URLs for up to 50 ports and raw TCP, so you can open the app an agent built or give a user a preview link. OpenAI containers accept no inbound connections, and Code Interpreter and Hosted Shell containers have no outbound access until an admin sets an allowlist.
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
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.
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 | OpenAI Containers: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent that installs packages, runs Docker and keeps a repo for days needs root and a disk that persists, which a container that expires after 20 idle minutes does not give. | 3rd cheapest of 367 $634 a month | 356th of 367, with limits $17,371 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs a disk that survives; an OpenAI container has to be touched every 20 minutes or it is deleted. | 5th cheapest of 366 $657 a month | 341st of 366, with limits $13,140 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month This is what OpenAI Containers are built for: the model writes Python and runs it in the same API call, with no machine to manage. | 186th of 345, with limits $2,000 a month | 194th of 345, with limits $6,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Your users can open a preview URL or SSH into a bochka sandbox; an OpenAI container has no inbound access at all, only the API. | Cheapest of 361 $209 a month | 361st of 361, with limits $3,780 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 | 191st of 360, with limits $30,000 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 | 360th of 364, with limits $5,760 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need Docker, root and open internet; OpenAI documents no Docker or root, and Code Interpreter and Hosted Shell containers also start with no internet. | 4th cheapest of 377 $86 a month | 345th of 377, with limits $1,728 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you SSH into and keep all month is what bochka is; OpenAI containers have no SSH and no persistent disk. | 18th cheapest of 368 $26 a month | 362nd of 368, with limits $1,051 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a hosted browser for computer use; bochka streams a full 60fps desktop you can embed, and OpenAI's runs inside the Agents API beta. | 6th cheapest of 369 $200 a month | 351st of 369, with limits $5,280 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month OpenAI's hosted browser is driven by its own Codex harness; on bochka you run Chromium on your machine and drive it with any agent or library. | 7th cheapest of 367 $200 a month | 328th of 367, with limits $1,440 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 | 328th of 346, with limits $1,755 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 | 311th of 338, with limits $35,100 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 | 308th of 360, with limits $870 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 | OpenAI Containers |
|---|---|---|
| What it is | A cloud VM you create, keep, stop and reach from outside | A sandbox tool the model uses inside OpenAI's API |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | A fully sandboxed virtual machine; hypervisor not named |
| Root, Docker and nested virtualization | Root, systemd, Docker and /dev/kvm on every machine | Commands do not run with sudo; no Docker or /dev/kvm documented |
| Machine size | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB | 1, 4, 16 or 64 GB of memory; vCPU not published (Agents API sandboxes: 1, 2 or 4 vCPU) |
| Files after the session | Disk saved every minute and on stop; a stopped sandbox costs nothing and comes back | Data is discarded when the container expires; Agents API keeps only files in /workspace/outputs |
| Lifetime | No session cap on paid plans; you set the time to live | Expires after 20 minutes without use; Agents API sandboxes after an hour without activity |
| Fork | Fork a running sandbox with its disk | No fork; templates save configuration, not a running workspace |
| Custom image | Named snapshots of a set-up machine, reused as templates | Fixed Debian 12 image; you upload files or skills into each container |
| Inbound access | SSH, HTTPS URLs for up to 50 ports, raw TCP | None; you reach the container only through the API |
| Outbound internet | Open internet on every plan; no provider-side allowlist | Code Interpreter and Hosted Shell: off until an admin sets an org domain allowlist. Agents API sandboxes: on by default, can be limited to 1 to 100 hosts |
| 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 | domain_secrets: a sidecar adds the real header for approved domains, the model sees a placeholder |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Agents API (beta) drives a managed Codex harness from outside, with steering, events and webhooks |
| Desktop and computer use | 60fps desktop and Chromium, computer use, embeddable stream | Hosted browser for the Agents API computer_use tool |
| Regions and your own compute | EU only (Germany, Finland, France) | US or EU processing for Code Interpreter; Agents API can also drive a sandbox you host |
| 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 | OpenAI Containers |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | No |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | No |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | Yes |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| 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: OpenAI Containers are not in the public CPU benchmark, and OpenAI does not publish how many vCPU each Responses container size gets. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. OpenAI Containers 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 | OpenAI Containers, 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 | $228 · API pay as you go · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $1,051 · API pay as you go · 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 | $11,405 · API 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,620 · API pay as you go · 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 | $6,000 · API pay as you go · with limits |
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.
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 separately on top. There is no plan fee; the scenarios use the 16 GB size for 8 GB needs and the 4 GB size for 4 GB needs, since vCPU is not published.
Limits in those scenarios
OpenAI Containers do not fit any of the five scenarios as written: they have no persistent disk and no Docker, Code Interpreter and Hosted Shell containers start with no internet, and the vCPU behind each size is not published. A container also expires after 20 minutes without use, so an agent that works all day or all month has to keep touching it or start over. OpenAI does not publish how many containers can run at once, so the 300 user sandboxes and the 1,000-job burst are unconfirmed. On bochka the burst is limited by starts per minute, so the $2,000 plan queues those starts.
| Scenario | bochka | OpenAI Containers |
|---|---|---|
| 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.
- Locked-down network by default. Useful if code must only reach chosen hosts: Code Interpreter and Hosted Shell have no outbound access until an admin allows domains.
- US processing and your own compute. Code Interpreter can process data in the US or Europe, and the Agents API can drive a sandbox on machines you run.
Use bochka when
your agent needs a real machine it keeps: root, Docker, a disk that persists, open internet and ports you can reach, with any coding agent built in.
- A whole machine with root. Most real repos need apt installs, a database in Docker or a service under systemd. Without root the agent stops at the first one, and the only way around it on OpenAI is a sandbox you host yourself.
- A disk that stays. An agent that pauses for a human review, or works over several days, loses its clone, its installs and its build cache when the container expires. Your code has to upload files again into a fresh container each time.
- Reachable from outside, open to the internet. An agent that builds a web app cannot show it to anyone from an OpenAI container, and in Code Interpreter or Hosted Shell every package registry or API it needs has to be added to the org allowlist first.
Questions people ask
Is bochka cheaper than OpenAI Containers?
In the scenarios on this page, yes: one coding agent on workdays comes to $20 a month on bochka and $228 on OpenAI, and one agent running all month comes to $26 versus $1,051. OpenAI also bills model tokens on top, and its containers do not fully fit these scenarios anyway, since they have no persistent disk or Docker.
Can I run Docker or install packages with sudo in an OpenAI container?
OpenAI's docs say hosted shell commands do not run with sudo, and no Docker support is documented. bochka gives you root, systemd, Docker and /dev/kvm on every sandbox.
How long does an OpenAI container last?
A container expires after 20 minutes without use, and its data is discarded and cannot be recovered. Agents API sandboxes can be deleted after an hour without activity. A bochka sandbox has no session cap on paid plans and keeps its disk when it stops.
Can I open a web app running inside an OpenAI container?
No. OpenAI containers have no ports, URLs or SSH; you reach them only through the API. bochka gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Can I use bochka with OpenAI models?
Yes. Codex is preinstalled in every bochka sandbox, and the credentials proxy lets the agent call the OpenAI API while your real key stays outside the 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.
Start a sandbox
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs exe.dev
- bochka vs Agent 37
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- 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