Runloop vs Sprites

Runloop gives each agent a devbox you build from a Dockerfile blueprint and size yourself, with tools for evals, RL and your own cloud. Sprites gives each agent a fixed 8 vCPU Linux VM that keeps its disk, sleeps seconds after work stops and wakes on the next request.

The companies and products

Runloop

Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.

You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.

Isolation: Micro-VM on a custom bare-metal hypervisor, with a container layer on top
Compliance: SOC 2 Type 2
Architectures: x86_64 and arm64 base blueprints
Own-cloud deploy: Deploy to VPC on AWS, GCP and Azure (Enterprise)
Regions: Not documented or selectable
Plans: Basic (usage only), Pro ($250/month plus usage), Enterprise (custom)
Company: Runloop AI, Inc.

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. “20th cheapest of 367” means 19 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	Runloop: price rank	Sprites: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Runloop fits fully with Dockerfile blueprints and devboxes you size; Sprites is a compromise with one fixed shape and one public HTTP port, and bochka adds systemd and /dev/kvm.	20th cheapest of 367 $8,152 a month	66th of 367, with limits $546 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB A Sprite pauses about 30 seconds after work stops and drops open connections, while Runloop keeps a devbox up under an idle policy; bochka just keeps the machine running.	32nd cheapest of 366 $10,194 a month	157th of 366, with limits $1,166 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 suits short code runs that sit idle in between, since it bills only real CPU and memory while awake and wakes in under a second.	44th cheapest of 345 $525 a month	93rd of 345, with limits $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	26th cheapest of 361 $3,301 a month	56th of 361, with limits $428 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 Runloop ranks 4th here: it starts large waves without published start limits and sells RL fine-tuning on Enterprise.	4th cheapest of 360 $15,922 a month	105th of 360, with limits $6,540 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	81st cheapest of 364 $2,562 a month	125th of 364, with limits $545 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 Sprites ranks 63rd for CI, ahead of Runloop at 121st, and both fit fully; bochka's faster CPUs finish builds sooner.	121st cheapest of 377 $1,554 a month	63rd cheapest of 377 $476 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Sprites keeps its disk and costs little while idle, but has no systemd or direct SSH; Runloop needs an idle policy to run all month, and bochka has both SSH and systemd.	113th cheapest of 368 $410 a month	213th of 368, with limits $27 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 Runloop ships a desktop and browser your agent can control and Sprites is headless; bochka streams its desktop at 60fps.	39th cheapest of 369 $2,306 a month	85th of 369, with limits $136 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	40th cheapest of 367 $1,153 a month	171st of 367, with limits $122 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	68th cheapest of 346 $781 a month	229th of 346, with limits $206 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	266th of 338, with limits $15,611 a month	141st of 338, with limits $4,113 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 Both can lock outbound traffic to a domain allowlist; Runloop fits fully here, and bochka gives each sandbox a full kernel with nested virtualization.	10th cheapest of 360 $770 a month	210th of 360, with limits $223 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	Runloop	Sprites	bochka
Isolation	Micro-VM on a custom bare-metal hypervisor, plus a container layer	Firecracker microVM with its own kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Machine size	You pick the size per devbox	Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform	You choose; up to 16 vCPU / 32 GB on the $100 plan and above
Images	Blueprints built from Dockerfiles, plus disk snapshots; x86_64 and arm64	One managed Ubuntu image you install on top of; x86_64	Templates from named snapshots, no Dockerfile builds; x86_64
Inside the machine	Root and Docker on the Docker-in-Docker blueprints; no nested virtualization documented	Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs	Root, Docker, systemd and /dev/kvm for emulators and VMs
Keeping files	Disk kept through suspend (Pro plan) or disk snapshots you take; shutdown ends the devbox	Disk kept between wakes, with manual or automatic checkpoints that restore in place	Disk saved every minute and on stop, on every plan; resume with the same disk
Idle sleep and wake	Suspend after idle, wake on an HTTP request to the tunnel (Pro)	Pauses about 30 seconds after activity stops, wakes in 100 to 500 ms with memory, or 1 to 2 s after a cold stop, on every plan	No idle timer; runs until you stop it or its time to live ends, and a stopped sandbox costs nothing
Long runs	Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it	No time cap, but it stays awake only while work or a renewed task hold keeps it busy	No session cap on paid plans; default TTL 1 hour, changeable
Fork	New devboxes from disk snapshots	No fork in the public API or CLI	Fork a running sandbox with its disk into a new one
Reaching the sandbox	One HTTPS tunnel per devbox covering its ports; SSH through a TLS proxy; no public IP	One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH
Outbound rules	Hostname allowlist with wildcards, or block all	Optional DNS-based domain allowlist set from outside; private IPs always blocked	Open internet, no provider-side allowlist
Keeping keys out of the sandbox	Agent gateways for any API endpoint with bearer, header or basic auth	Connectors gateway for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists	Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Coding agents	Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker	Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console	Seven agents preinstalled, with a prompt, steer and events API to drive them from outside
Desktop and browser	A desktop and browser your agent can control	Headless; no desktop or browser product	60fps desktop and Chromium, computer use and browser control, embeddable stream
Where it runs	Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise)	Region not selectable	EU only (Germany, Finland, France), with EU data residency

Every feature Battleships tracks (43)

Feature	Runloop	Sprites	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	No	Yes
Root	Yes	Yes	Yes
Systemd	Not published	No	Yes
Desktop GUI	Yes	No	Yes
Browser	Yes	No	Yes
Computer-use API	Yes	No	Yes
SSH	Yes	No	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	Yes	Yes
Automatic snapshots	Yes	Yes	Yes
Fork/clone	Yes	No	Yes
Live fork (no pause)	Yes	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	No	Yes
Public IPv4	No	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	Yes	Yes	Yes
Secret proxy for any API	Yes	Yes	Yes
Preinstalled agents	Yes	Yes	Yes
Agent harness API	Yes	No	Yes
MCP server	Yes	Yes	No
GPU	No	No	No
Windows	No	No	No
Arm64	Yes	No	No
Self-hosting	No	No	No
BYOC	Yes	No	No
Open source	No	No	No
Scoped API keys	Yes	Not published	Yes
Spend limits	Not published	Not published	Yes
Usage per sandbox (API)	No	No	Yes
Audit logs	Not published	Not published	No
SSO	Yes	Yes	No
SOC 2	Yes	Yes	No
HIPAA	Not published	Yes	No
EU data residency	No	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

Runloop8.29 runs/s

SpritesNot measured

bochka26.69 runs/s

On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), bochka scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. Sprites has no comparable measurement: it is not in those results, and a Sprite always has 8 vCPU, so a fair test would 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	Runloop, a month	Sprites, 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	$113 · Basic	$23 · Pay-as-you-go	$20 · $20/mo
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$429 · Basic	$92 · Pay-as-you-go	$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	$5,268 · Basic	$1,120 · Pay-as-you-go	$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	$1,441 · Basic	$314 · Pay-as-you-go · 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	$3,184 · Basic	$1,134 · Pay-as-you-go · with limits	$2,000 · $2000/mo · with limits

Runloop: Runloop bills per second for the CPU and memory you allocate while a devbox is starting, running, suspending or resuming, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.

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 include fixed CPU, memory and storage allowances that are not credit.

Sprites: 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

Runloop publishes no concurrency cap for paid plans and no egress price, and its fixed lifetime tops out at 48 hours unless an idle policy replaces it. 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 there, and creation is 10 a minute without a plan. Runloop fits both of those scenarios. bochka queues starts above 90 a minute, so 1,000 jobs at once does not fit even its $2,000 plan.

Scenario	Runloop	Sprites	bochka
One coding agent, workdays	egress price not published	None that bite	None that bite
One agent that never stops	egress price not published	None that bite	None that bite
50 agents in parallel	egress price not published	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	None that bite
Sandboxes for your users	egress price not published	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	None that bite
1,000 short jobs at once	egress price not published	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	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)

Which one should you use?

Use Runloop when

you need Dockerfile blueprints, arm64, devboxes sized your way, large waves of evals or RL jobs, or devboxes inside your own AWS, GCP or Azure account.

Images from Dockerfiles, sized your way. Useful if your agent needs a custom image: Runloop builds blueprints from Dockerfiles, offers arm64, and lets you size each devbox.
Run it in your own cloud. On the Enterprise plan, Runloop can run devboxes inside your own AWS, GCP or Azure account.
Built for evals and RL. For teams training or testing agents at scale: Runloop starts large waves without published start limits and sells RL fine-tuning on Enterprise.

Use Sprites when

your agents or apps sit idle most of the day and should wake on a request, and you want to pay only for the CPU and memory they actually use.

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.
Pay for the CPU you use. Sprites bills the CPU time and memory a machine actually uses while awake, not the size it was given.
Plugs into agent platforms. Teams already on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them.

Where bochka fits

If your agents do real work for hours, with installs, builds, Docker and emulators, look at bochka. Each sandbox is a full VM with systemd and /dev/kvm, keeps its disk on every plan, and was about three times Runloop's speed on the same CPU test.

A full machine with /dev/kvm and systemd

Neither Runloop nor Sprites documents /dev/kvm, so an Android emulator or a VM does not start. Sprites also has no systemd, so services must be rewritten as Sprite services. bochka runs both in every sandbox.

Real networking, not one tunnel

Runloop reaches a devbox through one HTTPS tunnel and Sprites exposes one HTTP port, with SSH and other ports through a proxy. bochka gives HTTPS on up to 50 ports, raw TCP, SSH and a dedicated IP.

Files kept and agents that keep running

On Runloop, keeping a disk means the $250-a-month Pro plan or your own snapshot code. A Sprite pauses when idle and drops connections unless you renew an hourly task hold. bochka saves the disk every minute and has no session cap on paid plans.

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 Runloop and bochka vs Sprites.

Questions people ask

Is Sprites cheaper than Runloop?

In every scenario we priced, yes. One coding agent on workdays is $23 a month on Sprites and $113 on Runloop, and 50 agents in parallel are $1,120 versus $5,268. On bochka those two are $20 and $317.

Which is faster, Runloop or Sprites?

We can't say yet: Runloop scored 8.29 runs a second on the Node.js build-and-test benchmark at 4 vCPU / 8 GB, and Sprites has not been measured on it. bochka scored 26.69 on the same test.

Can Runloop and Sprites run Docker?

Yes, both. Runloop runs Docker as root on its Docker-in-Docker blueprints. Docker runs inside a Sprite, but users report that docker exec fails for containers whose main process is not root. bochka runs Docker with root and systemd.

Does a Sprite or a Runloop devbox keep running when idle?

A Sprite pauses about 30 seconds after activity stops and drops open connections, unless a task hold keeps it awake for up to an hour at a time. A Runloop devbox runs for its set lifetime, or until an idle policy shuts it down or suspends it (Pro).

Can I limit which websites a sandbox can reach?

Yes on both. Runloop network policies allow only listed hostnames, with wildcards, or block everything, and Sprites can get a DNS-based domain allowlist that also always blocks private IPs. bochka has no provider-side egress allowlist, so you filter inside the VM.

Can I SSH into Runloop or Sprites?

Runloop offers SSH through a TLS proxy, with no public IP. On Sprites you install an SSH server yourself and tunnel it through the sprite proxy CLI. bochka sandboxes have SSH, raw TCP and a dedicated IP.

Try bochka

Install the CLI, then run bochka new.

Product preview