Fly.io Machines vs OpenAI Containers
Fly.io Machines are microVMs you build, keep and host apps on, in 17 regions. OpenAI Containers are short-lived boxes inside OpenAI's API where the model runs code, then the box expires after 20 minutes without use.
The companies and products
Fly.io Machines
Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.
A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.
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. “92nd cheapest of 367” means 91 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 | Fly.io Machines: price rank | OpenAI Containers: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs root, Docker and a disk that stays: Fly gives root and a Volume you set up, OpenAI gives neither, and bochka has all of it on every machine. | 92nd of 367, with limits $836 a month | 356th of 367, with limits $17,371 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that runs all month needs a machine that stays up; a Fly Machine can, an OpenAI container is deleted after 20 idle minutes, and bochka keeps its whole disk. | 125th of 366, with limits $816 a month | 341st of 366, with limits $13,140 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 OpenAI Containers are built for this, since the model runs its code in the same API call; Fly is cheaper per run but you build the sandbox yourself. | 75th of 345, with limits $94 a month | 194th of 345, with limits $6,000 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 Users can open a URL on a Fly Machine or a bochka sandbox; an OpenAI container has no inbound access, only the API. | 69th of 361, with limits $600 a month | 361st of 361, with limits $3,780 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 | 48th of 360, with limits $2,838 a month | 191st of 360, with limits $30,000 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 | 117th of 364, with limits $457 a month | 360th of 364, with limits $5,760 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 needs Docker and open internet: Fly lets you install Docker but throttles shared vCPUs under long loads, and OpenAI documents no Docker and starts with no internet. | 152nd of 377, with limits $288 a month | 345th of 377, with limits $1,728 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Fly Machines and bochka both offer SSH into a machine you keep; OpenAI containers have no SSH and no persistent disk. | 118th of 368, with limits $53 a month | 362nd of 368, with limits $1,051 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 OpenAI's Agents API has a hosted browser for computer use, Fly has none built in, and bochka streams a 60fps desktop with Chromium you can embed. | 95th of 369, with limits $173 a month | 351st of 369, with limits $5,280 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 | 160th of 367, with limits $90 a month | 328th of 367, with limits $1,440 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 | 161st of 346, with limits $67 a month | 328th of 346, with limits $1,755 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 Fly fits wide scraping better than OpenAI, with 17 regions and open internet, where OpenAI containers need an admin allowlist for every domain. | 44th of 338, with limits $1,232 a month | 311th of 338, with limits $35,100 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 | 118th of 360, with limits $63 a month | 308th of 360, with limits $870 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 | Fly.io Machines | OpenAI Containers | bochka |
|---|---|---|---|
| What it is | App hosting platform; you boot your own image as a microVM through a REST API | A sandbox tool the model uses inside OpenAI's API | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Firecracker microVM with its own kernel | A fully sandboxed virtual machine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | Root, and Docker you install yourself; Fly's own init, no systemd; no /dev/kvm | Commands do not run with sudo; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every machine |
| Files after a stop | Root file system is ephemeral; one Volume per Machine, billed for its full size around the clock | Data is discarded when the container expires | Whole disk saved every minute and on stop; a stopped sandbox costs nothing |
| Lifetime | No documented cap; a Machine runs until you or autostop stop it | Expires after 20 minutes without use; Agents API sandboxes after an hour without activity | No session cap on paid plans; you set the time to live |
| Pause and memory | Suspend keeps memory for Machines up to 2GB | No pause or snapshots | Resume reboots from disk (no memory snapshots) |
| Fork | Clone copies a Machine's config; a cloned Volume starts empty | No fork | Fork a running sandbox, disk included |
| Custom image | Any Docker image you build | Fixed Debian 12 image; you upload files or skills into each container | Named snapshots of a set-up machine, reused as templates |
| Inbound access | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network | None; you reach the container only through the API | SSH, HTTPS URLs for up to 50 ports, raw TCP |
| Outbound internet | Open by default; network policies can allow chosen ports and protocols | Code Interpreter and Hosted Shell: off until an admin sets a domain allowlist | Open internet on every plan; no provider-side allowlist |
| Keeping API keys out of the sandbox | Secrets arrive as environment variables; open-source tokenizer proxy you deploy yourself | domain_secrets: a sidecar adds the real header, the model sees a placeholder | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | None built in; you install and run agents yourself | Agents API (beta) drives a managed Codex harness from outside | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | None built in; you add a desktop and browser to your image | Hosted browser for the Agents API computer_use tool | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Regions | 17 regions on six continents | US or EU processing for Code Interpreter; Agents API in the US | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Fly.io Machines | OpenAI Containers | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | No | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | No | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | No | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | 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 either: Fly.io Machines and OpenAI Containers were not part of the public StarSling run where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly's shared vCPUs guarantee only 6.25% of a core with a burst balance, and OpenAI does not publish how many vCPU each container size gets.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Fly.io Machines and OpenAI Containers 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 | Fly.io Machines, a month | OpenAI Containers, 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 | $15 · Pay As You Go · with limits | $228 · API pay as you go · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $36 · Pay As You Go · with limits | $1,051 · API pay as you go · with limits | $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 | $487 · Pay As You Go · with limits | $11,405 · API 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 | $110 · Pay As You Go · with limits | $1,620 · API pay as you go · with limits | $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 | $232 · Pay As You Go · with limits | $6,000 · API pay as you go · with limits | $2,000 · $2000/mo · with limits |
Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee; Volumes are billed for their full size all month. The figures use Fly's lowest rate: shared vCPUs on a 1-year reservation.
OpenAI Containers: OpenAI bills each container by the minute for the memory size you pick, with a 5-minute minimum, and model tokens are billed on top. The scenarios use the 16 GB size for 8 GB needs and 4 GB for 4 GB needs.
OpenAI Containers: 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
Fly is a compromise in every scenario: its lowest figures need a 1-year reservation, and shared vCPUs that guarantee 6.25% of each core get throttled under long builds. OpenAI Containers fit none of the scenarios as written, with no persistent disk, no Docker, no internet until an admin allows domains, and an unpublished vCPU count. OpenAI also does not publish how many containers can run at once, so 300 user sandboxes or 1,000 jobs at once are unconfirmed. On bochka the 1,000-job burst is limited by starts per minute and per day, so it gets queued even on the $2,000 plan.
| Scenario | Fly.io Machines | OpenAI Containers | 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 Fly.io Machines when
you want your own image on a microVM that serves traffic near users worldwide, and you are fine building the sandbox parts yourself.
- A machine you build and keep. Useful if you need your own image: Fly boots any Docker image with root, SSH and a Volume, and keeps it running.
- Reachable and open to the internet. Useful if code must serve traffic or call outside APIs: Fly gives public HTTPS, TCP and open outbound access.
- 17 regions worldwide. Useful if users sit outside Europe: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
Use OpenAI Containers when
your app already calls OpenAI models and the model only needs to run short pieces of code 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 run or clean up. Useful for short jobs: OpenAI creates the container, bills it by the minute and lets it expire on its own.
- 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.
Where bochka fits
Neither is an agent sandbox: Fly.io Machines are an app platform, and OpenAI Containers are a code tool for the model. If what you are really running is agents that work for hours, bochka gives each one a full VM with root, Docker, a disk that stays and a desktop, ready to use.
A disk that keeps everything
An agent leaves clones, installs and caches all over its disk. On Fly only the one Volume survives a restart, billed even while stopped; an OpenAI container deletes it all after 20 idle minutes. bochka saves the whole disk every minute.
Root, Docker and /dev/kvm
Real repos need apt installs, Docker and services under systemd. OpenAI runs commands without sudo and documents no Docker; Fly has root but its own init, no systemd and no /dev/kvm for emulators.
Agents and a desktop built in
On Fly you build the image with the browser and agents, then write the code that drives them. OpenAI's managed harness is Codex only, in beta. bochka ships Claude Code, Codex and a 60fps desktop, driven from outside.
Use bochka when your agents do real work for hours: root, Docker and /dev/kvm on a full VM whose disk survives every stop, with coding agents, a desktop and a keys proxy built in. Compare it one to one: bochka vs Fly.io Machines and bochka vs OpenAI Containers.
Questions people ask
Is Fly.io Machines cheaper than OpenAI Containers?
In every scenario on this page, yes. One coding agent on workdays is $15 a month on Fly and $228 on OpenAI, and one agent running all month is $36 versus $1,051, before OpenAI's model tokens. Fly's figures use shared vCPUs on a 1-year reservation; bochka is $20 and $26 for the same two.
Which is faster?
Neither has a comparable CPU measurement. Fly's shared vCPUs guarantee 6.25% of a core plus bursts, and its performance vCPUs get the full core at a higher rate. OpenAI does not publish the vCPU behind each container size. bochka did 26.69 runs per second on the StarSling Node.js benchmark.
Can Fly.io Machines or OpenAI Containers run Docker?
You can install and run Docker inside a Fly Machine yourself, since it is a microVM with root, but there is no /dev/kvm for nested VMs. OpenAI's docs say shell commands do not run with sudo, and no Docker support is documented. bochka has Docker, systemd and /dev/kvm on every machine.
Do they keep my files?
A Fly Machine keeps only what is on its one Volume; the root file system is ephemeral. An OpenAI container discards its data when it expires after 20 minutes without use. bochka keeps the whole disk, with snapshots every minute and on stop.
Can I open a web app running inside them?
On Fly, yes: Fly Proxy gives public HTTPS and TCP, Anycast IPs and custom domains. OpenAI containers have no ports, URLs or SSH. bochka gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Where does my data run?
Fly runs Machines in 17 regions worldwide. OpenAI's Code Interpreter processes data in the US or Europe, and the Agents API supports data residency only in the US. 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 Fly.io Machines
- bochka vs OpenAI Containers
- E2B vs Fly.io Machines
- Daytona vs Fly.io Machines
- Modal vs Fly.io Machines
- Vercel Sandbox vs Fly.io Machines
- Cloudflare Sandbox vs Fly.io Machines
- Blaxel vs Fly.io Machines
- Runloop vs Fly.io Machines
- Tensorlake vs Fly.io Machines
- Morph Cloud vs Fly.io Machines
- CodeSandbox SDK vs Fly.io Machines