boat vs Sprites
Sprites and boat 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 boat gives the agent a fuller machine it can shape, with systemd, nested virtualization, a desktop, forks and coding agents you drive from outside.
Where boat stands out
A machine you can shape, not a fixed box
A boat 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 boat 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
boat
boat.dev 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
- Regions
- EU: Germany, Finland, France
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. “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 | boat: 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; boat 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; boat 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 boat 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 boat 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; boat 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: boat 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 boat 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 | boat | 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 | boat | 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
There is no comparable measurement for Sprites yet: it is not in the hpc-sandbox-benchmarks results we use. boat 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 | boat, 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 |
boat: 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. boat 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 | boat | 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 |
|
| Sandboxes for your users | None that bite |
|
| 1,000 short jobs at once |
|
|
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 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.
- 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 boat cheaper than Sprites?
In four of the five scenarios we priced, yes: one coding agent on workdays comes to $20 a month on boat 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 boat sandbox keeps running until you stop it.
Can I run Docker, systemd and Android emulators on each?
boat 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. boat sandboxes have SSH, raw TCP and a dedicated IP.
Where do Sprites and boat run?
Sprites does not let you choose a region. boat runs only in the EU, in Germany, Finland and France, with EU data residency and a zero data retention option.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs E2B
- boat vs Daytona
- boat vs Modal
- boat vs Vercel Sandbox
- boat vs Blaxel
- boat vs Runloop
- boat vs Tensorlake
- boat vs Cloudflare Sandbox
- boat vs exe.dev
- boat vs Agent 37
- boat vs Oracle Cloud
- boat vs IONOS Cloud
- E2B vs Sprites
- Daytona vs Sprites
- Modal vs Sprites
- Vercel Sandbox vs Sprites
- Cloudflare Sandbox vs Sprites
- Blaxel vs Sprites
- Runloop vs Sprites
- Tensorlake vs Sprites