Fly.io Machines vs Replit

Fly.io Machines are microVMs that your code starts and stops through a REST API, running the image you build, in 17 regions. Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it.

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

Replit

Replit is an AI app builder and hosting platform: you describe an app in chat, Replit Agent writes it, and Replit publishes it.

You work in a browser workspace where Replit Agent sets up the project, writes the code, tests it and fixes problems, with system packages managed by Nix. When the app is ready you publish it as an Autoscale, Static, Scheduled or Reserved VM deployment, with Postgres and object storage next to it. It is built for people and teams who want a working app, not for programs that need to create many machines by API, so this page compares the parts where the two overlap.

Kind of product: AI app builder with workspaces and app hosting, not a sandbox API
Hosting: Data is hosted mainly in Google Cloud data centers in the United States, with an optional India region
Regions for published apps: North America, Europe, Asia, South America and Australia on Core, Pro and Enterprise; the free plan publishes to North America
Isolation: Not documented: the security page promises strong logical separation between users but does not say containers or VMs
Plans: Starter (free), Core $20 a month, Pro from $100 a month, Enterprise custom; plan fees come back as usage credits
Compliance: Says it has a SOC 2 Type 2 attestation

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	Replit: price rank	boat: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Fly can start one Machine per agent from code but you build the image and its tools; Replit drives only Replit Agent, one app at a time, while boat fits fully at $634 a month.	92nd of 367, with limits $836 a month	181st of 367, with limits $2,000 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant is one Reserved VM app billed all month on Replit, and on Fly it keeps only what sits on its one Volume.	125th of 366, with limits $816 a month	202nd of 366, with limits $2,033 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 is the better of the two for short bursts: per-second billing with no plan fee, and cheap shared CPU for code that mostly waits.	75th of 345, with limits $94 a month	228th of 345, with limits $146 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 can create a Machine per user through its API, about one per second per app; Replit does not publish how many deployments can run at once.	69th of 361, with limits $600 a month	233rd of 361, with limits $825 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	258th of 360, with limits $4,226 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	265th of 364, with limits $685 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 jobs keep the CPU busy, which drains a shared Fly vCPU's burst balance, and Replit's Nix-based environments do not document Docker for container builds.	152nd of 377, with limits $288 a month	275th of 377, with limits $425 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Replit workspace is a good place to code by hand, though its CPU and memory per plan are no longer published; on Fly you build the dev box image yourself.	118th of 368, with limits $53 a month	165th of 368, with limits $109 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 has a computer-use API: Fly has no desktop built in and Replit's VNC pane only shows a desktop to a person, while boat ships a 60fps desktop with computer use.	95th of 369, with limits $173 a month	190th of 369, with limits $619 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	229th of 367, with limits $317 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	234th of 346, with limits $217 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 is the stronger pick 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	150th of 338, with limits $4,378 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	208th of 360, with limits $215 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	Replit	boat
Kind of product	App hosting platform; Machines are its microVM building block with a REST API	AI app builder with browser workspaces and app hosting	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	Not documented; the security page says strong logical separation between users	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Creating machines from code	REST API to create, start and stop Machines, about one per second per app	MCP server tools to create, update and publish apps; no API to start many machines	API, SDK and CLI to create, stop, resume and fork many sandboxes
Docker, systemd and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered	System packages come from Nix; the docs do not describe Docker, systemd or /dev/kvm	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	Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem	The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Pause and memory	Suspend keeps memory for Machines up to 2GB; the snapshot is dropped on deploy or host move	No pause documented; whether a Reserved VM can be stopped to save money is not documented	Resume reboots from disk (no memory snapshots)
Waking on a request	Fly Proxy stops or suspends idle Machines and wakes them when a request arrives	Autoscale starts on the first request and goes idle after 15 minutes, costing nothing while idle	No wake on request; you start and stop machines through the API
Desktop and computer use	None built in; you add a desktop and browser to your own image	VNC pane that streams a native desktop to your browser; no computer-use API	60fps desktop and Chromium, computer use and browser control, embeddable stream
Coding agents	None built in; you install and run agents yourself	Replit Agent, which you can also drive from an MCP client (create, update, ask, publish)	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; Fly's open-source tokenizer proxy can be deployed yourself	Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are secrets in the app	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 services through Fly Proxy, Anycast IPs, custom domains, private network between Machines	Published apps on HTTPS domains, custom domains and private deployments; SSH into the workspace on paid plans	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4; SSH
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	No outbound allowlist documented	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	Reserved VMs come in fixed sizes such as dedicated 4 vCPU / 16 GB; workspace CPU per plan is not published	One CPU class on every plan, with no baseline quota or burst balance
Regions	17 regions on six continents	Published apps in North America, Europe, Asia, South America and Australia on Core and up; data mainly in the US	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Replit	boat
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	No	Yes
Nested virtualization	No	No	Yes
Root	Yes	Not published	Yes
Systemd	No	No	Yes
Desktop GUI	No	Yes	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	No	Yes
Automatic snapshots	Yes	Yes	Yes
Fork/clone	Yes	Yes	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	Not published	Yes
Public IPv4	Yes	No	No
Egress allowlist	Yes	No	No
Secret proxy	No	Yes	Yes
Secret proxy for any API	No	No	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	Not published	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	Yes	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

ReplitNot measured

boat26.69 runs/s

There is no comparable measurement for either one: neither Fly.io Machines nor Replit was in StarSling's public benchmark, where boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. On Fly, results would depend on the CPU class: shared vCPUs guarantee only 6.25% of a core, while 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 Replit 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	Replit, 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	$122 · Pro $100 (annual) · with limits	$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	$122 · Pro $100 (annual) · 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	$1,330 · Pro $1,000 (annual) · 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	$403 · Pro $250 (annual) · 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	$825 · Pro $1,000 (annual) · 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 use Fly's lowest rate, shared vCPUs bought in 1-year reservation blocks for 40% off.

Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting. A Reserved VM has a fixed monthly price per size, such as $130 for 4 vCPU / 16 GB, and bills whether busy or idle; Agent usage is left out of the figures.

Replit: 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

Both are marked as not a fit in every scenario, because both are app platforms. Fly's low figures need a 1-year reservation and use shared vCPUs that guarantee only 6.25% of each core, so long builds get throttled, and its API starts about one Machine per second per app. Replit prices each agent as a Reserved VM that runs all month, does not publish how many can run at once (300 or 1,000 are not confirmed), and does not document Docker or a disk to rely on. On boat, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.

Scenario	Fly.io Machines	Replit	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	different kind of product: app platform monthly / always-on product: priced as 1 machines kept on and reused	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	different kind of product: app platform	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	adjacent product, not a like-for-like sandbox missing persistent disk, Docker inside different kind of product: app platform 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	adjacent product, not a like-for-like sandbox different kind of product: app platform 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	adjacent product, not a like-for-like sandbox different kind of product: app platform 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 want to boot your own image as microVMs from code, near users in many regions, with wake on request and port-level network rules.

Your own image, started by API. Useful if you build your own platform: your code boots any Docker image as a microVM and stops it when done.
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 port-level rules. Useful for services that sleep between requests: Fly Proxy wakes Machines on traffic, and network policies limit ports and protocols.

Use Replit when

you want Replit Agent to build a web app from a description and host it for you, with a database, storage and hosting that sleeps when idle.

An app built and hosted for you. Useful if you want a working app from a description: Replit Agent writes, tests and publishes it for you.
Databases and storage next to the app. Useful for small products: each published app gets Postgres and App Storage without running them yourself.
Hosting that costs nothing when idle. Useful for web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.

Where boat fits

Neither Fly.io Machines nor Replit is built as an agent sandbox: Fly gives you microVMs to fill with your own image, and Replit builds and hosts apps around its own agent. If what you are really running is agents that install, build, test and browse for hours, boat gives each one a full VM with those pieces already in place.

A disk that keeps everything

Agents leave tools, repos and caches all over the disk. A Fly root file system is ephemeral, so you pay for a Volume around the clock, and Replit's published apps should not rely on their files. boat keeps the whole disk, saved every minute.

Docker, systemd and /dev/kvm

Fly Machines run Fly's own init with no systemd and no /dev/kvm, so emulators and nested VMs are out. Replit's docs do not describe Docker at all. Every boat machine has Docker, systemd and /dev/kvm on its own kernel.

Agents driven from outside, keys kept out

On Fly you build the image with agents, browser and desktop, then run your own tokenizer for keys. Replit's MCP server drives only Replit Agent. boat preinstalls coding agents with a prompt, steer and events API, plus a keys proxy for any HTTPS API.

Use boat when your agents do real work for hours: full VMs with Docker, systemd and /dev/kvm, a disk that survives every stop, a desktop, coding agents you drive from outside and keys kept out of the sandbox. Compare it one to one: boat vs Fly.io Machines and boat vs Replit.

Questions people ask

Is Fly.io Machines cheaper than Replit?

In every scenario we priced, yes. One coding agent on workdays is $15 a month on Fly and $122 on Replit, 50 agents in parallel are $487 versus $1,330, and sandboxes for your users are $110 versus $403. Fly's figures use shared vCPUs on a 1-year reservation; boat comes to $20, $317 and $200 for the same three.

Which is faster, Fly.io Machines or Replit?

We cannot say: neither was in StarSling's public benchmark. On Fly it depends on the CPU class, since shared vCPUs guarantee only 6.25% of a core. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.

Can I run Docker on Fly.io Machines or Replit?

On Fly you can install and run Docker yourself, since a Machine is a microVM with root, but there is no systemd and no /dev/kvm. Replit's docs set up environments with Nix packages and do not describe Docker. Every boat machine has Docker, systemd and /dev/kvm ready.

Do my files survive a stop?

On Fly, only what sits on a Volume; the root file system is ephemeral. On Replit, workspace files and Agent checkpoints stay, but published apps should not rely on their filesystem. boat keeps the whole disk, with snapshots every minute and on stop.

Can I use either one as an AI agent sandbox?

Fly can be one if you build it: you package the tools, browser and agents into an image and add a Volume. Replit is an app builder, and from outside its MCP server drives only Replit Agent. boat ships the sandbox, agents and desktop in every machine.

Where does my data run?

Fly runs Machines in 17 regions worldwide. Replit hosts data mainly on Google Cloud in the United States, and on Core and up publishes apps in five regions. boat runs only in the EU (Germany, Finland and France), with EU data residency.

Try boat

Install the CLI, then run boat new.

7-day free trial