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.
- 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
- 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.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- 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 | boat: 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 boat 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; boat 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; boat'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 boat 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; boat 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 boat 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 | boat |
|---|---|---|---|
| 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 | boat |
|---|---|---|---|
| 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
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), boat 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 | boat, 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. boat queues starts above 90 a minute, so 1,000 jobs at once does not fit even its $2,000 plan.
| Scenario | Runloop | Sprites | boat |
|---|---|---|---|
| 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 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 boat fits
If your agents do real work for hours, with installs, builds, Docker and emulators, look at boat. 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. boat 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. boat 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. boat saves the disk every minute and has no session cap on paid plans.
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 Runloop and boat 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 boat 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. boat 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. boat 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. boat 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. boat sandboxes have SSH, raw TCP and a dedicated IP.
Try boat
Install the CLI, then run boat new.
7-day free trial