Sprites vs GitHub Codespaces
Sprites is Fly.io's computer for agents: a Firecracker VM that keeps its disk, sleeps about 30 seconds after work stops and wakes on the next request. GitHub Codespaces is a dev environment for people: a dev container built from a repository, opened in VS Code or the browser, that stops after 12 hours at most.
The companies and products
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.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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 working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running 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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: price rank | GitHub Codespaces: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites keeps an agent's disk with no session cap, while a codespace stops at 12 hours even while in use; boat adds systemd, /dev/kvm and many public ports on top. | 66th of 367, with limits $546 a month | 274th of 367, with limits $4,618 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 fits neither well: a Sprite pauses when nothing holds it awake and drops open connections, and a codespace stops after 12 hours; boat keeps the machine running. | 157th of 366, with limits $1,166 a month | 309th of 366, with limits $6,970 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 Sprites suits short code runs better, since it sleeps about 30 seconds after the last command and wakes in under a second, while each codespace builds a dev container on a new VM. | 93rd of 345, with limits $140 a month | 288th of 345, with limits $619 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 Sprites gives each user a VM with an HTTPS URL that wakes on request, while codespaces are created for GitHub users on a repository; boat adds SSH, raw TCP and up to 50 HTTPS ports per user. | 56th of 361, with limits $428 a month | 281st of 361, with limits $1,964 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 | 105th of 360, with limits $6,540 a month | 282nd of 360, with limits $9,489 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 | 125th of 364, with limits $545 a month | 295th of 364, with limits $1,519 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 Neither has fork or /dev/kvm in its docs; Sprites restores checkpoints in place and Codespaces starts from a repo or a prebuild, while boat forks a warm machine and exposes /dev/kvm. | 63rd cheapest of 377 $476 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is the more polished VS Code box per repo, but it stops after 12 hours; Sprites tunnels SSH through its CLI and has no systemd, and boat has both SSH and systemd. | 213th of 368, with limits $27 a month | 130th of 368, with limits $270 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 Both are headless for computer use: Sprites has no desktop and a codespace has an editor and terminal, while boat streams a 60fps desktop with Chromium. | 85th of 369, with limits $136 a month | 267th of 369, with limits $1,367 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 | 171st of 367, with limits $122 a month | 275th of 367, with limits $678 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 | 229th of 346, with limits $206 a month | 310th of 346, with limits $922 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 | 141st of 338, with limits $4,113 a month | 280th of 338, with limits $18,637 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 Neither can copy a prepared machine; boat forks one running sandbox into many. | 210th of 360, with limits $223 a month | 267th of 360, with limits $445 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 | Sprites | GitHub Codespaces | boat |
|---|---|---|---|
| What it is | A computer for agents, created by API or CLI | A dev environment for people working on a GitHub repository | A sandbox API for agents: full VMs you create and drive from code |
| Isolation | Firecracker microVM with its own kernel | A Docker container on its own newly built VM, with its own virtual network | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | 2, 4, 8, 16 or 32 cores, with 4 GB of memory per core | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| How long it runs | No session cap, but it pauses about 30 seconds after activity stops unless a task holds it awake | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Runs until you stop it; no session cap on paid plans |
| Waking up | Wakes on the next request in 100 to 500 ms with memory, or 1 to 2 s after a cold stop | Restart by hand, CLI or REST API; running processes do not come back | Resume by booting again; the disk is kept |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Docker and sudo in the dev container; /dev/kvm and nested virtualization not documented | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Starting point | One managed Ubuntu image with coding agents preinstalled; you install on top | Dev container config in the repository, with prebuilds built by GitHub Actions | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Snapshots and fork | Filesystem checkpoints by hand or automatic; restore replaces the disk in place; no fork | No copy or snapshot endpoint; stopped codespaces are deleted after 30 days by default | Disk saved every minute and on stop; fork a running sandbox into copies |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | GitHub Copilot as a VS Code extension; other agents you install yourself | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping keys out of the sandbox | Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path rules | Secrets are copied into the codespace as environment variables | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the machine | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | A URL per forwarded port; SSH and CLI tunnels; no public IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Optional DNS-based domain allowlist set from outside; private IPs always blocked | Open internet; GitHub says there is no way to restrict it | Open internet, no provider-side allowlist |
| Desktop and browser | Headless; no desktop or browser product | VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Regions | Not selectable | US East, US West, Europe West and Southeast Asia | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | GitHub Codespaces | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or GitHub Codespaces: neither is in the hpc-sandbox-benchmarks results we use. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites and GitHub Codespaces 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 | Sprites, a month | GitHub Codespaces, 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 | $23 · Pay-as-you-go | $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 | $92 · Pay-as-you-go | $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 | $1,120 · Pay-as-you-go | $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 | $314 · 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 | $1,134 · Pay-as-you-go · with limits | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time it actually uses 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 buy fixed CPU, memory and storage allowances, not credit.
GitHub Codespaces: Codespaces bills $0.09 per core-hour for the whole time a codespace is active, used or not, plus $0.07 per GB-month of storage while it exists. There is no 4-core machine with 8 GB, so a 4 vCPU job runs on the 16 GB one.
GitHub Codespaces: 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
Every codespace stops after 12 hours at most, so it does not fit the always-on scenario without a restart script, and its processes end at each stop. A Sprite has no time cap but pauses when idle, so an always-on agent needs a task hold renewed every hour. Neither publishes how many machines can run at once on its default plan, so 300 user sandboxes and 1,000 jobs at once are not confirmed for either. boat has no session cap on paid plans, but at 1,000 short jobs at once it queues starts above 90 a minute and runs out of daily starts.
| Scenario | Sprites | GitHub Codespaces | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite |
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Sprites when
you run coding agents or user apps that sit idle most of the day and should wake on a request, or when you need a domain allowlist on outbound traffic.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day, a Sprite stops billing compute and wakes on the next request in under a second.
- Built for agents, with no session cap. Sprites ships Claude Code, Codex, Gemini CLI and Cursor and never stops on a timer, where a codespace stops at 12 hours.
- Egress allowlist and API connectors. Teams that must fence an agent in can limit the domains it reaches and the API paths a stored token may call.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, in the US, Europe or Asia.
- Built into GitHub. For teams on GitHub, a codespace opens from any repo, branch or pull request with the dev container already set up.
- A real editor for people. Developers get VS Code in the browser or on their machine, JupyterLab, port forwarding and prebuilds that keep setups the same.
- Free hours and more regions. A personal GitHub Free account includes 120 core-hours a month, and codespaces run in the US, Europe and Southeast Asia.
Where boat fits
If what you are really running is coding agents, not people in an editor, Sprites is the closer fit of the two, and boat is worth a look next to it. boat gives each agent a full VM that runs until you stop it, with systemd, /dev/kvm, a desktop, many open ports, forks and an API to drive the agents inside from outside.
Machines that keep running
A Sprite pauses when nothing holds it awake and drops open connections, so you renew a task hold every hour. A codespace stops at 12 hours and needs a restart script. A boat sandbox runs until you stop it.
A full VM with /dev/kvm and a desktop
Neither documents /dev/kvm, so Android emulators and microVMs are off the table, and neither has a graphical desktop for computer use. boat has root, systemd, /dev/kvm and a 60fps desktop with Chromium on every machine.
Fork, ports and agents you drive
Neither can copy a running machine, so every parallel try starts over. Sprites has one public HTTP port and Codespaces no public IP. boat forks running sandboxes, opens 50 HTTPS ports and raw TCP, and drives agents through one API.
Use boat when your agents need a full machine for hours or days: systemd, Docker and /dev/kvm, a desktop and browser, many open ports, forks, and an API to drive the agents inside from outside. Compare it one to one: boat vs Sprites and boat vs GitHub Codespaces.
Questions people ask
Is Sprites cheaper than GitHub Codespaces?
In every scenario we priced, yes: one coding agent on workdays is $23 a month on Sprites against $51 on Codespaces, and 50 agents in parallel are $1,120 against $3,019. On boat the same two come to $20 and $317 a month. Sprites bills only real CPU and memory use, so a mostly idle workload can cost less still.
Which is faster, Sprites or GitHub Codespaces?
We have no comparable CPU measurement for either one. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. A Sprite always has 8 vCPU, so a fair test would need a matching shape.
Can I run an agent 24/7 on Sprites or Codespaces?
On Codespaces, not without restarts: a codespace stops after 12 hours at most, even while in use. A Sprite has no time cap, but it pauses about 30 seconds after activity stops, so you hold it awake with its Tasks API for up to an hour at a time. A boat sandbox runs until you stop it.
Can Sprites and Codespaces run Docker?
Both run Docker. On Sprites users report that docker exec fails for containers whose main process is not root, and there is no systemd. Neither documents /dev/kvm, while every boat machine has Docker, systemd and /dev/kvm.
Can I SSH into a Sprite or a codespace?
Codespaces supports SSH through the GitHub CLI. On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. Neither gives the machine a public IP, while boat sandboxes have SSH, raw TCP and a dedicated IP.
Where do Sprites and Codespaces run?
Sprites does not let you choose a region. Codespaces runs in US East, US West, Europe West and Southeast Asia. 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