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.

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 workloadSprites: price rankReplit: price rankboat: 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 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

FeatureSpritesReplitboat
Kind of productPersistent Linux VMs for agents, created by API or CLIAI app builder with browser workspaces and app hostingSandboxes you create, stop and fork by API, SDK or CLI
IsolationFirecracker microVM with its own kernelNot documented for workspaces; the security page says strong logical separation between usersFull 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 codeAPI and CLI to create Sprites; 10 creates a minute without a planMCP 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 machinesAPI, SDK and CLI to create, stop, resume and fork many sandboxes, within each plan's start limits
Machine sizeFixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as neededReserved VMs at fixed sizes with dedicated vCPUs, such as 4 vCPU / 16 GB2 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 machineRoot and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docsSystem packages come from Nix; the docs do not describe Docker, systemd or /dev/kvmRoot, Docker, systemd and /dev/kvm for emulators and VMs
Idle behaviorPauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 msAutoscale apps wake on the first request and go idle after 15 minutes, with no compute charge while idle; a Reserved VM runs all monthRuns until auto-stop (1 hour by default) and bills its full size, busy or idle; no compute charge while stopped
Files over time100 GB disk backed by object storage; checkpoints restore in placeWorkspace files persist; Agent checkpoints save files, database and settings at milestones for rollback; published apps keep data in Postgres or App StorageDisk saved every minute and at each stop; saved snapshots to start new sandboxes from
ForkNo fork in the CLI or API docsNo fork of a running machine in the docs; Agent checkpoints roll a project backFork a running sandbox from its latest disk save (taken every minute)
Reaching the machineOne HTTPS URL to one HTTP port; other ports and SSH through the sprite proxy CLIPublished apps on HTTPS domains, custom domains and private deployments; static outbound IPs on Enterprise; SSH into the workspace on paid plansHTTPS 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 sandboxConnectors gateway holds the token for any HTTP API, with path allow and block listsReplit manages keys for OpenAI, Anthropic, Google, Grok and OpenRouter models, billed to credits; other keys are secrets in the appOptional paid credentials proxy ($1 per day on plus $1 per 1,000 requests) for model providers and any HTTPS API
Coding agentsClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a consoleReplit Agent, which you can also drive from an MCP clientSeven agents preinstalled, with a prompt, steer and events API to drive them from outside
Desktop and computer useNo desktop or browser built in; you install a browser, a display server and a stream yourselfVNC pane that streams a native desktop to your browser; the docs describe no computer-use API60fps desktop and Chromium, computer use and browser control, embeddable stream
Databases and storageFly.io sells Managed Postgres in the same accountPostgres and App Storage built into each appNo hosted databases; run your own inside a sandbox
RegionsNo region option when you create a SpriteNorth America, Europe, Asia, South America and Australia for published apps on Core and upGermany, Finland and France; you cannot pick one; no US or Asia region
Every feature Battleships tracks (43)
FeatureSpritesReplitboat
Full VM (own kernel)YesYesYes
Docker insideYesNot publishedYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesNot publishedYes
SystemdNo documented wayNot publishedYes
Desktop GUINo documented wayYesYes
BrowserNo documented wayNo documented wayYes
Computer-use APINo documented wayNo documented wayYes
SSHWith your own setupYesYes
Persistent diskYesYesYes
Pause/resumeYesNo documented wayYes
Automatic snapshotsYesYesYes
Fork/cloneNo documented wayYesYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesYesNo documented way
Wake on requestYesYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNot publishedYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesNo documented wayNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayYesYes
MCP serverYesYesNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNot publishedNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)No documented wayYesYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyNo documented wayYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

SpritesNot measured
ReplitNot measured
boat28.06 runs/s

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.

ScenarioSprites, a monthReplit, 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
$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.

ScenarioSpritesReplitboat
One coding agent, workdaysNone for this scenario
  • different kind of product: app platform
  • monthly / always-on product: priced as 1 machines kept on and reused
None for this scenario
One agent that never stopsNone for this scenario
  • different kind of product: app platform
None for this scenario
50 agents in parallel
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
  • not confirmed: Docker inside
  • different kind of product: app platform
  • monthly / always-on product: priced as 50 machines kept on and reused
  • 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
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • 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 for this scenario
1,000 short jobs at once
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 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)
  • 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 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

More comparisons