bochka vs Sprites

Sprites and bochka both give each agent its own Linux VM with a disk that survives. Sprites sleeps the moment work stops and wakes on the next request, while bochka gives the agent a fuller machine it can shape, with systemd, nested virtualization, a desktop, forks and coding agents you drive from outside.

Where bochka stands out

A machine you can shape, not a fixed box

A bochka sandbox runs systemd, Docker and /dev/kvm, so services, Android emulators and nested VMs work the way they do on any Linux server. You pick its size up to 16 vCPU / 32 GB, and reach it over SSH, raw TCP and HTTPS on up to 50 ports. A Sprite is a fixed 8 vCPU shape with no systemd and one public HTTP port.

Agents you drive from outside, and forks

Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API from your own code. You can fork a running sandbox to try two approaches from the same state. Sprites preinstalls agents too, but you run them through exec, and its checkpoints restore in place instead of making a copy.

A desktop and browser for computer use

Every bochka sandbox has a Linux desktop streamed at 60fps, with Chromium and computer use built in, and you can embed the stream in your app. A Sprite is headless, so a browser agent there runs blind.

The companies and products

bochka

bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.

You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.

Isolation: Full VM per sandbox, own kernel
Hardware: Dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Regions: EU: Germany, Finland, France
Plans: From $20 a month, all of it usage credit, 7-day trial

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.

Company: Fly.io, which also sells Fly Machines and Managed Postgres
Isolation: Firecracker microVM per Sprite
Machine shape: Fixed 8 vCPU and 100 GB disk; memory is set and scaled by the platform
Image: One managed Ubuntu 25.10 image; you install on top of it
Regions: Not selectable for Sprites
Compliance: SOC 2 Type II; HIPAA package with a pre-signed BAA on paid plans
Free start: $30 trial credit per organization

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. “3rd cheapest of 367” means 2 of the other 366 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	bochka: price rank	Sprites: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both keep a disk between runs; bochka adds systemd, /dev/kvm for Android emulators and more than one public port, which full-stack builds often need.	3rd cheapest of 367 $634 a month	66th of 367, with limits $546 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that waits on websockets or a queue stays billed on Sprites only while held awake, and its open connections drop on every pause; bochka just keeps the machine running.	5th cheapest of 366 $657 a month	157th of 366, with limits $1,166 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, bills only real CPU and memory, and wakes in under a second.	186th of 345, with limits $2,000 a month	93rd of 345, with limits $140 a month
Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both give each user a persistent VM with a URL; Sprites wakes it on the first request, while bochka gives each user SSH, raw TCP and up to 50 HTTPS ports.	Cheapest of 361 $209 a month	56th of 361, with limits $428 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month	34th of 360, with limits $2,000 a month	105th of 360, with limits $6,540 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month	10th cheapest of 364 $200 a month	125th of 364, with limits $545 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds Android apps or VM images needs /dev/kvm, which bochka exposes and the Sprites docs do not mention.	4th cheapest of 377 $86 a month	63rd cheapest of 377 $476 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box wants SSH and systemd; bochka has both, while Sprites tunnels SSH through its CLI and does not run systemd.	18th cheapest of 368 $26 a month	213th of 368, with limits $27 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: bochka streams a 60fps desktop with Chromium, and Sprites is headless.	6th cheapest of 369 $200 a month	85th of 369, with limits $136 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ships Chromium on a desktop you can watch; on Sprites you install and run a headless browser yourself.	7th cheapest of 367 $200 a month	171st of 367, with limits $122 a month
Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month	6th cheapest of 346 $90 a month	229th of 346, with limits $206 a month
Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month	71st of 338, with limits $1,800 a month	141st of 338, with limits $4,113 a month
Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month	2nd cheapest of 360 $200 a month	210th of 360, with limits $223 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
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

Key features

Feature	bochka	Sprites
Isolation	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts	Firecracker microVM with its own kernel
Machine size	You choose; up to 16 vCPU / 32 GB on the $100 plan and above	Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform
Inside the machine	Root, Docker, systemd and /dev/kvm for emulators and VMs	Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs
Idle behavior	Runs until you stop it or its time to live ends; a stopped sandbox costs nothing	Pauses about 30 seconds after activity stops, wakes on the next request in 100 to 500 ms with memory, or 1 to 2 s after a cold stop
Snapshots	Disk saved every minute and on stop; named snapshots to start new sandboxes from	Filesystem checkpoints by hand or automatic; restore replaces the current disk in place
Fork	Fork a running sandbox with its disk into a new one	No fork in the public API or CLI
Reaching the sandbox	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH	One HTTPS URL to one HTTP port, private by default; other ports and SSH only through the sprite proxy CLI on your machine
Outbound rules	Open internet, no provider-side allowlist	Optional DNS-based domain allowlist set from outside; private IPs always blocked
Keeping keys out of the sandbox	Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out	Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists
Coding agents	Seven agents preinstalled, with a prompt, steer and events API to drive them from outside	Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console
Desktop and browser	60fps desktop and Chromium, computer use and browser control, embeddable stream	Headless; no desktop or browser product
Integrations	REST API, CLI and SDKs	Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents
Regions	EU only (Germany, Finland, France), with EU data residency	Region not selectable
Compliance and transparency	SOC 2 is in progress. We're open about where we stand: live status and data retention policy.	SOC 2

Every feature Battleships tracks (43)

Feature	bochka	Sprites
Full VM (own kernel)	Yes	Yes
Docker inside	Yes	Yes
Nested virtualization	Yes	No
Root	Yes	Yes
Systemd	Yes	No
Desktop GUI	Yes	No
Browser	Yes	No
Computer-use API	Yes	No
SSH	Yes	No
Persistent disk	Yes	Yes
Pause/resume	Yes	Yes
Automatic snapshots	Yes	Yes
Fork/clone	Yes	No
Live fork (no pause)	Yes	No
Memory fork	No	No
Custom image (Docker or snapshot)	Yes	Yes
≥24 h sessions	Yes	Yes
Idle auto-stop	No	Yes
Wake on request	No	Yes
HTTPS preview URLs	Yes	Yes
Raw TCP inbound	Yes	No
Public IPv4	No	No
Egress allowlist	No	Yes
Secret proxy	Yes	Yes
Secret proxy for any API	Yes	Yes
Preinstalled agents	Yes	Yes
Agent harness API	Yes	No
MCP server	No	Yes
GPU	No	No
Windows	No	No
Arm64	No	No
Self-hosting	No	No
BYOC	No	No
Open source	No	No
Scoped API keys	Yes	Not published
Spend limits	Yes	Not published
Usage per sandbox (API)	Yes	No
Audit logs	No	Not published
SSO	No	Yes
SOC 2	No	Yes
HIPAA	No	Yes
EU data residency	Yes	No
Zero data retention	Yes	Not published

Performance

bochka26.69 runs/s

SpritesNot measured

There is no comparable measurement for Sprites yet: it is not in the hpc-sandbox-benchmarks results we use. 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. A Sprite always has 8 vCPU, so a fair test would also need a matching shape.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Sprites has 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	bochka, a month	Sprites, 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	$20 · $20/mo	$23 · Pay-as-you-go
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$26 · $20/mo	$92 · Pay-as-you-go
50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside	$317 · $20/mo × 3 seats	$1,120 · Pay-as-you-go
Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once	$200 · $100/mo × 2 seats	$314 · Pay-as-you-go · with limits
1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month	$2,000 · $2000/mo · with limits	$1,134 · Pay-as-you-go · with limits

bochka: 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.

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, plus storage on the bytes you write. Optional plans such as Hero at $100 a month include fixed CPU-hour, memory-hour and storage allowances that are not credit, and anything above them bills at the normal rates.

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; its plans list running caps, and creation is 10 a minute without a plan. A Sprite stays billed only while something keeps it awake, and open TCP connections drop on every pause, so an always-on agent needs a task hold that lasts at most an hour and must be renewed. bochka has no session cap on paid plans, but at 1,000 short jobs at once even the $2,000 plan queues starts above 90 a minute and runs out of daily starts. Each Sprite also has a fixed 100 GB disk.

Scenario	bochka	Sprites
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	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
Sandboxes for your users	None that bite	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
1,000 short jobs at once	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)

Which one should you use?

Use Sprites when

your agents or apps 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. Useful for agents and apps that sit idle most of the day: a Sprite stops billing compute and wakes on the next request.
Egress allowlist and API connectors. Sprites can limit which domains an agent reaches, and limit which API paths it can call through a stored credential.
Plugs into agent platforms. Teams already on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them.

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.

A machine you can shape, not a fixed box. On Sprites, a stack that expects systemd units needs rewriting as Sprite services, emulators have no /dev/kvm, and a second public port or a database client has to go through the sprite proxy on your own machine.
Agents you drive from outside, and forks. Without a driving API you write the code that starts, prompts and watches each agent. Without fork, trying two fixes from one state on Sprites means building the second machine again from the start.
A desktop and browser for computer use. Agents that test web apps or work through sites need a screen to look at and a browser to click. On Sprites you would install a display server, a browser and a streaming layer yourself.

Questions people ask

Is bochka cheaper than Sprites?

In four of the five scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $23 on Sprites, one agent that never stops is $26 versus $92, and 50 agents in parallel are $317 versus $1,120. For 1,000 short jobs at once, Sprites comes to $1,134 against $2,000, but neither fits that burst as published. Sprites bills real CPU use, so a mostly idle workload can cost less than these estimates.

Does a Sprite keep running when I am not using it?

No. A Sprite pauses about 30 seconds after activity stops, and open connections drop. To keep an agent working you register a task through its Tasks API, which holds the Sprite awake for up to an hour at a time. A bochka sandbox keeps running until you stop it.

Can I run Docker, systemd and Android emulators on each?

bochka runs Docker, systemd and /dev/kvm in every sandbox, so emulators and nested VMs work. Users run Docker on Sprites, but its docs say Sprites don't run systemd, and they do not mention /dev/kvm.

Can I SSH into a Sprite?

Not directly. The Sprites docs say to install an SSH server yourself and tunnel it through the sprite proxy CLI. bochka sandboxes have SSH, raw TCP and a dedicated IP.

Where do Sprites and bochka run?

Sprites does not let you choose a region. bochka runs only in the EU, in Germany, Finland and France, with EU data residency and a zero data retention option.

Is bochka SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.

Start a sandbox

Install the CLI, then run bochka new.

Product preview