Fly.io Machines vs GitHub Codespaces

Fly.io Machines are fast microVMs you boot from your own image to host apps near users, and they run until you stop them. GitHub Codespaces are ready dev containers opened from a repository in VS Code or the browser, and each one stops after 12 hours at most.

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.

GitHub Codespaces

GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.

Codespaces is a different kind of product from boat: a dev environment for people who work on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config. It runs on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.

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 rankGitHub Codespaces: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Neither fits fully: on Fly you install Docker in your image and keep files on a Volume, and /dev/kvm is not documented; a codespace stops after 12 hours at most. boat fits with Docker, /dev/kvm and a disk saved every minute.
123rd of 365, with limits
$836 a month
290th of 365, with limits
$4,618 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Fly Machines run until stopped, which suits a long-lived assistant better than Codespaces and its 12-hour cap. On Fly, files last on the Volume, or on the root file system with opt-in persist_rootfs.
186th of 361, with limits
$816 a month
320th of 361, with limits
$6,970 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 best of the three: per-second billing with no plan fee. Each codespace builds a dev container on a new VM first, and boat's start limits push it to a high plan.
83rd of 336, with limits
$94 a month
283rd of 336, with limits
$619 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 can host one Machine per user through its API, at about one create per second per app. Codespaces are made for GitHub users on a repository, and GitHub does not publish how many can run at once.
75th of 349, with limits
$600 a month
276th of 349, with limits
$1,964 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
276th of 349, with limits
$9,489 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
295th of 359, with limits
$1,519 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
Busy CI jobs drain a shared Fly vCPU's burst balance; performance CPU avoids it. Codespaces has no fork or snapshot API, so each run starts from a repo or prebuild.
154th of 374, with limits
$288 a month
317th of 374, with limits
$909 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
Codespaces gives a polished VS Code box per repo but stops after 12 hours at most. Fly runs 24/7, but you build the image. On boat, turn auto-stop off (1 hour by default) on a paid plan.
160th of 371, with limits
$35 a month
144th of 371, with limits
$270 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
A codespace can add a basic noVNC desktop through the desktop-lite dev container feature; on Fly you build a desktop into your image. Neither has a computer-use API. boat streams a 60fps desktop with Chrome.
140th of 367, with limits
$173 a month
297th of 367, with limits
$1,367 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
306th of 356, with limits
$678 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
324th of 343, with limits
$922 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 highest of the three here: it can spread scrapers across 17 regions and bill only the seconds they run.
47th of 327, with limits
$1,232 a month
279th of 327, with limits
$18,637 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
284th of 351, with limits
$445 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 MachinesGitHub Codespacesboat
Kind of productApp hosting platform; you boot your own image as a microVMCloud dev environment: a dev container per GitHub repositoryAgent sandbox: a full VM per agent, ready to use
IsolationFirecracker microVM with its own kernelA Docker container on its own newly built VMFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
How long it runsRuns until you or Fly Proxy stop it; no documented maximumStops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in useStops after 1 hour by default; set up to 30 days, or turn auto-stop off on a paid plan and it runs until you stop it
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 documentedDocker inside through a dev container feature; /dev/kvm not documentedDocker, 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, billed for its full size around the clockFiles are kept and storage is billed; a stopped codespace is deleted after 30 days by default (0 to 30 days)The disk is saved every minute and at each stop, kept at least 14 days with no compute charge; a saved snapshot has no scheduled expiry
Pause with memorySuspend keeps memory for Machines up to 2GB; dropped on deploy or host moveNo memory state is kept; processes end at each stopResume reboots from disk (no memory snapshots)
Fork and copiesClone copies a Machine's config; its Volume starts empty unless you restore a volume snapshot or fork the VolumeNo copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuildFork a running sandbox from its last 1-minute snapshot; saved snapshots as templates
Starting pointAny Docker image you buildDev container config in the repo, with prebuilds built by GitHub Actionsboat's image or a saved snapshot, shareable by code; you cannot boot your own Docker image
Desktop and computer useNot built in; you set it up: add a desktop, a browser and a VNC stream to your own imageVS Code, JupyterLab and a terminal; a Fluxbox desktop over noVNC through the desktop-lite dev container feature, which you configure; no computer-use APIBuilt-in desktop and Chrome streamed at 1920x1080, 60fps, with computer-use tools
Coding agentsNot built in on Machines; you install agents in your image. Fly's separate Sprites product ships coding agentsGitHub Copilot as a VS Code extension; other agents you install yourselfSeven harnesses installed, among them Claude Code, Codex and OpenCode, with a prompt, steer and events API
Keeping keys out of the sandboxSecrets arrive as environment variables; you can deploy Fly's open-source tokenizer proxy yourselfSecrets are copied into the codespace as environment variablesOptional AI credentials proxy ($1 a day while on, plus $1 per 1,000 requests); with it on, real keys of supported providers stay outside; other secrets still enter
Reaching the machinePublic HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, SSH, private networkA URL per forwarded port (private, organization or public) and SSH tunnels; no public IPUp 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 internet; GitHub says there is no way to restrict itOpen internet on every plan; no provider-side allowlist
Regions17 regions on six continentsUS East, US West, Europe West and Southeast AsiaGermany, Finland and France; no US or Asia region, and you cannot pick one
Every feature Battleships tracks (43)
FeatureFly.io MachinesGitHub Codespacesboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNot publishedNot publishedYes
RootYesYesYes
SystemdNot publishedNot publishedYes
Desktop GUINo documented wayWith your own setupYes
BrowserNo documented wayNo documented wayYes
Computer-use APINo documented wayNo documented wayYes
SSHYesYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)YesNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesNo documented wayYes
Idle auto-stopYesYesNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundYesNo documented wayYes
Public IPv4YesNo documented wayNo documented way
Egress allowlistYesNo documented wayNo documented way
Secret proxyNo documented wayNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsNo documented wayNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesNo documented wayNo 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 wayNo documented wayNo documented way
Open sourceYesNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNo documented wayYesYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedYesNo documented way
SSONo documented wayYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Fly.io MachinesNot measured
GitHub CodespacesNot measured
boat28.06 runs/s

Neither Fly.io Machines nor GitHub Codespaces 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's shared vCPUs guarantee only 6.25% of each core with a burst balance, so its results depend on the CPU class you pick.

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 GitHub Codespaces 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 monthGitHub Codespaces, 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$51 · Personal account: GitHub Free$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$270 · Personal account: GitHub Free · 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$3,019 · Personal account: GitHub Free$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$850 · Personal account: GitHub Free · 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,889 · Personal account: GitHub Free · 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 shared vCPUs bought in 1-year reservation blocks for 40% off, Fly's lowest rate.

GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, used or not, plus $0.07 per GB-month of storage while it exists, stopped too. A 4 vCPU / 8 GB job is priced on the 4-core 16 GB machine. Personal accounts get a free monthly quota; organizations do not.

GitHub Codespaces: 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 shows as a compromise in every scenario because its lowest figures need a 1-year reservation and use shared vCPUs that are throttled above 6.25% of each core, so long builds and tests slow down. Codespaces stops every codespace after 12 hours at most, so it does not fit the always-on agent. GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. 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 MachinesGitHub Codespacesboat
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
None for this scenarioNone 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
  • Personal account: GitHub Free: sessions capped at 12 h
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
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None 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
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
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
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 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 services that must run near users around the world, sleep between requests and wake on traffic.

  • No time limit. Useful for services and long jobs: a Fly Machine runs until you stop it, while a codespace stops after 12 hours at most.
  • 17 regions and wake on request. Useful for apps near users worldwide: Fly runs in 17 regions and Fly Proxy wakes a sleeping Machine when traffic arrives.
  • Public endpoints and egress rules. Useful if you host a product: Fly gives public HTTPS and TCP, custom domains and port-level outbound rules.

Use GitHub Codespaces when

your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, with compliance reports available today.

  • Built into GitHub. Useful if your team lives on GitHub: open a ready codespace from any repo, branch or pull request.
  • A ready editor. Useful for people, not just code: VS Code in the browser or on your machine, with dev containers and prebuilds set up.
  • Free hours and compliance reports. A GitHub Free account includes 120 core-hours and 15 GB-month each month, and GitHub Enterprise Cloud lists audit reports.

Where boat fits

Fly.io Machines are built for hosting apps and GitHub Codespaces for developers working in a repository, so teams that use either for agents build the sandbox around them. If your agents install, build, test and browse for hours, boat gives each one a full VM with a disk saved every minute, a desktop and agent controls in place.

A saved disk and long sessions

On Fly, lasting files go on one Volume, or on the root file system with opt-in persist_rootfs. A codespace stops at 12 hours at most, and its processes end. boat saves the disk every minute and at each stop. Auto-stop defaults to 1 hour; on a paid plan you can turn it off. boat does not save memory, and a machine failure loses writes after the last good snapshot.

/dev/kvm, systemd and a desktop

Neither Fly nor Codespaces documents /dev/kvm, so emulators and nested VMs are not a documented path. On Fly you add a desktop to your image; on Codespaces the desktop-lite feature adds a basic noVNC desktop. Every boat machine has Docker, systemd, /dev/kvm and a 60fps desktop with computer-use tools.

Agents driven from outside

On both you install agents yourself, write the code that prompts and watches them, and pass keys in as environment variables. boat installs seven coding-agent harnesses with a prompt, steer and events API. Its optional paid credentials proxy keeps real keys of supported AI providers outside.

Use boat when your agents do real work for hours or days: full VMs with /dev/kvm, Docker and a desktop, a disk saved every minute, forks of running machines, and coding agents you drive from outside. Compare it one to one: boat vs Fly.io Machines and boat vs GitHub Codespaces.

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 GitHub Codespaces?

In every scenario we priced, yes, using Fly's lowest rate of shared vCPUs on a 1-year reservation. One agent running all month is $36 on Fly against $270 on Codespaces, and 50 agents in parallel are $487 against $3,019. boat comes to $26 and $317 for the same two, with no reservation. Codespaces personal accounts get free monthly hours, which cover light use.

Which is faster, Fly.io Machines or GitHub Codespaces?

Neither is in the public benchmarks we use, so we cannot say. Fly's shared vCPUs guarantee 6.25% of each core and get throttled under steady load, while its performance vCPUs get the full core.

Can I run an AI agent 24/7 on either one?

On Fly yes, since a Machine runs until you stop it; files last on its Volume, or on the root file system with opt-in persist_rootfs. A codespace stops after 12 hours at most, even while in use, so 24/7 work needs a restart script. On boat, turn auto-stop off on a paid plan and the sandbox runs until you stop it.

Can Fly.io Machines and GitHub Codespaces run Docker?

Both can: on Fly you install Docker inside the microVM yourself, and Codespaces runs Docker inside the dev container through a dev container feature. Neither documents /dev/kvm, so Android emulators and nested VMs are not a documented path. boat has Docker, systemd and /dev/kvm on every machine.

Where do they run?

Fly runs Machines in 17 regions on six continents, and Codespaces in US East, US West, Europe West and Southeast Asia. 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