Fly.io Machines vs Docker Cloud Sandboxes

Fly.io Machines are microVMs for hosting your own apps in 17 regions, with no time limit but nothing for agents built in. Docker Cloud Sandboxes are microVMs made for coding agents, started from the sbx CLI, but each one ends 24 hours after it is created and you get 10 at a time by default.

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.

Kind of product: App hosting platform; Machines are its VM building block with a REST API
Isolation: Firecracker microVMs with hardware virtualization, on Fly's own servers
Regions: 17 regions in North America, Europe, Asia, Oceania, South America and Africa
CPU classes: Shared vCPUs guarantee 6.25% of each core with a burst balance; performance vCPUs get the full core
Storage: Root file system is ephemeral; one Volume of up to 500GB per Machine for lasting data
Free trial: 2 Machine hours or 7 days, up to 10 Machines of 2 vCPU / 4GB that stop after 5 minutes
Compliance: Lists SOC 2 Type II; a HIPAA package with a pre-signed BAA is sold as an add-on

Docker Cloud Sandboxes

Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.

Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.

Isolation: MicroVM per sandbox with its own Linux kernel and its own Docker Engine
Launched: September 24, 2026
Machine sizes: 1 vCPU / 2 GiB up to 16 vCPU / 32 GiB, CPU only, amd64 or arm64 by account
Session length: 1 hour by default, extendable to 24 hours from creation
Default quota: 10 concurrent and 50 stored sandboxes per account
Account: Pay-as-you-go plan on a personal Docker account, even inside an organization
Regions: Not published

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	Docker Cloud Sandboxes: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs many agents for days; Docker stops each sandbox at 24 hours and runs 10 at once by default, while Fly has no time limit but resets the root disk on restart, and bochka fits fully with Docker, /dev/kvm and a kept disk.	92nd of 367, with limits $836 a month	280th of 367, with limits $4,928 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 cannot do it in one Docker session, and on Fly it keeps only what sits on its one Volume; bochka keeps the whole disk.	125th of 366, with limits $816 a month	276th of 366, with limits $5,110 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 Short code runs suit both Fly and Docker better than bochka: per-second billing with no plan fee, and Docker can stop a sandbox with its memory between runs.	75th of 345, with limits $94 a month	119th of 345, with limits $233 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 Fly has no published cap on Machines but its API creates about one per second per app, while Docker's default of 10 concurrent sandboxes is too few to serve your users.	69th of 361, with limits $600 a month	136th of 361, with limits $1,628 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	114th of 360, with limits $7,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	167th of 364, with limits $1,400 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 keeps the CPU busy, which drains a shared Fly vCPU's burst balance; Docker allows only 10 jobs at once by default, and neither offers /dev/kvm for Android builds.	152nd of 377, with limits $288 a month	172nd of 377, with limits $672 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays on all month works on Fly with a Volume for lasting files, but not on Docker, whose sandboxes end 24 hours after creation.	118th of 368, with limits $53 a month	127th of 368, with limits $204 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 Docker ships a desktop: on Fly you build and stream one yourself, and Docker's sandboxes are terminal only, while bochka has a 60fps desktop with Chromium.	95th of 369, with limits $173 a month	268th of 369, with limits $1,400 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	277th of 367, with limits $700 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	262nd of 346, with limits $350 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 mass scraping better than Docker here: it can spread scrapers over 17 regions with no 10-at-once quota.	44th of 338, with limits $1,232 a month	190th of 338, with limits $7,000 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	248th of 360, with limits $350 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	Docker Cloud Sandboxes	bochka
Kind of product	App hosting platform; you boot your own image as a microVM	Cloud microVMs for coding agents, started from the sbx CLI	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	MicroVM with its own Linux kernel; hypervisor not named	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Session length	No documented maximum; a Machine runs until you or autostop stop it	1 hour by default, at most 24 hours from creation	No cap on paid plans; you set the time to live
Sandboxes at once	No published quota; the API creates about one Machine per second per app	10 by default; no published way to raise it	100 on the $20 plan, up to 2,000 on higher plans, self-serve
Docker, systemd and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered	Its own Docker Engine inside; agent runs as a non-root user with sudo; 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 all month	Stop keeps files and memory for free, but snapshots unused for 7 days are deleted	The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Memory on pause	Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move	Stop keeps memory and files; resume picks up where it left off	Resume reboots from disk (no memory snapshots)
Fork	Clone copies a Machine's config; a cloned Volume starts empty	Snapshot a running sandbox with disk or disk and memory, then restore it as a new one	Fork a running sandbox, disk included
Desktop and browser	None built in; you add them to your own image	Terminal sessions only	60fps Linux desktop with Chromium, computer use and browser control
Coding agents	None built in; you install and run agents yourself	Claude Code, Codex, Copilot, OpenCode and more, attached to from the sbx CLI	Seven agents preinstalled, with a prompt, steer and events API to drive them from outside
Keeping API keys out of the sandbox	Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself	Cloud proxy sets the auth header for built-in AI services and custom hosts; the sandbox sees a placeholder	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Reaching the sandbox	Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network between Machines	Public HTTPS URL per published port, not a TCP tunnel; SSH with Docker-issued certificates	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Allow and deny rules by host, with allow-all, balanced and deny-all presets	Open internet on every plan; no provider-side allowlist
Regions	17 regions on six continents	Not published	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Docker Cloud Sandboxes	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	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	Yes	Yes
Automatic snapshots	Yes	Yes	Yes
Fork/clone	Yes	Yes	Yes
Live fork (no pause)	Yes	Yes	Yes
Memory fork	No	Yes	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	No	No
Wake on request	Yes	Not published	No
HTTPS preview URLs	Yes	Yes	Yes
Raw TCP inbound	Yes	Not published	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	Yes	Yes
Agent harness API	No	No	Yes
MCP server	Yes	Yes	No
GPU	No	No	No
Windows	No	No	No
Arm64	No	Yes	No
Self-hosting	No	No	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	No	No
HIPAA	Yes	No	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

Docker Cloud SandboxesNot measured

bochka26.69 runs/s

There is no comparable measurement for either: neither Fly.io Machines nor Docker Cloud Sandboxes was in the public StarSling run, where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly's results would depend on its CPU class, since shared vCPUs guarantee only 6.25% of each core with a burst balance and performance vCPUs get the full core. Docker does not say what hardware it uses.

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 Docker Cloud Sandboxes 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	Docker Cloud Sandboxes, 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	$49 · Docker Agentic Platform (pay-as-you-go)	$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	$204 · Docker Agentic Platform (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	$2,464 · Docker Agentic Platform (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	$700 · Docker Agentic Platform (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	$1,400 · Docker Agentic Platform (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 here use Fly's lowest rate: shared vCPUs bought in 1-year reservation blocks for 40% off.

Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox, volumes and egress are free.

Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

Fly is marked a compromise in all five scenarios: it is an app platform, its lowest figures need a 1-year reservation, and its shared vCPUs guarantee only 6.25% of each core, so long builds get throttled. Docker fits one agent on workdays, but its 24-hour cap rules out an agent that never stops, and its default of 10 concurrent sandboxes rules out 50 agents, sandboxes for your users and 1,000 short jobs at once. bochka fits four of the five; its start limits queue the 1,000-job burst even on the $2,000 plan.

Scenario	Fly.io Machines	Docker Cloud Sandboxes	bochka
One coding agent, workdays	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	None that bite	None that bite
One agent that never stops	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Docker Agentic Platform (pay-as-you-go): sessions capped at 24 h	None that bite
50 agents in parallel	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Docker Agentic Platform (pay-as-you-go): max 10 concurrent	None that bite
Sandboxes for your users	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Docker Agentic Platform (pay-as-you-go): max 10 concurrent	None that bite
1,000 short jobs at once	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	Docker Agentic Platform (pay-as-you-go): max 10 concurrent	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

Use Fly.io Machines when

you host apps or services that must run near users around the world, stay up as long as you like and wake on traffic, and you are happy to build the agent tooling yourself.

No clock on a Machine. For work that must keep running: a Fly Machine has no documented time limit, while a Docker sandbox ends 24 hours after creation.
17 regions worldwide. For users outside one region: Fly runs Machines in 17 regions on six continents, while Docker does not say where its sandboxes run.
A full app platform around each VM. For hosting real services: Fly Proxy wakes Machines on traffic, with raw TCP, Anycast IPs, custom domains and a private network.

Use Docker Cloud Sandboxes when

you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, with memory kept across stops and outbound rules by host.

Coding agents ready to run. For developers who want Claude Code or Codex in a sandbox today: sbx starts them with Docker inside, no image to build.
Stop and fork with memory. For agents that pause between steps: a stopped sandbox comes back with its memory, and a running one can be forked with it.
The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move a sandbox either way.

Where bochka fits

Fly gives you a fast VM for your own app and leaves the agent parts to you, and Docker gives you agents ready to run but only for a day and 10 at a time. If what you are running is agents that work for hours or days, many at once, look at bochka: a full VM per agent with a kept disk, a desktop, and an API to drive the agents inside.

Runs for days with its whole disk

A Docker sandbox ends 24 hours after creation, so your code must stop and resume long tasks. A Fly Machine keeps only its one Volume, billed for its full size. bochka has no session cap and keeps the whole disk.

A whole machine, screen included

Neither Fly nor Docker offers /dev/kvm, so Android emulators and nested VMs are out, and neither has a desktop. On Fly you build and stream one yourself; on Docker you add a separate browser service. bochka ships both.

Drive agents inside from outside

On Fly you install the agents and write the code that starts and watches them. On Docker you attach to a terminal and parse its text. bochka has a prompt, steer and events API, plus a keys proxy for any HTTPS API.

Use bochka when your agents run for days or by the dozen, need Docker, emulators, a desktop or a browser on a full VM whose disk survives every stop, and have to be driven from your own app through an API. Compare it one to one: bochka vs Fly.io Machines and bochka vs Docker Cloud Sandboxes.

Questions people ask

Is Fly.io Machines cheaper than Docker Cloud Sandboxes?

On Fly's cheapest rate, yes: one agent on workdays is $15 a month on Fly against $49 on Docker, and one agent running all month is $36 against $204. Fly's figures need a 1-year reservation and assume work that stays within a shared vCPU's 6.25% baseline. On bochka the same two are $20 and $26.

Which is faster, Fly.io Machines or Docker Cloud Sandboxes?

Neither has a comparable public benchmark, so there is no fair speed ratio. On Fly, speed depends on whether you pick shared or performance vCPUs. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.

Can I run Docker inside Fly Machines and Docker Cloud Sandboxes?

Yes on both. A Docker cloud sandbox comes with its own Docker Engine, and on a Fly Machine you install Docker yourself as root. Neither offers /dev/kvm for Android emulators or nested VMs; bochka has Docker, systemd and /dev/kvm on every machine.

Can either run longer than 24 hours?

A Fly Machine has no documented time limit and runs until it is stopped. A Docker cloud sandbox ends one hour after creation by default and can be extended to at most 24 hours. bochka has no session cap on paid plans.

How many can I run at once?

Docker allows 10 concurrent and 50 stored sandboxes per account by default, with no published way to raise it. Fly publishes no such quota, but its API creates about one Machine per second per app. bochka's $20 plan runs 100 at once, and higher plans go up to 2,000.

Do they keep my files when they stop?

Docker keeps files and memory on stop, but snapshots unused for 7 days are deleted. A Fly Machine's root file system is ephemeral, so only its one Volume lasts. bochka keeps the whole disk, with snapshots every minute and on stop.

Try bochka

Install the CLI, then run bochka new.

Product preview