Fly.io Machines vs exe.dev

Fly.io Machines are fast microVMs for hosting your own apps near users, with a root disk that resets and one Volume for data that must last. exe.dev rents ready Linux VMs with root, systemd, Docker and coding agents, whose whole disk stays between runs.

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

exe.dev

exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.

You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.

Company: Bold Software, Inc.
Isolation: KVM VMs on rented bare-metal servers, using Cloud Hypervisor
Boot: Starts from a container image (default "exeuntu"), so a new VM takes about two seconds; you can't choose the kernel
Billing model: Reserved pools shared by your VMs, plus standalone VMs billed per second
Regions: 9: Oregon, Los Angeles, New York, Dallas, Frankfurt, London, Tokyo, Singapore, Sydney
Preinstalled agents: claude, codex, pi and the Shelley web agent
Networking: No public IP per VM; HTTPS proxy at vmname.exe.xyz and brokered SSH

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	exe.dev: price rank	boat: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boat fits a software factory fully, with Docker, /dev/kvm and a desktop on every machine; Fly needs a Volume per agent, and exe.dev has no desktop or snapshots.	92nd of 367, with limits $836 a month	253rd of 367, with limits $3,701 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev fits always-on assistants fully, since each VM keeps its whole disk and runs with no time limit, while a Fly Machine keeps only what is on its Volume.	125th of 366, with limits $816 a month	15th cheapest of 366 $3,833 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 better than exe.dev: per-second billing with no plan fee, and cheap shared CPU for code that mostly waits.	75th of 345, with limits $94 a month	235th of 345, with limits $175 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 boat fits sandboxes for your users fully; Fly's API creates about one Machine per second per app, and exe.dev Personal stops at 50 VMs at once.	69th of 361, with limits $600 a month	257th of 361, with limits $1,226 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	265th of 360, with limits $5,250 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	283rd of 364, with limits $1,050 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; exe.dev pools bill whether jobs run or not, and boat bills per second while running.	152nd of 377, with limits $288 a month	288th of 377, with limits $504 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev makes a good 24/7 dev box with root, SSH and a lasting disk on a flat pool; on Fly the root disk resets and shared CPUs get throttled under steady load.	118th of 368, with limits $53 a month	25th cheapest of 368 $35 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 Computer-use agents need a screen: neither Fly Machines nor exe.dev has one built in, while boat streams a 60fps desktop with Chromium.	95th of 369, with limits $173 a month	240th of 369, with limits $1,055 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	130th of 367, with limits $530 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	124th of 346, with limits $278 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 higher than exe.dev here, since it can spread scrapers across 17 regions and pay only for the seconds they run.	44th of 338, with limits $1,232 a month	166th of 338, with limits $5,490 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	60th of 360, with limits $263 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	exe.dev	boat
Kind of product	App hosting platform; you boot your own image as a microVM	Linux VMs for developers and AI agents, reached over SSH and HTTPS	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel, on Fly's own servers	KVM VM with Cloud Hypervisor on rented bare metal; you can't choose the kernel	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	Root, systemd and Docker ready; nested virtualization on Enterprise only	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	Whole disk persists and is streamed to a second server; no snapshots	Whole disk kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Pause with memory	Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move	Stop and start; no memory snapshots	Resume reboots from disk (no memory snapshots)
Fork and copy	Clone copies a Machine's config; a cloned Volume starts empty	cp copies a VM's disk and config into a new VM	Fork a running sandbox, disk included; named snapshots as templates
Custom images	Boots your own Docker image	Boots from your own Docker image	Templates from named snapshots; no Dockerfile or OCI images
Coding agents	None built in; you install and run agents yourself	Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API	Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code and Mistral Vibe, with a prompt, steer and events API
Desktop and computer use	None built in; you add a desktop and browser to your own image	Headless; no desktop or screen streaming	60fps desktop and Chromium, computer use and browser control, embeddable stream
Keeping keys out of the sandbox	Secrets arrive as environment variables; the open-source tokenizer proxy can be deployed yourself	Integrations inject secrets at the network edge for any HTTP host, S3, GitHub and more	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Reaching the machine	Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network	HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP	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	Open internet; no provider-side allowlist	Open internet on every plan; no provider-side allowlist
CPU	Shared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs get the full core at a higher rate	Your VMs share the vCPUs of the pool you reserve	One CPU class on every plan, with no baseline quota or burst balance
Regions	17 regions on six continents	9 regions in the US, Europe, Asia and Australia	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	exe.dev	boat
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	Yes	Yes
Root	Yes	Yes	Yes
Systemd	No	Yes	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	Yes	Yes
Live fork (no pause)	Yes	Yes	Yes
Memory fork	No	No	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	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	Yes	Yes
Secret proxy for any API	No	Yes	Yes
Preinstalled agents	No	Yes	Yes
Agent harness API	No	Yes	Yes
MCP server	Yes	Yes	No
GPU	No	No	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	Yes	Yes
Spend limits	No	Not published	Yes
Usage per sandbox (API)	No	Yes	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	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

exe.devNot measured

boat26.69 runs/s

Neither Fly.io Machines nor exe.dev was part of the public StarSling run, so there is no comparable CPU measurement for either. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run. Fly results would also depend on the CPU class: shared vCPUs guarantee only 6.25% of a core, 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 exe.dev 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	exe.dev, a month	boat, 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	$35 · Personal	$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	$35 · Personal	$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	$1,848 · Personal	$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	$530 · Personal · 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,050 · Personal · 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.

exe.dev: exe.dev Personal pools are a flat monthly fee, from $15 for 2 vCPU / 4 GB to $155 for 16 vCPU, billed whether VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.

exe.dev: 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 all five scenarios: its lowest prices need a 1-year reservation, and shared vCPUs guarantee only 6.25% of each core, so long builds get throttled. Fly's API also starts about one Machine per second per app. exe.dev Personal allows one pool of up to 16 vCPU with 50 VMs, plus 50 standalone VMs, so 300 or 1,000 sandboxes at once do not fit. On boat the 1,000-job burst is queued by start-rate limits even on the top plan.

Scenario	Fly.io Machines	exe.dev	boat
One coding agent, workdays	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	flat pool: the tier is billed whether used or not	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	flat pool: the tier is billed whether used or not	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	None that bite	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	Personal: max 50 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	Personal: max 50 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 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 spread out: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
Wake on request and memory suspend. Useful for services that sleep between requests: Fly Proxy wakes a Machine on traffic, and small Machines resume with memory kept.
A full app platform around each Machine. Useful if you host whole apps: Fly adds port-level egress rules, private networking, Anycast IPs and custom domains.

Use exe.dev when

you want a persistent Linux dev box with agents preinstalled, outside Europe or booted from your own Docker image, on a flat monthly pool.

A dev box that is ready and keeps its disk. Useful for long-lived agents: each VM has root, systemd, Docker and Claude Code ready, and its whole disk stays between runs.
A flat pool for steady use. Useful when machines run all day: a Personal pool is one flat monthly fee that your VMs share, however busy they are.
Team controls and an MCP server. Useful for teams: the Work plan covers everyone with SSO and roles, and an MCP server lets tools like Claude Code control VMs.

Where boat fits

Fly.io Machines are an app platform you turn into a sandbox yourself, and exe.dev is a headless dev box. If your agents build, test, browse and click through UIs for hours, boat gives each one a full VM with a desktop, a disk saved every minute and an API to drive agents inside from outside.

A screen your agents can use

Fly Machines have no desktop, and exe.dev VMs are headless, so computer-use agents have nothing to look at. On both you build and stream a desktop yourself; boat ships a 60fps desktop with Chromium and computer use.

A disk saved every minute

A Fly Machine's root disk resets, so agent work must live on a Volume billed for its full size. exe.dev keeps the disk but has no snapshots, so one bad agent step can wipe a session's work.

Agents driven from outside, with /dev/kvm

Fly has no agents built in and no /dev/kvm. exe.dev takes API prompts only for Shelley and has nested VMs on Enterprise only. boat preinstalls seven agents with a prompt, steer and events API, and /dev/kvm on every plan.

Use boat when your agents do real work for hours: builds, tests, Docker and emulators on a full VM with a desktop, a disk saved every minute and one API to drive agents inside from outside. Compare it one to one: boat vs Fly.io Machines and boat vs exe.dev.

Questions people ask

Is Fly.io Machines cheaper than exe.dev?

Often, on Fly's cheapest rate of shared vCPUs on a 1-year reservation. One agent on workdays is $15 a month on Fly and $35 on exe.dev, and 50 agents in parallel are $487 on Fly against $1,848 on exe.dev. One agent running all month is about even, $36 against $35, and boat is $20, $317 and $26 for those three.

Which is faster, Fly.io Machines or exe.dev?

There is no comparable measurement, since neither was in the public StarSling benchmark run. On Fly it depends on the CPU class: shared vCPUs guarantee 6.25% of a core and get throttled under steady load. boat scored 26.69 runs per second in that run.

Can Fly.io Machines and exe.dev run Docker?

Yes. On Fly you install Docker yourself in your image, and there is no systemd or /dev/kvm. exe.dev VMs come with root, systemd and Docker ready, with nested virtualization on Enterprise only. boat has Docker, systemd and /dev/kvm on every machine.

Do they keep my files when a machine stops?

exe.dev keeps the whole disk of each VM, though it has no snapshots. On Fly the root file system is ephemeral, so only what is on the Machine's one Volume lasts. boat keeps the whole disk, with snapshots every minute and on stop.

Which one comes with coding agents?

exe.dev preinstalls Claude Code, Codex, Pi and its own Shelley agent, though only Shelley takes prompts through its API. Fly Machines boot your own image, so you add agents yourself. boat preinstalls seven agents and lets you prompt, steer and stream any of them through one API.

Where do they run?

Fly runs Machines in 17 regions on six continents, and exe.dev runs in 9 regions in the US, Europe, Asia and Australia. boat runs only in the EU, in Germany, Finland and France, with EU data residency.

Try boat

Install the CLI, then run boat new.

7-day free trial