Sprites vs smol machines
Both give each agent its own small Linux VM with its own kernel. Sprites is one fixed, managed machine that sleeps when idle and wakes on a request, while smol machines lets you pick the size, branch a running machine with its memory, and run the same open-source engine on your own servers.
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
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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 | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 66th of 367, with limits $546 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant waiting on a queue drops its open connections on every Sprite pause, and smol cloud's terminal caps each connection at one hour; bochka just keeps the machine running. | 157th of 366, with limits $1,166 a month | 148th of 366, with limits $1,038 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 Both fit short code runs, but smol machines ranks 12th to Sprites at 93rd: a one-minute minimum, a /code endpoint, and branches of a warm machine. | 93rd of 345, with limits $140 a month | 12th cheapest of 345 $140 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 smol machines ranks 7th, with published caps up to 1,000 machines on Startup; Sprites does not publish how many run at once on pay as you go, and bochka ranks 1st. | 56th of 361, with limits $428 a month | 7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, so rollouts start from one prepared state; Sprites checkpoints restore in place and have no fork. | 105th of 360, with limits $6,540 a month | 111th of 360, with limits $6,978 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 smol machines ships a registry image with the Harbor eval harness and branches warm machines; bochka adds a desktop and coding agents you drive from outside. | 125th of 364, with limits $545 a month | 36th cheapest of 364 $670 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 Sprites nor smol cloud exposes /dev/kvm, so CI that builds Android apps or VM images needs bochka. | 63rd cheapest of 377 $476 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box wants SSH and systemd; Sprites has no systemd and tunnels SSH through its CLI, smol cloud has no SSH, and bochka has both. | 213th of 368, with limits $27 a month | 216th of 368, with limits $29 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: Sprites has no desktop, and smol machines only documents running your own Chromium; bochka streams a 60fps desktop with computer use. | 85th of 369, with limits $136 a month | 90th of 369, with limits $156 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 | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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 | smol machines | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory set and scaled by the platform | You choose; up to 8 vCPU / 16 GB on Standard, 16 vCPU / 24 GB on Pro, 32 vCPU / 32 GB on Startup | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Image | One managed Ubuntu image with nothing to choose; you install on top | OCI images and registry images in amd64 and arm64 | Docker and seven coding agents preinstalled, plus named snapshots to start new sandboxes from |
| Inside the machine | Root and Docker, with rough edges users report; no systemd, no /dev/kvm in the docs | Docker inside, with its data on the machine's ext4 disk; no nested virtualization on hosted machines | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Idle behavior | Pauses about 30 seconds after work stops, wakes on the next request in 100 to 500 ms with memory | Idle apps scale to zero and wake on the next request; a command starts a stopped machine | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing |
| Snapshots and fork | Filesystem checkpoints that restore in place; no fork | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Disk saved every minute and on stop; fork a running sandbox with its disk |
| Shell access | Exec and console; SSH only through the sprite proxy CLI on your machine | Command API and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | One HTTPS URL to one HTTP port; other ports only through the proxy CLI | Up to 16 published ports; no dedicated IP | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6 |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Connectors gateway holds tokens for any HTTP API, with path allow and block lists | Cloud secrets are environment variables the guest can read | 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 | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no desktop or browser product | No hosted desktop; a guide shows running your own Chromium | 60fps Linux desktop, Chromium and computer use built in |
| Self-hosting | No; hosted on Fly.io only | Open-source smolvm runs on your laptop or your own servers | No; hosted only |
| Regions | Not selectable | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | 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 | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | 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 | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Sprites or smol machines: neither is in the StarSling hpc-sandbox-benchmarks results we use. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which is start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites and smol machines 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 | smol machines, 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 | $25 · Standard | $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 | $93 · Standard | $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,139 · Pro | $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 | $465 · Startup | $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,389 · Startup | $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 awake, plus storage on the bytes you write. Optional plans such as Hero at $100 a month buy fixed CPU, memory and storage allowances, not credit.
smol machines: smol cloud charges $0.04 for every hour a machine runs, plus $0.05 per active vCPU-hour and $0.0162 per active GB-hour of memory, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage.
smol machines: Plans start at $20 a month, and the whole fee is usage credit. You pay per second for the size you pick while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Sprites does not publish how many Sprites run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed there. smol machines publishes caps of 20, 100 and 1,000 machines on Standard, Pro and Startup, with stopped machines still holding a slot, so 50 agents need Pro and 1,000 jobs need Startup. bochka fits every scenario but the 1,000-job burst, where even the $2,000 plan queues starts above 90 a minute.
| Scenario | Sprites | smol machines | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use Sprites when
your agents sit idle most of the day and should wake on a request with their memory intact, or you already run on Fly.io or Claude Managed Agents.
- Wakes with its memory intact. For agents idle most of the day: a Sprite pauses after 30 seconds and wakes in under a second with processes still running.
- Connectors with path rules. Teams handing agents a GitHub or Slack token can keep it outside the VM and allow or block specific API paths.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, next to the rest of Fly.io.
Use smol machines when
you want to branch running machines with their memory, choose machine sizes and images, or run the same open-source VM engine on your own servers.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine into children that keep its memory and running processes.
- Open source, laptop to your servers. Teams that want one VM engine locally, in a hosted cloud and on their own servers can use smolvm for all three.
- Sizes, images and published caps. You pick the machine size and image, including arm64, and plans publish how many machines you can hold, up to 1,000.
Where bochka fits
Sprites and smol machines are both strong at small VMs that sleep and wake fast. If your agents work for hours on real projects and need a whole Linux machine, a desktop and a way to drive them from your own code, bochka is built for that.
A whole machine, not a trimmed one
Sprites runs no systemd and has no /dev/kvm in its docs; smol cloud has no SSH and no nested virtualization. Stacks with systemd units, Android emulators or SSH tools get rewritten on both, while bochka runs them as is.
A screen for computer use
Both are headless, so a computer-use agent has nothing to look at. You would install a display server, a browser and a streaming layer yourself; bochka streams a 60fps desktop with Chromium in every sandbox.
Agents you drive from outside
Sprites and smol machines preinstall some agents, but you run them through exec calls and write the harness that prompts and watches them. bochka gives you one API to prompt, steer and follow seven agents.
Use bochka when your agents need a whole machine for hours: systemd, Docker, emulators, SSH, many ports, a desktop and browser, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Sprites and bochka vs smol machines.
Questions people ask
Is Sprites cheaper than smol machines?
Slightly, in our scenarios: one coding agent on workdays is $23 a month on Sprites and $25 on smol machines, and 50 agents in parallel are $1,120 against $1,139. bochka comes to $20 and $317 for the same two. Both Sprites and smol bill real CPU and memory use, so idle machines cost less than these estimates.
Which is faster, Sprites or smol machines?
Neither has a comparable CPU measurement in the benchmarks we use, so we cannot say. Sprites documents waking in 100 to 500 ms with memory, and smol machines publishes a boot time under 200ms for smolvm. bochka did 26.69 runs per second on the Node.js build-and-test loop.
Can Sprites and smol machines run Docker?
Both run Docker inside the VM. On Sprites, users report docker exec failing for containers that run as non-root, and smol's guide says Docker data must live on the machine's ext4 disk. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Can I fork a running machine?
On smol machines, yes: it branches a running machine into children that keep its memory and processes. Sprites has no fork, and its checkpoints restore the disk in place. bochka forks a running sandbox with its disk, and the fork boots fresh.
Can I SSH into Sprites or smol machines?
Not directly. Sprites tunnels SSH through its proxy CLI, and smol cloud offers a command API and a terminal capped at one hour per connection. bochka sandboxes have SSH, raw TCP and a dedicated IP.
Can I self-host either one?
smol machines, yes: smolvm is open source and runs on macOS, Linux and Windows hosts, with the same machine artifact as smol cloud. Sprites runs only on Fly.io, and bochka is a hosted service only.
Try bochka
Install the CLI, then run bochka new.
Product preview