Sprites vs Replit
Sprites gives your code persistent Linux VMs for agents, created by API, that sleep when idle and wake on the next request. Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it.
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 that scales from 2 GB to 16 GB as needed, and a 100 GB ext4 disk backed by object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled. It gets an HTTPS URL that wakes it, and it bills only for the CPU and memory it 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
- Free start
- $30 trial credit per organization
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. This page compares the parts where the two overlap.
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 374” means 62 of the other 373 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 | Replit: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites gives each agent a machine your code creates. Replit's entry point from outside is an MCP server that drives Replit Agent, with up to 10 parallel Agent tasks on Pro. boat adds systemd, /dev/kvm and up to 50 public HTTPS URLs. | 101st of 365, with limits $546 a month | 204th of 365, with limits $2,000 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant drops its open connections each time a Sprite pauses. On Replit it is a Reserved VM that runs all month at a fixed price. boat keeps running once you turn auto-stop off (default 1 hour). | 214th of 361, with limits $1,166 a month | 246th of 361, with limits $2,033 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 Sprites fits short code runs well: it sleeps about 30 seconds after the last command and bills only the CPU and memory it really uses. | 99th of 336, with limits $140 a month | 225th of 336, with limits $146 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 Neither Sprites nor Replit publishes how many machines can run at once on its default plan, so 300 user sandboxes is not confirmed on either. boat runs 300 at once on the $100 plan. | 61st of 349, with limits $428 a month | 229th of 349, with limits $825 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 | 114th of 349, with limits $6,540 a month | 253rd of 349, with limits $4,226 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 | 130th of 359, with limits $545 a month | 266th of 359, with limits $685 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 that builds containers needs Docker. It runs on Sprites; Replit's docs set up environments with Nix and do not describe Docker. boat also gives /dev/kvm for Android builds. | 63rd cheapest of 374 $476 a month | 278th of 374, with limits $425 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Replit's workspace is a good place to code by hand, with SSH on paid plans. On Sprites you tunnel SSH through its CLI. boat gives a dev box with SSH and systemd. | 120th cheapest of 371 $27 a month | 181st of 371, with limits $109 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 Computer-use agents need a screen. On Sprites you install a display yourself. Replit's VNC pane streams a native desktop to a person in the workspace, with no computer-use API. boat streams a 60fps desktop with computer tools. | 132nd of 367, with limits $136 a month | 225th of 367, with limits $619 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 On Sprites you install and run a browser yourself. Replit's docs describe no browser-control API. boat ships Chromium on a desktop you can watch. | 236th of 356, with limits $122 a month | 277th of 356, with limits $317 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 | 279th of 343, with limits $206 a month | 282nd of 343, with limits $217 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 | 139th of 327, with limits $4,113 a month | 147th of 327, with limits $4,378 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 | 243rd of 351, with limits $223 a month | 241st of 351, with limits $215 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 requirement | Not ranked: misses a requirement | Not 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 requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Sprites | Replit | boat |
|---|---|---|---|
| Kind of product | Persistent Linux VMs for agents, created by API or CLI | AI app builder with browser workspaces and app hosting | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Firecracker microVM with its own kernel | Not documented for workspaces; the security page says strong logical separation between users | Full VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared |
| Creating machines from code | API and CLI to create Sprites; 10 creates a minute without a plan | MCP server tools to create, update and publish apps, with up to 10 parallel Agent tasks on Pro; the docs describe no API to start many machines | API, SDK and CLI to create, stop, resume and fork many sandboxes, within each plan's start limits |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as needed | Reserved VMs at fixed sizes with dedicated vCPUs, such as 4 vCPU / 16 GB | 2 to 16 vCPU and 4 to 32 GB; 16 vCPU needs the $100 plan or higher; disk fixed per size (51 to 251 GB) |
| Inside the machine | Root and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docs | System packages come from Nix; the docs do not describe Docker, systemd or /dev/kvm | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Idle behavior | Pauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 ms | Autoscale apps wake on the first request and go idle after 15 minutes, with no compute charge while idle; a Reserved VM runs all month | Runs until auto-stop (1 hour by default) and bills its full size, busy or idle; no compute charge while stopped |
| Files over time | 100 GB disk backed by object storage; checkpoints restore in place | Workspace files persist; Agent checkpoints save files, database and settings at milestones for rollback; published apps keep data in Postgres or App Storage | Disk saved every minute and at each stop; saved snapshots to start new sandboxes from |
| Fork | No fork in the CLI or API docs | No fork of a running machine in the docs; Agent checkpoints roll a project back | Fork a running sandbox from its latest disk save (taken every minute) |
| Reaching the machine | One HTTPS URL to one HTTP port; other ports and SSH through the sprite proxy CLI | Published apps on HTTPS domains, custom domains and private deployments; static outbound IPs on Enterprise; SSH into the workspace on paid plans | HTTPS URLs for up to 50 ports, token-protected; SSH through a shared IPv4 host and port; public IPv6 for raw ports; no dedicated IPv4 |
| Keeping keys out of the sandbox | Connectors gateway holds the token for any HTTP API, with path allow and block lists | Replit manages keys for OpenAI, Anthropic, Google, Grok and OpenRouter models, billed to credits; other keys are secrets in the app | Optional paid credentials proxy ($1 per day on plus $1 per 1,000 requests) for model providers and any HTTPS API |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Replit Agent, which you can also drive from an MCP client | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and computer use | No desktop or browser built in; you install a browser, a display server and a stream yourself | VNC pane that streams a native desktop to your browser; the docs describe no computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Databases and storage | Fly.io sells Managed Postgres in the same account | Postgres and App Storage built into each app | No hosted databases; run your own inside a sandbox |
| Regions | No region option when you create a Sprite | North America, Europe, Asia, South America and Australia for published apps on Core and up | Germany, Finland and France; you cannot pick one; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Sprites | Replit | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No documented way | Not published | Yes |
| Desktop GUI | No documented way | Yes | Yes |
| Browser | No documented way | No documented way | Yes |
| Computer-use API | No documented way | No documented way | Yes |
| SSH | With your own setup | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No documented way | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No documented way | Yes | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | No documented way | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | Yes | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | Not published | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | No documented way | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | Yes | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | No documented way | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | Not published | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | No documented way | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No documented way | Yes | Yes |
| Audit logs | Not published | Yes | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | No documented way | No documented way |
| EU data residency | No documented way | Yes | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
Sprites and Replit are not in the public benchmarks we use, so we cannot say which is faster. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). 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.
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. Sprites and Replit 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.
| Scenario | Sprites, 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 | $23 · Pay-as-you-go | $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 | $92 · Pay-as-you-go | $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 | $1,120 · Pay-as-you-go | $6,092 · Pro $2,500 (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 | $314 · 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 | $1,134 · Pay-as-you-go · with limits | $825 · Pro $1,000 (annual) · with limits | $8,800 · $2000/mo · with limits |
Sprites: Sprites bills CPU time measured by cpu.stat at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake. Storage costs about $0.50 per GB-month for hot data while awake and about $0.02 per GB-month for cold data. Pay as you go has no plan fee. Optional plans, such as Hero at $100 a month, buy fixed allowances that are not credit.
Replit: Replit plans (Core $20, or $18 billed annually; Pro from $100) turn into monthly credits for Agent work and hosting, then usage goes on to pay-as-you-go up to a budget you set. A Reserved VM has a fixed monthly price per size, such as $130 for 4 vCPU / 16 GB with dedicated vCPUs, and bills busy or idle. Autoscale charges a $2 monthly base fee plus $0.60 per million compute units and $0.40 per million requests while it serves.
Replit: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Included VM time expires at the end of the billing period. You pay per second for the size you pick while a sandbox runs: $0.036 an hour for 4 vCPU / 8 GB, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk for at least 14 days. Saved snapshots above the plan's included count and the optional AI credentials proxy still charge while sandboxes are stopped.
Limits in those scenarios
Sprites does not publish how many Sprites can run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed. Replit is marked as not a fit in every scenario because it is an app platform: each always-on agent is one published Reserved VM billed all month, so 50 agents means 50 published apps. Replit does not publish how many deployments can run at once, and its docs do not describe Docker. boat auto-stops after 1 hour by default; you can set up to 30 days or turn it off on a paid plan. Each boat plan caps starts. The $2,000 plan includes 90 a minute and 2,400 a day, charges $0.03 to $0.07 per extra start and refuses starts above 270 a minute, so boat does not fit 1,000 short jobs at once. boat never queues a start. A machine failure on boat loses writes made after the last 1-minute disk save.
| Scenario | Sprites | Replit | boat |
|---|---|---|---|
| One coding agent, workdays | None for this scenario |
| None for this scenario |
| One agent that never stops | None for this scenario |
| None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Sprites when
your code needs to give each agent its own persistent VM that sleeps when idle and wakes on a request, or when you need a domain allowlist on outbound traffic.
- Machines your code creates. For teams building agent products: Sprites gives each agent its own persistent VM, created by API, with coding agents preinstalled.
- Sleeps when idle, wakes on request. For agents that sit idle most of the day: a Sprite pauses, stops billing compute and wakes on the next request.
- Egress allowlist and API connectors. For teams that want tight outbound rules: a Sprite can be limited to listed domains and to allowed API paths.
Use Replit when
you want Replit Agent to build a web app from a description and host it for you, with databases, hosting that sleeps when idle, or regions outside Europe.
- An app built and hosted for you. For people who want a working app from a description: Replit Agent builds, tests and publishes it, with Postgres and storage.
- Hosting that sleeps when idle. For web apps with uneven traffic: Autoscale wakes on the first request and has no compute charge while idle, plus a $2 monthly base fee.
- Regions on five continents. For users outside Europe: Replit publishes apps in North America, Europe, Asia, South America and Australia.
Where boat fits
If you are choosing between Sprites and Replit to run AI agents, look at boat when those agents need a full Linux machine for hours, not a sleeping VM or a hosted app. boat gives each agent a full VM with systemd, Docker and /dev/kvm, a 60fps desktop, forks, and an API to drive the coding agents inside from outside. boat bills its full size while it runs, has no hosted databases and no US or Asia region, and caps starts per plan.
A full Linux machine
Sprites runs services through its own API instead of systemd, and its docs do not mention /dev/kvm. Replit's docs set up environments with Nix and do not describe Docker. boat runs docker compose stacks, systemd services and Android emulators as on any Linux server.
Agents that keep running, driven from outside
A Sprite pauses about 30 seconds after work stops and drops open connections, so long jobs need a task hold renewed every hour. Replit's MCP server drives Replit Agent. boat has no session cap once auto-stop is off on a paid plan, and a prompt, steer and events API for seven agents.
A screen, many ports and forks
On Sprites you install a screen yourself, and there is one public HTTP port. Replit's VNC pane serves a person in the workspace, not an agent API. Neither documents a fork of a running machine. boat has a 60fps desktop, 50 HTTPS URLs and fork from the latest 1-minute disk save.
Use boat when your agents need a full machine for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: boat vs Sprites and boat vs Replit.
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 Sprites cheaper than Replit?
For agent machines, in four of the five scenarios we priced, yes, because Sprites bills only while awake and a Replit Reserved VM bills all month. One agent on workdays is $23 on Sprites, $122 on Replit and $20 on boat. One agent that never stops is $92, $122 and $26. 50 agents in parallel are $1,120, $6,092 and $317. Sandboxes for your users are $314 on Sprites and $403 on Replit, neither confirmed at 300 at once, and $200 on boat. For 1,000 short jobs at once Replit is lower at $825 against $1,134 on Sprites, and none of the three fits as published. The Replit Reserved VM we price has dedicated vCPUs and 16 GB of RAM.
Which is faster, Sprites or Replit?
Neither is in the public benchmarks we use, so we cannot say. A Sprite always has 8 vCPU, while Replit sells Reserved VMs in fixed sizes with dedicated vCPUs. boat did 28.06 V8 Web Tooling runs/s at 4 vCPU / 8 GB in StarSling's run of 3 October 2026, on a Ryzen 9 9950X host; boat does not promise a CPU model.
Can Sprites or Replit run Docker?
Docker runs inside a Sprite, though a user reports docker exec failing for containers that do not run as root, and services run through the Sprites services API instead of systemd. Replit sets up environments with Nix packages, and its docs do not describe running Docker. Every boat sandbox has root, systemd, Docker and /dev/kvm.
Is Replit a sandbox for AI agents like Sprites?
Not in the same sense. Sprites gives your code VMs for agents by API. Replit is an app builder where Replit Agent writes and publishes apps, driven from outside through its MCP server. boat is built for the first job, with an API to drive Claude Code, Codex and other agents inside.
Can I SSH into Sprites or Replit?
On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. Replit lets you SSH into a workspace on paid plans. boat sandboxes have SSH from the start, through a shared IPv4 host and port. boat does not sell a dedicated IPv4, and the IP changes at each resume.
Where do Sprites and Replit run?
Sprites has no region option. Replit hosts data mainly on Google Cloud in the United States, with an optional India region, and on Core and up you can publish apps in North America, Europe, Asia, South America or Australia. boat runs on machines in Germany, Finland and France, and you cannot pick one. boat has no US or Asia region, and boat can store snapshot copies outside the EU.
Try boat
Install the CLI, then run boat new.
7-day free trial