Fly.io Machines vs Sprites

Both come from Fly.io and both run Firecracker microVMs. Fly.io Machines boot an image you build, in a region you pick, with a root disk that resets; Sprites are fixed 8 vCPU agent computers with a disk that lasts, agents preinstalled, and billing only for the CPU and memory they use while awake.

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

Sprites

Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.

Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.

Company: Fly.io, which also sells Fly Machines and Managed Postgres
Isolation: Firecracker microVM per Sprite
Machine shape: Fixed 8 vCPU and 100 GB disk; memory is set and scaled by the platform
Image: One managed Ubuntu 25.10 image; you install on top of it
Regions: Not selectable for Sprites
Compliance: SOC 2 Type II; HIPAA package with a pre-signed BAA on paid plans
Free start: $30 trial credit per organization

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	Sprites: price rank	boat: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites suits a coding agent better than Fly.io Machines because its disk lasts; boat adds systemd, /dev/kvm and many public ports on top of a disk that lasts.	92nd of 367, with limits $836 a month	66th of 367, with limits $546 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Fly Machine runs until you stop it but keeps only what is on its Volume, while a Sprite pauses when idle and drops open connections; boat just keeps the machine and its disk running.	125th of 366, with limits $816 a month	157th of 366, with limits $1,166 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 Both Fly products beat boat for short bursts: Fly bills per second with no plan fee, and Sprites bills only the CPU and memory a run actually uses.	75th of 345, with limits $94 a month	93rd of 345, with limits $140 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	56th of 361, with limits $428 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 Fly.io Machines rank well above Sprites for big rollout fleets, since cheap shared CPU and per-second billing add up over many short runs.	48th of 360, with limits $2,838 a month	105th of 360, with limits $6,540 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	125th of 364, with limits $545 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 Sprites fits CI fully while Fly.io Machines are a compromise, because CI keeps the CPU busy and drains a shared Fly vCPU's burst balance.	152nd of 377, with limits $288 a month	63rd cheapest of 377 $476 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box wants SSH and systemd; Fly.io Machines give you SSH, Sprites tunnel it through a CLI, and only boat has both with a disk that lasts.	118th of 368, with limits $53 a month	213th of 368, with limits $27 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 product has a desktop, so on both you build and stream one yourself; boat ships a 60fps desktop with Chromium and computer use.	95th of 369, with limits $173 a month	85th of 369, with limits $136 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	171st of 367, with limits $122 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	229th of 346, with limits $206 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.io Machines lead here: scrapers can spread across 17 regions and pay only for the seconds they run, while Sprites have no region choice.	44th of 338, with limits $1,232 a month	141st of 338, with limits $4,113 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	210th of 360, with limits $223 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	Sprites	boat
Kind of product	App hosting building block: you boot your own Docker image as a microVM	Agent computer: one managed Ubuntu image you install on top of	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	Firecracker microVM with its own kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Machine size and CPU	CPU presets you pick; shared vCPUs guarantee 6.25% of a core plus bursts, performance vCPUs get the full core	Fixed 8 vCPU and 100 GB disk; memory set and scaled by the platform	You choose, up to 16 vCPU / 32 GB on the $100 plan and above; one CPU class with no burst balance
Docker, systemd and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered	Root and Docker, with rough edges users report; no systemd, and no /dev/kvm in the docs	Root, Docker, systemd and /dev/kvm on every machine
Files after a stop	Root file system is ephemeral; lasting data goes on one Volume of up to 500 GB, billed for its full size around the clock	The whole 100 GB disk lasts and syncs to object storage; storage billed on bytes written	The whole disk is kept, saved every minute and on stop; a stopped sandbox costs nothing
Idle and wake	Fly Proxy stops or suspends idle Machines and wakes them on a request; memory kept only up to 2 GB	Pauses about 30 seconds after activity stops; wakes in 100 to 500 ms with memory, or 1 to 2 s after a cold stop	Runs until you stop it or its time to live ends; resume reboots from disk
Snapshots and fork	Clone copies a Machine's config; a cloned Volume starts empty	Filesystem checkpoints that restore in place; no fork in the API or CLI	Fork a running sandbox with its disk; named snapshots to start new sandboxes from
Reaching the machine	Public HTTPS and TCP services through Fly Proxy, public IPv4, custom domains, private network between Machines	One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Optional DNS-based domain allowlist set from outside; private IPs always blocked	Open internet on every plan; no provider-side allowlist
Keeping keys out of the machine	Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself	Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Coding agents	None built in; you install and run agents yourself	Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console	Seven agents preinstalled, with a prompt, steer and events API to drive agents inside from outside
Desktop and browser	None built in; you add a desktop and browser to your own image	Headless; no desktop or browser product	60fps desktop and Chromium, computer use and browser control, embeddable stream
Regions	17 regions on six continents	Region not selectable	EU only (Germany, Finland, France), with EU data residency

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Sprites	boat
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	No	Yes
Root	Yes	Yes	Yes
Systemd	No	No	Yes
Desktop GUI	No	No	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	No	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	No	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	No	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	Yes	No
HIPAA	Yes	Yes	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

SpritesNot measured

boat26.69 runs/s

There is no comparable measurement for either Fly product: neither Fly.io Machines nor Sprites were in the public StarSling run where boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. On Fly.io Machines the result would depend on the CPU class, since shared vCPUs guarantee only 6.25% of a core, and a Sprite always has 8 vCPU, so a fair test would need matching shapes.

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 Sprites 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	Sprites, 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	$23 · 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	$92 · Pay-as-you-go	$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,120 · 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	$314 · 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,134 · 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; stopped Machines pay for their root file system and Volumes bill their full size all month. The figures here use Fly's lowest rate: shared vCPUs in 1-year reservation blocks for 40% off.

Sprites: Sprites bill CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while awake, plus storage on the bytes you write. Optional plans include fixed CPU-hour, memory-hour and storage allowances that are not credit; usage above them bills at the normal rates.

Sprites: 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.io Machines are a compromise in all five scenarios: the lowest figures need a 1-year reservation and shared vCPUs that guarantee only 6.25% of each core, so long builds get throttled, and Fly's API starts about one Machine per second per app. Sprites fit one agent on workdays, one agent all month and 50 agents in parallel, but the running cap on pay as you go is not published, so 300 user sandboxes and 1,000 jobs at once are not confirmed, and creation is 10 a minute without a plan. A Sprite also drops open connections on every pause, so an always-on agent needs a task hold of at most an hour that must be renewed. boat fits four of the five; at 1,000 short jobs at once even the $2,000 plan queues starts above 90 a minute.

Scenario	Fly.io Machines	Sprites	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	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	None that bite	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	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	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	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	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	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	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 your own image near users around the world, want private networking and custom domains, or run light services that sleep between requests.

Your own image, in 17 regions. Useful if you ship your own Docker image and need it near users: Fly runs Machines in 17 regions, from the US to Sydney.
A full app platform around each VM. Useful for hosting whole products: Fly adds public IPv4, raw TCP, custom domains, private networking and port-level network policies.
Cheap CPU for work that mostly waits. Useful for light services and short jobs: shared vCPUs bill per second with no plan fee, and suspend keeps memory for small Machines.

Use Sprites when

your agents sit idle most of the day, should wake on a request with their disk intact, and need a domain allowlist or API connectors.

A disk that lasts, ready for agents. Useful for coding agents: each Sprite keeps its whole 100 GB disk and comes with Claude Code, Codex, Gemini CLI and Cursor.
Sleeps when idle, bills real use. Useful for machines idle most of the day: a Sprite pauses after about 30 seconds and bills only the CPU and memory used.
Domain allowlist and API connectors. Useful when agents must stay fenced in: Sprites limit outbound traffic to listed domains and hold API tokens outside the machine.

Where boat fits

If what you are really running is agents that work for hours, neither Fly product gives you a whole Linux server to shape. Fly.io Machines need you to build the image, the lasting disk and the agent tooling; Sprites give you a lasting disk and agents but a fixed headless box with one public port. boat gives each agent a full VM with systemd, /dev/kvm, a desktop, forks and an API to drive agents inside from outside.

A full machine, not a trimmed one

Neither Fly product runs systemd or offers /dev/kvm, so services need rewriting and Android emulators or nested VMs cannot run. On Sprites, docker exec also fails for containers like Postgres that run as non-root. boat has Docker, systemd and /dev/kvm ready.

A disk that lasts, and forks

A Fly Machine loses everything off its one Volume on restart, and a clone gets an empty Volume. Sprites keep the disk, but checkpoints restore in place with no fork. boat saves the disk every minute and forks a running sandbox.

A desktop and agents you drive

Both Fly products are headless, so a browser agent runs blind unless you add a display and a stream yourself. Sprites preinstall agents but run them through exec. boat streams a 60fps desktop and has a prompt, steer and events API.

Use boat when your agents do real work for hours: Docker, systemd and emulators on a full VM whose disk survives every stop, with forks, a desktop, many ports and an API to drive agents inside from outside. Compare it one to one: boat vs Fly.io Machines and boat vs Sprites.

Questions people ask

Is Fly.io Machines cheaper than Sprites?

On the table, yes: one agent all month is $36 on Fly.io Machines and $92 on Sprites, and 50 agents in parallel are $487 against $1,120. But Fly's figures need a 1-year reservation and assume work that stays within a shared vCPU's 6.25% baseline. On boat the same two cost $26 and $317 a month.

Are Fly.io Machines and Sprites from the same company?

Yes. Both are sold by Fly.io and both run as Firecracker microVMs. Machines are the building block of Fly's app hosting platform, while Sprites are its product for agents.

Which is faster?

There is no comparable measurement for either one. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in the public StarSling run, which included neither Fly product.

Can Fly.io Machines and Sprites run Docker?

Yes, both give you root and can run Docker, though on Fly you install it yourself and on Sprites docker exec fails for containers whose main process is not root. Neither runs systemd or offers /dev/kvm. boat 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. A Sprite keeps its whole 100 GB disk. boat keeps the whole disk too, saved every minute and on stop.

Where do they run?

Fly.io Machines run in 17 regions you can choose. Sprites do not let you choose a region. 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