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 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
Replit
Replit is an AI app builder and hosting platform: you describe an app in chat, Replit Agent writes it, and Replit publishes it.
You work in a browser workspace where Replit Agent sets up the project, writes the code, tests it and fixes problems, with system packages managed by Nix. When the app is ready you publish it as an Autoscale, Static, Scheduled or Reserved VM deployment, with Postgres and object storage next to it. It is built for people and teams who want a working app, not for programs that need to create many machines by API, so this page compares the parts where the two overlap.
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 | Replit: price rank | bochka: 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, while Replit's outside entry point is an MCP server that drives Replit Agent one app at a time; bochka adds systemd, /dev/kvm and many public ports. | 66th of 367, with limits $546 a month | 181st of 367, with limits $2,000 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant drops its open connections each time a Sprite pauses, and on Replit it is a Reserved VM billed all month; bochka just keeps the machine running. | 157th of 366, with limits $1,166 a month | 202nd of 366, with limits $2,033 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month 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. | 93rd of 345, with limits $140 a month | 228th of 345, with limits $146 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 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; bochka fits this one. | 56th of 361, with limits $428 a month | 233rd of 361, with limits $825 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 105th of 360, with limits $6,540 a month | 258th of 360, with limits $4,226 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 125th of 364, with limits $545 a month | 265th of 364, with limits $685 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds containers needs Docker, which runs on Sprites with rough edges and is not documented on Replit; bochka also gives /dev/kvm for Android builds. | 63rd cheapest of 377 $476 a month | 275th of 377, with limits $425 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Replit's workspace is a good place to code by hand, Sprites tunnels SSH through its CLI, and bochka gives a dev box with SSH and systemd. | 213th of 368, with limits $27 a month | 165th of 368, with limits $109 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Computer-use agents need a screen: Sprites is headless, Replit's VNC pane is for a person in the workspace, and bochka streams a 60fps desktop with computer use. | 85th of 369, with limits $136 a month | 190th of 369, with limits $619 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month On Sprites you install and run a headless browser yourself, and Replit has no browser-control API; bochka ships Chromium on a desktop you can watch. | 171st of 367, with limits $122 a month | 229th of 367, with limits $317 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 229th of 346, with limits $206 a month | 234th of 346, with limits $217 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 141st of 338, with limits $4,113 a month | 150th of 338, with limits $4,378 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 210th of 360, with limits $223 a month | 208th of 360, with limits $215 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Can't run it | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Sprites | Replit | bochka |
|---|---|---|---|
| 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; the security page says strong logical separation between users | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| 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; no API to start many machines | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | Reserved VMs at fixed sizes, such as 4 vCPU / 16 GB; workspace sizes no longer published | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Inside the machine | Root and Docker (with rough edges users report); no systemd, and 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; a Reserved VM runs all month | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Files over time | 100 GB disk synced to object storage; checkpoints restore in place | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Disk saved every minute and on stop; named snapshots to start new sandboxes from |
| Fork | No fork in the public API or CLI | No fork of a running machine | Fork a running sandbox with its disk into a new one |
| Reaching the machine | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | Published apps on HTTPS and custom domains; SSH into the workspace on paid plans | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IP; SSH |
| Outbound rules | Optional DNS-based domain allowlist set from outside; private IPs always blocked | No provider-side allowlist | Open internet, no provider-side allowlist |
| 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 and OpenRouter models; other keys are secrets in the app | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| 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 | Headless; no desktop or browser product | VNC pane that streams a native desktop to your browser; no computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Regions | Region not selectable | North America, Europe, Asia, South America and Australia for published apps on Core and up | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | Replit | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | No | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | Yes | 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 | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Not published | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | Yes | 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 measurement for Sprites or Replit: neither is in the hpc-sandbox-benchmarks results we use, so we cannot say which of the two is faster. bochka did 26.69 runs per second on the Node.js build-and-test test 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 Replit have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Sprites, a month | Replit, a month | bochka, 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 | $1,330 · Pro $1,000 (annual) · with limits | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $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 | $2,000 · $2000/mo · with limits |
Sprites: Sprites bills CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans such as Hero at $100 a month buy fixed CPU-hour, memory-hour and storage allowances, not credit.
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting, then usage goes on to pay-as-you-go. A Reserved VM has a fixed monthly price per size, such as $130 for 4 vCPU / 16 GB, and bills whether busy or idle.
Replit: 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
Sprites fits the single-agent and 50-agent scenarios, but it 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, its concurrency is not published, and it does not document Docker or a disk you can rely on in a published app. On bochka, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | Sprites | Replit | bochka |
|---|---|---|---|
| One coding agent, workdays | 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
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 costs nothing when idle. For web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.
- Regions on five continents. For users outside Europe: Replit publishes apps in North America, Europe, Asia, South America and Australia.
Where bochka fits
If you are choosing between Sprites and Replit to run AI agents, look at bochka when those agents need a full Linux machine for hours, not a sleeping VM or a hosted app. bochka 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.
A full Linux machine
Sprites has no systemd or /dev/kvm, and users report docker exec failing for containers like Postgres. Replit's docs do not describe Docker at all. On both, docker compose stacks, services and Android emulators need rewriting or get dropped.
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 only Replit Agent. bochka has no session cap on paid plans and a prompt, steer and events API.
A screen, many ports and forks
Sprites is headless with one public HTTP port, and Replit's VNC pane is for a person, not an agent. Neither forks a running machine, so trying two fixes means rebuilding the second one. bochka has a 60fps desktop, 50 HTTPS ports and fork.
Use bochka 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: bochka vs Sprites and bochka vs Replit.
Questions people ask
Is Sprites cheaper than Replit?
For agent machines, yes in four of the five scenarios we priced, because Sprites bills only while awake and a Replit Reserved VM bills all month. One agent that never stops comes to $92 on Sprites and $122 on Replit, and 50 agents in parallel come to $1,120 versus $1,330. For 1,000 short jobs at once Replit is lower at $825 against $1,134, but neither fits as published.
Which is faster, Sprites or Replit?
We cannot say: neither Sprites nor Replit is in the public benchmark we use. A Sprite always has 8 vCPU, while Replit sells Reserved VMs in fixed sizes. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Can Sprites or Replit run Docker?
Docker runs inside a Sprite, but a community report shows docker exec failing for containers whose main process is not root, and Sprites does not run systemd. Replit sets up environments with Nix packages and its docs do not describe Docker. Every bochka 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, while Replit is an app builder where Replit Agent writes and publishes apps, driven from outside only through its MCP server. bochka 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. bochka sandboxes have SSH, raw TCP and a dedicated IP.
Where do Sprites and Replit run?
Sprites does not let you choose a region. Replit hosts data mainly on Google Cloud in the United States, and on Core and up you can publish apps in North America, Europe, Asia, South America or Australia. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview