Fly.io Machines vs Ona
Fly.io Machines are fast microVMs for hosting your own apps near users, billed per second with no plan fee. Ona, formerly Gitpod and now part of OpenAI, gives engineers and its Codex agent cloud dev environments, sold through sales and run in your own AWS or GCP account.
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.
Ona
Ona, formerly Gitpod, is a platform for cloud dev environments and background coding agents, and is now part of OpenAI.
Ona is a different kind of product from bochka: a dev-environment platform, not a sandbox API. Each task or developer gets an isolated VM built from a Dev Container config, which people open in a browser IDE, VS Code or JetBrains, and where Ona's Codex Agent can plan, code, test and open pull requests. It is built for engineering teams who want the same governed environment for every developer and agent; new customers run it in their own AWS or GCP account on an Enterprise contract.
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 | Ona: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither fits fully: a Fly Machine resets its root disk on restart and Ona's SDK is Enterprise only, while bochka gives each agent a full VM with Docker, /dev/kvm and a desktop. | 92nd of 367, with limits $836 a month | 324th of 367, with limits $7,315 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant on Ona needs auto-stop set to Never, since background work does not count as activity; on Fly it keeps only what sits on its one Volume. | 125th of 366, with limits $816 a month | 83rd of 366, with limits $8,504 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 Fly suits short bursts best of the three: per-second billing with no plan fee and cheap shared CPU for code that mostly waits. | 75th of 345, with limits $94 a month | 335th of 345, with limits $5,320 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 Ona is built for your own engineers, with a default of 10 running environments per user; Fly can host one VM per user but creates about one Machine per second per app. | 69th of 361, with limits $600 a month | 330th of 361, with limits $5,988 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 | 283rd of 360, with limits $9,773 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 | 334th of 364, with limits $5,768 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 keep the CPU busy, which drains a shared Fly vCPU's burst balance; Ona starts each run from a prebuild, and bochka can fork a warm machine instead. | 152nd of 377, with limits $288 a month | 365th of 377, with limits $5,461 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Ona is a full cloud IDE with Dev Containers and prebuilds, a good dev box if you can buy Enterprise; bochka is a full VM you reach over SSH, HTTPS or a desktop. | 118th of 368, with limits $53 a month | 368th of 368, with limits $5,140 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 Neither Fly nor Ona has a graphical desktop to drive, while bochka streams a 60fps desktop with Chromium for computer use. | 95th of 369, with limits $173 a month | 353rd of 369, with limits $5,691 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 | 150th of 367, with limits $5,346 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 | 146th of 346, with limits $5,468 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 does well here: it can spread scrapers across 17 regions and pay only for the seconds they run. | 44th of 338, with limits $1,232 a month | 261st of 338, with limits $14,360 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 | 93rd of 360, with limits $5,228 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 | Ona | bochka |
|---|---|---|---|
| Kind of product | App hosting platform; you boot your own Docker image as a microVM | Cloud dev environment platform for engineers and its Codex agent | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Firecracker microVM with its own kernel, on Fly's own servers | Isolated VM per environment with dedicated compute, built from a Dev Container config | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X (Zen 5) hosts |
| Docker, systemd and nested virtualization | Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered | Docker and root inside the Dev Container; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Files after a stop | Root file system is ephemeral; lasting data goes on one Volume, billed for its full size around the clock | Disk persists across stops; in your own cloud its storage is billed while stopped; Core archives a stopped environment after 3 days | The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing |
| Fork | Clone copies a Machine's config; a cloned Volume starts empty | No environment copy; you can create a project from an environment's config | Fork a running sandbox, disk included |
| Starting point | Any Docker image you build | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Idle, wake and suspend | Fly Proxy stops or suspends idle Machines and wakes them on a request; suspend keeps memory up to 2GB | Stops after 30 minutes without SSH, IDE or agent activity by default; background work does not count; can be set to Never | Runs until you stop it, no session cap on paid plans; resume reboots from disk |
| Driving it from code | Machines REST API on pay as you go | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK on every plan, including the trial |
| Coding agents | None built in; you install and run agents yourself | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | 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 own image | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Keeping keys out of the sandbox | Secrets arrive as environment variables; Fly's open-source tokenizer proxy you deploy yourself | Secrets are injected as environment variables or files | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the sandbox | HTTPS and TCP services through Fly Proxy, Anycast IPs, custom domains, private network between Machines | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| GPUs | GPU Machines discontinued from 2026-08-01 | GPU instance types on Enterprise runners in your own cloud, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
| Regions | 17 regions on six continents | Enterprise runners in your own AWS or GCP account, in many regions | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Fly.io Machines | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | Yes | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | No | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | 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 Ona were not in the public StarSling run where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly results would depend on the CPU class, since shared vCPUs guarantee only 6.25% of a core with a burst balance and performance vCPUs get the full core.
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 Ona 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 | Ona, 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 | $5,030 · Enterprise (AWS Marketplace 12-month contract) · 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 | $5,140 · Enterprise (AWS Marketplace 12-month contract) · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · 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 | $5,955 · Enterprise (AWS Marketplace 12-month contract) · 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 here use Fly's lowest rate: shared vCPUs bought in 1-year reservation blocks for 40% off.
Ona: New Core subscriptions are closed, so Ona's figures use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract (about $5,000 a month), plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: 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
Both show as a compromise in every scenario. Fly's lowest figures need a 1-year reservation and use shared vCPUs that guarantee 6.25% of each core, so long builds get throttled, and its API creates about one Machine per second per app. Ona can only be bought as Enterprise through sales, and since it publishes no concurrency limit the table assumes 3 environments at once, so 50 agents, 300 user sandboxes and 1,000 short jobs do not fit. 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 | Ona | 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 host web apps or light services that must run near users worldwide, sleep between requests and wake on traffic.
- Sign up and pay per second. Useful if you want to start today: Fly is self-serve, billed per second with no plan fee, while new Ona customers go through sales.
- 17 regions and wake on request. Useful for services near users worldwide that sleep between requests: Fly Proxy wakes a Machine when traffic arrives.
- A full app platform. Useful if you host whole apps: Fly adds Anycast IPs, custom domains, raw TCP, private networking and port-level network policies.
Use Ona when
your engineers want a governed cloud IDE shared with a Codex agent, inside your own AWS or GCP account or with a GPU.
- A full cloud IDE for your team. Useful if engineers work in the same environments as their agents: Ona has browser, VS Code and JetBrains IDEs with prebuilds.
- Runs in your own cloud. Useful if environments must live inside your own AWS or GCP account: Ona's Enterprise runners provision them there.
- GPU environments. Useful if your agents need a GPU: Ona's Enterprise runners can use GPU instance types, while Fly has discontinued its GPU Machines.
Where bochka fits
Fly.io Machines are built for hosting apps and Ona for engineers working in a cloud IDE. If what you are really running is agents that install, build and test for hours, bochka gives each one a full VM that keeps its disk, a desktop, coding agents and an API on every plan. Look at bochka if you would otherwise build that sandbox yourself on Fly, or buy an Enterprise contract on Ona to get an SDK.
A disk that keeps everything
A Fly Machine's root disk is ephemeral, so an agent's tools and caches must sit on a Volume billed for its full size. Ona keeps the disk, but bills it in your cloud while stopped, and Core archives it after 3 days.
A full VM with /dev/kvm and a desktop
Neither Fly nor Ona documents /dev/kvm, so Android emulators and nested VMs have nothing to run on. Neither has a graphical desktop, so on Fly you build and stream one yourself, and on Ona computer-use agents have no screen.
Fork a running agent, drive it from outside
A Fly clone gets an empty Volume and Ona has no environment copy, so every parallel attempt rebuilds from an image or prebuild. bochka forks the warm machine and lets you prompt, steer and watch Claude Code, Codex and others through one API.
Use bochka when your code starts and drives the agents: full VMs with /dev/kvm, a desktop and open ports, disks that survive every stop, forks of running machines and an API on every plan. Compare it one to one: bochka vs Fly.io Machines and bochka vs Ona.
Questions people ask
Is Fly.io Machines cheaper than Ona?
Yes, by a wide margin in every scenario we priced. One coding agent on workdays is $15 a month on Fly and $5,030 on Ona ($20 on bochka), and 50 agents in parallel are $487 against $6,521 ($317 on bochka). Fly's figures use shared vCPUs on a 1-year reservation, and Ona's use its Enterprise listing on AWS Marketplace.
Which is faster, Fly.io Machines or Ona?
Neither has a comparable public measurement, so we cannot say. On Fly it depends on the CPU class: shared vCPUs guarantee 6.25% of a core and get throttled under long load, while performance vCPUs get the full core. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run.
Can Fly.io Machines or Ona run Docker?
Both can. On Fly you install Docker yourself inside the microVM, and Ona gives you Docker and root inside the Dev Container. Neither documents /dev/kvm, so nested VMs and Android emulators are out; bochka has Docker, systemd and /dev/kvm on every machine.
Do they keep my files when they stop?
A Fly Machine keeps only what is on its one Volume, since its root file system is ephemeral. Ona keeps the disk across stops, but Core archives a stopped environment after 3 days and Enterprise bills the disk in your cloud. bochka keeps the whole disk, with snapshots every minute and on stop.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025, and Ona is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales.
Can I use either as an AI agent sandbox?
You can, with work. On Fly you package the tools, browser and agents into an image, add a Volume and write the code that drives them; on Ona the managed agent is Codex and the SDK is Enterprise only. bochka ships all of that in every machine.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Fly.io Machines
- bochka vs Ona
- 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