Fly.io Machines vs Namespace

Fly.io Machines are microVMs for hosting your own apps near users, in 17 regions, with wake on request. Namespace is a build and dev platform: fast GitHub Actions runners with caches, plus Devboxes on Linux, macOS and Windows that stop after 4 to 24 hours.

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

Namespace

Namespace is a dev platform for fast builds, tests and coding environments: CI runners, build caches and Devboxes, on its own hardware.

Most of Namespace is CI: a faster drop-in for GitHub Actions runners, with Docker, Bazel, Turborepo and Nix caching. Its Devboxes are remote Linux and macOS machines with persistent storage, made for people and AI coding agents, and they also host sessions for Claude Managed Agents, Cursor Cloud Agents and Devin. It is a different kind of product from bochka, so this page compares the part where they overlap: a machine an agent works on.

Products: GitHub Actions runners, Docker, Bazel, Turborepo and Nix caching, Devboxes, and a compute API
Hardware: Its own hardware in its own racks: AMD EPYC for Linux and Windows, Apple M4 Pro or M5 Max for macOS
Linux Devboxes: Run from a container image you choose and include Docker; the docs do not say whether each one has its own kernel
Devbox time limit: 4 hours on Developer, 5 on Team, 24 on Business, even while you are working
Customers: Says 1,000+ companies, including Ramp, ElevenLabs, Zed and Vanta
Funding: Announced a $42M Series B
Compliance: Trust center lists SOC 2 Type II

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	Namespace: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Namespace ranks above Fly here, but both are a compromise: Fly resets the root disk on restart and Namespace stops Devboxes after at most 24 hours, while bochka fits fully with Docker, /dev/kvm and a kept disk.	92nd of 367, with limits $836 a month	39th of 367, with limits $3,495 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops is hard on both: Namespace shuts a Devbox down after at most 24 hours, and a Fly Machine keeps only what sits on its one Volume; bochka has no session cap on paid plans.	125th of 366, with limits $816 a month	303rd of 366, with limits $6,645 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 fits short bursts best of the three here, with per-second billing, no plan fee and cheap shared CPU for code that mostly waits.	75th of 345, with limits $94 a month	247th of 345, with limits $250 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	69th of 361, with limits $600 a month	284th of 361, with limits $2,068 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	356th of 360, with limits $9,012 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	282nd of 364, with limits $1,043 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 Namespace fits CI fully, since runners with Docker, Bazel and Turborepo caches are its main product; shared Fly vCPUs get throttled by long busy builds.	152nd of 377, with limits $288 a month	80th cheapest of 377 $765 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB	118th of 368, with limits $53 a month	126th of 368, with limits $168 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 Namespace's screenshot and click API works on macOS Devboxes only and Fly has no desktop at all; bochka streams a 60fps Linux desktop with Chromium.	95th of 369, with limits $173 a month	67th of 369, with limits $982 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	285th of 367, with limits $789 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	259th of 346, with limits $332 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 ranks highest of the three 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	226th of 338, with limits $9,012 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	242nd of 360, with limits $339 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 None of the three fits: Fly discontinued GPU Machines, and Namespace and bochka sell CPU machines only.	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 Only Namespace fits: it runs macOS on Apple Silicon, and neither Fly nor bochka offers macOS.	Can't run it	6th cheapest of 36 $1,205 a month	Can't run it

Key features

Feature	Fly.io Machines	Namespace	bochka
Kind of product	App hosting platform; Machines are its microVM building block with a REST API	CI and dev platform: GitHub Actions runners, build caches, Devboxes and a compute API	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	Linux Devboxes run from a container image on Namespace's own hardware; the docs do not say if each has its own kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X (Zen 5) hosts
CPU speed (Node.js build-and-test, 4 vCPU / 8 GB)	Not measured; shared vCPUs guarantee 6.25% of a core, performance vCPUs the full core	21.79 runs/s	26.69 runs/s
Docker and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; no /dev/kvm	Docker in Linux Devboxes; /dev/kvm on Linux compute instances	Docker, root, systemd and /dev/kvm on every machine
How long a session can run	No documented limit; a Machine runs until it is stopped	Devboxes stop after 4, 5 or 24 hours by plan, raisable to 24 at most	No session cap on paid plans
Files after a stop	Root file system is ephemeral; lasting data goes on one Volume, billed for its full size around the clock	A stopped Devbox keeps its storage, billed at $0.20 per GB-month used	The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Pause and fork	Suspend keeps memory for Machines up to 2GB; a clone copies config with an empty Volume	No fork; compute instances can suspend and resume with RAM kept	Fork a running sandbox, disk included; resume reboots from disk
Idle stop and wake	Fly Proxy stops or suspends idle Machines and wakes them when a request arrives	Devboxes stop after an idle timeout and start again when you connect	Machines run until you stop them through the API
Desktop and computer use	None built in; you add a desktop and browser to your own image	Screenshot and click API on macOS Devboxes only; VNC and RDP for compute instances	60fps Linux desktop and Chromium, computer use and browser control, embeddable stream
Coding agents	None built in; you install and run agents yourself	Hosts Claude Managed Agents, Cursor and Devin sessions run through those partners; an MCP server for your own agent	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API
Keeping keys out of the sandbox	Secrets arrive as environment variables; an open-source tokenizer proxy you deploy yourself	Egress rules inject a header from Namespace Vault, resolved outside the workload	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	HTTPS URLs that need a Namespace login, TCP through a CLI port-forward; no public IP	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Egress policies by domain: block, advisory or allow	Open internet on every plan; no provider-side allowlist
Operating systems and regions	Linux only, in 17 regions on six continents	Linux, macOS on Apple Silicon, and Windows on Team plans and up	Linux only, with Wine for Windows apps; EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Namespace	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	Yes	Yes
Root	Yes	Yes	Yes
Systemd	No	Not published	Yes
Desktop GUI	No	Yes	Yes
Browser	No	No	Yes
Computer-use API	No	Yes	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	Yes	Yes
Automatic snapshots	Yes	Yes	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	Yes	No
HTTPS preview URLs	Yes	Yes	Yes
Raw TCP inbound	Yes	Yes	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	Yes	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	Yes	Yes
Usage per sandbox (API)	No	No	Yes
Audit logs	Not published	Yes	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

Fly.io MachinesNot measured

Namespace21.79 runs/s

bochka26.69 runs/s

In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Namespace did 21.79, so the same build takes about a fifth longer on Namespace. Fly.io Machines were not part of that run, so there is no comparable score; Fly's results would depend on whether you pick shared vCPUs, which guarantee 6.25% of a core, or performance vCPUs.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Namespace measured on: Linux compute instance (unit-minutes, PAYG/overage $0.0015). Fly.io Machines 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	Fly.io Machines, a month	Namespace, 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	$50 · Devbox (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	$176 · Devbox (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,198 · Devbox (pay as you go)	$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,214 · Devbox (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	$232 · Pay As You Go · with limits	$3,237 · Devbox (pay as you go)	$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.

Namespace: Devboxes are billed in Devbox Minutes at $0.004 each, pay as you go on every plan, and a 4 vCPU / 8 GB Devbox uses one a minute. The minutes in the Team and Business plans cover runners and instances, not Devboxes, and stored files cost $0.20 per GB-month.

Namespace: 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 marked a compromise in every scenario: its lowest figures need a 1-year reservation and use shared vCPUs that guarantee only 6.25% of each core, so long builds get throttled. Namespace fits most scenarios, but a Devbox is shut down after at most 24 hours, so the agent that never stops has to restart at least once a day, and Namespace does not publish an egress price. On bochka the 1,000 short jobs at once get queued by start limits, even on the $2,000 plan.

Scenario	Fly.io Machines	Namespace	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	egress price not published	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	sessions end after 24 h: needs restarts to run 24/7 egress price not published	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	egress price not published	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	egress price not published	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	egress price not published	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 web apps or light services that must run near users worldwide, sleep between requests and wake on traffic.

17 regions worldwide. Useful if your users are outside Europe: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
Wake on request. Useful for services that sleep between requests: Fly Proxy wakes a Machine when traffic arrives, and small Machines resume with memory kept.
A full app platform. Useful if you host whole apps: Fly adds public IPs, custom domains, private networking and port-level rules around each Machine.

Use Namespace when

you need faster GitHub Actions runners with build caches, or macOS and Windows machines for builds and tests.

macOS and Windows. Useful if you build iOS or Mac apps or test on Windows: Namespace runs macOS on Apple Silicon and Windows machines.
CI runners and build caches. Useful if you want faster GitHub Actions: Namespace is a drop-in runner with Docker, Bazel and Turborepo caching.
Egress rules by domain. Useful if agents must reach only chosen domains: Namespace can block all outbound traffic except the ones you allow.

Where bochka fits

Neither Fly.io Machines nor Namespace is built mainly as an agent sandbox: Fly hosts apps, and Namespace runs CI and dev boxes. If what you are really running is agents that install, build and test for hours, bochka gives each one a full VM with a kept disk, no session cap, a desktop and coding agents built in.

A disk that keeps everything, and no clock

A Fly Machine's root disk is ephemeral, so tools and caches outside its one Volume can vanish on restart. A Namespace Devbox is shut down after at most 24 hours, even mid-task. bochka keeps the whole disk and has no session cap.

A full VM with /dev/kvm, systemd and speed

Fly has no /dev/kvm or systemd, and its cheap shared vCPUs get throttled on long builds. Namespace's Devboxes run from a container image and did 21.79 runs/s against bochka's 26.69 in the same test.

Desktop and agents driven from outside

Fly has no desktop or agents, so you build and maintain the image yourself. Namespace's click API is macOS only and agents run through partners. bochka ships a 60fps Linux desktop and coding agents with a prompt, steer and events API.

Use bochka when your agents work on Linux for hours or days: a full, faster VM whose disk survives every stop, with no session cap, Docker and /dev/kvm, a 60fps desktop and coding agents you drive from outside. Compare it one to one: bochka vs Fly.io Machines and bochka vs Namespace.

Questions people ask

Is Fly.io Machines cheaper than Namespace?

In the scenarios we priced, yes, using Fly's cheapest rate of shared vCPUs on a 1-year reservation. One agent on workdays is $15 a month on Fly and $50 on Namespace, and 50 agents in parallel are $487 versus $2,198. Fly's figures assume work that stays within a shared vCPU's 6.25% baseline; bochka comes to $20 and $317 for the same two.

Which is faster, Fly.io Machines or Namespace?

Only Namespace was measured: 21.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public run, against bochka's 26.69. Fly.io Machines were not in that run, and their speed depends on whether you pick shared or performance vCPUs.

Can Fly.io Machines and Namespace run Docker?

Yes, both. On Fly you install Docker in your own image, and there is no /dev/kvm for nested VMs. Namespace Linux Devboxes include Docker, and its Linux compute instances offer /dev/kvm. bochka has Docker, systemd and /dev/kvm on every machine.

How long can a session run on each?

Fly documents no maximum runtime for a Machine. A Namespace Devbox is shut down after 4, 5 or 24 hours by plan, even while you work in it. bochka has no session cap on paid plans.

Do they keep my files when a machine stops?

On Fly, only what is on the one Volume a Machine can mount; the root file system is ephemeral. A stopped Namespace Devbox keeps its storage at $0.20 per GB-month used. bochka keeps the whole disk, with snapshots every minute and on stop.

Which one runs macOS?

Namespace runs macOS Devboxes and instances on Apple Silicon, and Windows on Team plans and up. Fly.io Machines and bochka run Linux only.

Try bochka

Install the CLI, then run bochka new.

Product preview