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 by default 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 and mount one Volume at a time for data that must last. Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. Machines themselves are an app-hosting building block; for agent sandboxes Fly also sells Sprites (see boat vs Sprites), so this page compares only the Machines product.

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 with 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. It suits developers who want a persistent dev box or a sandbox for their agents.

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. “123rd cheapest of 365” means 122 of the other 364 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 workloadFly.io Machines: price rankexe.dev: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
boat fits a software factory with Docker, /dev/kvm, a desktop and a snapshot every minute. exe.dev runs the code too, but you install a desktop and take disk backups yourself. On Fly you build the image and keep files on a Volume.
123rd of 365, with limits
$836 a month
267th of 365, with limits
$3,721 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
exe.dev fits always-on assistants: each VM keeps its whole disk and runs with no time limit. A Fly Machine keeps files on its Volume, or on the root file system with opt-in persist_rootfs.
186th of 361, with limits
$816 a month
20th cheapest of 361
$3,833 a month
6th cheapest of 361
$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.
83rd of 336, with limits
$94 a month
231st of 336, with limits
$175 a month
189th of 336, 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's API creates about one Machine per second per app. exe.dev Personal allows 50 VMs in total; a Work pool allows up to 1,000. boat allows 100 to 2,000 sandboxes at once by plan, with start limits per plan.
75th of 349, with limits
$600 a month
252nd of 349, with limits
$1,234 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
52nd of 349, with limits
$2,838 a month
260th of 349, with limits
$5,250 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
124th of 359, with limits
$457 a month
280th of 359, with limits
$1,050 a month
10th cheapest of 359
$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 its standalone VMs bill per second. boat bills per second while running.
154th of 374, with limits
$288 a month
289th of 374, with limits
$504 a month
2nd cheapest of 374
$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 by default, and shared CPUs get throttled under steady load.
160th of 371, with limits
$35 a month
24th cheapest of 371
$35 a month
19th cheapest of 371
$26 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Neither Fly Machines nor exe.dev ships a desktop: on both you install a desktop and VNC yourself. boat streams a 60fps desktop with Chrome.
140th of 367, with limits
$173 a month
270th of 367, with limits
$1,055 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
229th of 356, with limits
$90 a month
187th of 356, with limits
$530 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
233rd of 343, with limits
$67 a month
187th of 343, with limits
$278 a month
6th cheapest of 343
$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 well above exe.dev here: it can spread scrapers across 17 regions and pay only for the seconds they run.
47th of 327, with limits
$1,232 a month
165th of 327, with limits
$5,490 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
168th of 351, with limits
$63 a month
51st of 351, with limits
$264 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureFly.io Machinesexe.devboat
Kind of productApp hosting platform; you boot your own image as a microVMLinux VMs for developers and AI agents, reached over SSH and HTTPSAgent sandbox: a full VM per agent, ready to use
IsolationFirecracker microVM with its own kernel, on Fly's own serversKVM VM with Cloud Hypervisor on rented bare metal; you cannot choose the kernelFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Docker, systemd and nested virtualizationRoot and Docker you install yourself; Fly's own init by default (systemd as PID 1 is not a documented setup); /dev/kvm not documentedRoot, systemd and Docker ready; nested virtualization off by default, available on request from supportDocker, root, systemd and /dev/kvm on every machine
Files after a stopRoot file system resets by default; opt-in persist_rootfs keeps it, but Fly staff say not to trust it with critical data. Lasting data goes on one Volume (daily snapshots), billed for its full size around the clockWhole disk persists and is replicated across the regional cluster; on-demand disk backups to your own S3 bucket, with restore to a new VM (preview)The disk is saved every minute and at each stop, kept at least 14 days, with no compute charge while stopped; memory is not saved
Pause with memorySuspend keeps memory for Machines up to 2GB; dropped on deploy or host moveStop and start; no memory snapshotsResume reboots from disk (no memory snapshots)
Fork and copyClone copies a Machine's config; its Volume starts empty unless you restore a volume snapshot or fork the Volumecp copies a VM's disk and config into a new VMFork a running sandbox from its last 1-minute snapshot; saved snapshots as templates
Custom imagesBoots your own Docker imageBoots from your own Docker imageStart from boat's image or a saved snapshot; you cannot boot your own Docker or OCI image
Coding agentsNot built in on Machines; you install agents in your image. Fly's separate Sprites product ships coding agentsClaude Code, Codex, Pi and Shelley preinstalled; Shelley takes prompts through the API, other agents run through the exec APIClaude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code and Mistral Vibe, with a prompt, steer and events API
Desktop and computer useNot built in; you set it up: add a desktop, a browser and a VNC stream to your own imageNo built-in desktop or stream; you can install a desktop and VNC yourself, and Shelley's browser tool drives a headless ChromiumBuilt-in 60fps desktop and Chrome, computer use, browser control, embeddable stream
Keeping keys out of the sandboxSecrets arrive as environment variables; you can deploy Fly's open-source tokenizer proxy yourselfIntegrations inject secrets at the network edge for any HTTP host, S3, GitHub and moreOptional AI credentials proxy ($1 a day while on, plus $1 per 1,000 requests) for model providers and HTTPS APIs you register
Reaching the machinePublic HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, SSH, private networkHTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCPUp to 50 HTTPS URLs, token-gated by default; SSH; public IPv6 and outbound IPv4; no dedicated IPv4
Outbound rulesNetwork policies allow chosen ports and protocols and deny the restOpen by default; an egress policy can block everything but attached integrationsOpen internet on every plan; no provider-side allowlist
CPUShared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs get the full core at a higher rateYour VMs share the vCPUs of the pool you reserveShared vCPUs with no baseline quota or burst balance; one price per size
Regions17 regions on six continents9 regions in the US, Europe, Asia and AustraliaGermany, Finland and France; no US or Asia region, and you cannot pick one
Every feature Battleships tracks (43)
FeatureFly.io Machinesexe.devboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNot publishedWith your own setupYes
RootYesYesYes
SystemdNot publishedYesYes
Desktop GUINo documented wayNo documented wayYes
BrowserNo documented wayYesYes
Computer-use APINo documented wayNo documented wayYes
SSHYesYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesYesYes
Live fork (no pause)YesYesYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesNo documented wayNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundYesNo documented wayYes
Public IPv4YesNo documented wayNo documented way
Egress allowlistYesWith your own setupNo documented way
Secret proxyNo documented wayYesYes
Secret proxy for any APINo documented wayYesYes
Preinstalled agentsNo documented wayYesYes
Agent harness APINo documented wayYesYes
MCP serverYesYesNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayYesNo documented way
Open sourceYesNo documented wayNo documented way
Scoped API keysNot publishedYesYes
Spend limitsNo documented wayNot publishedYes
Usage per sandbox (API)No documented wayYesYes
Audit logsNot publishedNot publishedNo documented way
SSONo documented wayYesNo documented way
SOC 2YesNo documented wayNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Fly.io MachinesNot measured
exe.devNot measured
boat28.06 runs/s

Neither Fly.io Machines nor exe.dev is in the public benchmarks we use, so we cannot say which is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 V8 Web Tooling Benchmark runs per second at 4 vCPU / 8 GB, second of 15. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Fly results depend on the CPU class: shared vCPUs guarantee only 6.25% of a core, and performance vCPUs get the full core.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Fly.io Machines and exe.dev are not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioFly.io Machines, a monthexe.dev, a monthboat, 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$8,800 · $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. Stopped Machines pay for their root file system, and Volumes are billed for their full size all month at $0.15 per GB. 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. Work is $75 a month for the team plus $0.105 an hour per extra 2 vCPU / 4 GiB. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.

exe.dev: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, and unused time does not carry over. A default 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs. A stopped sandbox has no compute charge; extra saved snapshots and the optional AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07 each.

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 up to 16 vCPU of pool and 50 VMs in total, so 300 or 1,000 sandboxes at once do not fit there; a Work pool allows up to 1,000 VMs, with pools above 32 vCPU after support approval. boat does not fit 1,000 short jobs at once either: the $2,000 plan charges for starts above 90 a minute and refuses them above 270.

ScenarioFly.io Machinesexe.devboat
One coding agent, workdays
  • different kind of product: app platform
  • files survive a stop only in one Fly Volume (root file system too with opt-in persist_rootfs): packages installed elsewhere reset
  • 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 for this scenario
One agent that never stops
  • different kind of product: app platform
  • files survive a stop only in one Fly Volume (root file system too with opt-in persist_rootfs): packages installed elsewhere reset
  • 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 for this scenario
50 agents in parallel
  • different kind of product: app platform
  • files survive a stop only in one Fly Volume (root file system too with opt-in persist_rootfs): packages installed elsewhere reset
  • 1-year commitment
  • burstable CPU: 6.25% of each vCPU guaranteed, throttled above that
None for this scenarioNone for this scenario
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 for this scenario
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
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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 network policies, 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, with SSO for a team.

  • 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 that you turn into a sandbox yourself, and exe.dev is a ready dev box with no built-in desktop. 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

Neither Fly Machines nor exe.dev ships a desktop; on both you install a desktop and VNC yourself. boat ships a 60fps desktop with Chrome and computer-use tools in every sandbox.

A disk saved every minute

On Fly, agent work lives on a Volume billed for its full size, or on the root file system with opt-in persist_rootfs. exe.dev keeps the disk and takes backups to your own S3 bucket when you ask (preview). boat saves the disk every minute and at each stop. It does not save memory, and a machine failure loses writes after the last good snapshot.

Agents driven from outside, with /dev/kvm

Fly has no agents built in and does not document /dev/kvm. exe.dev takes API prompts for Shelley and turns on nested virtualization on request. boat installs seven harnesses with a prompt, steer and events API, and has /dev/kvm on every sandbox.

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.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Fly.io Machines cheaper than exe.dev?

Often, on Fly's lowest 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. boat is $20, $317 and $26 for those three.

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

Neither is in the public benchmarks we use, so we cannot say. On Fly it depends on the CPU class: shared vCPUs guarantee 6.25% of a core and get throttled under steady load.

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

Yes. On Fly you install Docker yourself in your image; Fly does not document systemd as PID 1 or /dev/kvm. exe.dev VMs come with root, systemd and Docker ready, and support turns on nested virtualization on request. 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 and can back it up to your own S3 bucket on demand. On Fly, files on the Machine's Volume last, and the root file system too with opt-in persist_rootfs, which Fly staff say not to trust with critical data. boat saves the disk every minute and at each stop and keeps it at least 14 days.

Which one comes with coding agents?

exe.dev preinstalls Claude Code, Codex, Pi and its own Shelley agent; Shelley takes prompts through its API, and other agents run through its exec API. Fly Machines boot your own image, so you add agents yourself. boat installs seven harnesses 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 on machines in Germany, Finland and France, and you cannot pick a region. Snapshot copies can be stored outside the EU.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons