boat vs Sprites
Sprites and boat both give each agent its own Linux VM with a disk that survives. A Sprite sleeps soon after work stops, wakes on the next request and bills only the CPU and memory it uses. A boat sandbox is a fuller machine that you size: systemd, nested virtualization, a desktop, forks and coding agents you drive from outside. It bills its full size while it runs.
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 from 2 to 16 vCPU (16 vCPU needs the $100 plan or higher). You reach it over SSH, up to 50 HTTPS URLs and raw ports over IPv6. A Sprite has a fixed 8 vCPU shape, runs services through its own API instead of systemd, and has one public HTTPS URL.
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 from its latest disk save (taken every minute) to try two approaches from the same state. Sprites preinstalls agents too, but you run them through exec. Its checkpoints restore in place, and its documented CLI and API have no fork.
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 ships no desktop: you install a browser, a display server and a stream yourself.
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 that scales from 2 GB to 16 GB as needed, and a 100 GB ext4 disk backed by object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled. It gets an HTTPS URL that wakes it, and it bills only for the CPU and memory it 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
- 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. “5th cheapest of 365” means 4 of the other 364 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 up to 50 public HTTPS URLs, which full-stack builds often need. | 5th cheapest of 365 $634 a month | 101st of 365, with limits $546 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB On Sprites, an assistant that waits on websockets or a queue must keep the Sprite awake, for example with a Tasks API hold of up to an hour that you renew. boat keeps the machine running once you turn auto-stop off (default 1 hour), and bills its full size, busy or idle. | 6th cheapest of 361 $657 a month | 214th of 361, 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 used CPU and memory, and wakes in under a second. On boat, each new sandbox counts against the plan's start limits. | 189th of 336, with limits $2,000 a month | 99th of 336, 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. boat gives each user SSH, up to 50 HTTPS URLs and raw ports over IPv6. | 3rd cheapest of 349 $209 a month | 61st of 349, with limits $428 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 39th of 349, with limits $2,000 a month | 114th of 349, 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 359 $200 a month | 130th of 359, 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. boat has it in every sandbox, and the Sprites docs do not mention it. | 2nd cheapest of 374 $86 a month | 63rd cheapest of 374 $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. On Sprites you set up SSH yourself: install openssh-server and tunnel through sprite proxy. Sprites runs services through its services API, not systemd. | 19th cheapest of 371 $26 a month | 120th cheapest of 371 $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. A Sprite has no desktop built in: you install a display server, a browser and a stream yourself. | 7th cheapest of 367 $200 a month | 132nd of 367, 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 browser yourself, for example headless Chromium with Playwright. | 7th cheapest of 356 $200 a month | 236th of 356, 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 343 $90 a month | 279th of 343, 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 | 73rd of 327, with limits $1,800 a month | 139th of 327, with limits $4,113 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 3rd cheapest of 351 $200 a month | 243rd of 351, with limits $223 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | boat | Sprites |
|---|---|---|
| Isolation | Full VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared | Firecracker microVM with its own kernel |
| Machine size | You choose: 2 to 16 vCPU and 4 to 32 GB; 16 vCPU / 32 GB needs the $100 plan or higher; disk is fixed per size (51 to 251 GB) | Fixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB as needed and bills on use |
| Inside the machine | Root, Docker, systemd and /dev/kvm for emulators and VMs | Root and Docker (a user reports docker exec fails for containers that do not run as root); services run through the Sprites services API, not systemd; no /dev/kvm in the docs |
| Idle behavior | Runs until auto-stop (1 hour by default, up to 30 days, or off on paid plans) and bills its full size, busy or idle; a stopped sandbox has no compute charge | 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 at each stop, plus saved snapshots to start new sandboxes from; memory and running programs are not saved | Filesystem checkpoints by hand or automatic; restore replaces the current disk in place; memory is kept while a Sprite is paused |
| Fork | Fork a running sandbox into a new one from its latest disk save (taken every minute) | No fork command in the CLI or API docs; release notes mention an admin fork of a Sprite's storage (April 2026); checkpoints restore in place |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; SSH through a shared IPv4 host and port; public IPv6 for raw ports; no dedicated IPv4 | One HTTPS URL to one HTTP port, private by default; other ports and SSH 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 | Optional paid credentials proxy ($1 per day on plus $1 per 1,000 requests) 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 | No desktop or browser built in; you install a browser, display server and stream yourself |
| Integrations | REST API, CLI and SDKs | Remote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents |
| Regions | Germany, Finland and France; no US or Asia region; you cannot pick one | No region option when you create a Sprite |
| 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 documented way |
| Root | Yes | Yes |
| Systemd | Yes | No documented way |
| Desktop GUI | Yes | No documented way |
| Browser | Yes | No documented way |
| Computer-use API | Yes | No documented way |
| SSH | Yes | With your own setup |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | No documented way |
| Live fork (no pause) | Yes | No documented way |
| Memory fork | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No documented way | Yes |
| Wake on request | No documented way | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No documented way |
| Public IPv4 | No documented way | No documented way |
| Egress allowlist | No documented way | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No documented way |
| MCP server | No documented way | Yes |
| GPU | No documented way | No documented way |
| Windows | No documented way | No documented way |
| Arm64 | No documented way | No documented way |
| Self-hosting | No documented way | No documented way |
| BYOC | No documented way | No documented way |
| Open source | No documented way | No documented way |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No documented way |
| Audit logs | No documented way | Not published |
| SSO | No documented way | Yes |
| SOC 2 | No documented way | Yes |
| HIPAA | No documented way | Yes |
| EU data residency | No documented way | No documented way |
| Zero data retention | Yes | Not published |
Performance
Sprites is not in the public benchmarks we use, so we cannot say which is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. A Sprite always has 8 vCPU, so a fair test would also need a matching shape.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Sprites is not in the public benchmarks we use, so we cannot say which is faster.
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. Start limits, per-start fees and plan minimums are in the price, boat's included.
| 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 | $8,800 · $2000/mo · with limits | $1,134 · Pay-as-you-go · with limits |
boat: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. Included VM time expires at the end of the billing period. You pay per second for the size you pick while a sandbox runs: $0.036 an hour for 4 vCPU / 8 GB, busy or idle. A stopped sandbox has no compute charge, and boat keeps its disk for at least 14 days. Saved snapshots above the plan's included count and the optional AI credentials proxy still charge while sandboxes are stopped.
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. Storage costs about $0.50 per GB-month for hot data while awake and about $0.02 per GB-month for cold data while it is kept. Pay as you go has no plan fee. fly.io/sprites also lists optional plans, such as Hero at $100 a month, with fixed CPU-hour, memory-hour and storage allowances that are not credit; use 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 (Hero: 100 running and 100 warm), and creation is 10 a minute without a plan, 60 on Adventurer and 240 on Mythic. A Sprite pauses when nothing keeps it awake, and open connections drop on a pause; an always-on agent needs a Tasks API hold that lasts up to an hour and must be renewed. Each Sprite has a fixed 100 GB disk. Fly.io moved Sprites to a new block-device storage layer in October 2026; you migrate Sprites created before 6 October yourself. boat sandboxes stop after 1 hour by default; you can set up to 30 days or turn auto-stop off on a paid plan. Each boat plan caps sandboxes running at once (100 on $20, 300 on $100, 1,000 on $500, 2,000 on $2,000) and includes a set number of starts (12 a minute and 200 a day on $20; 90 a minute and 2,400 a day on $2,000). Extra starts cost $0.03 to $0.07 each, and starts above 3 times the included per-minute number fail with 429, so at 1,000 short jobs at once even the $2,000 plan refuses starts above 270 a minute. boat never queues a start. Disk is fixed per boat size: 51 GB at 4 vCPU, up to 251 GB at 16 vCPU. A resume is like a reboot, and a machine failure loses writes made after the last 1-minute disk save.
| Scenario | boat | Sprites |
|---|---|---|
| One coding agent, workdays | None for this scenario | None for this scenario |
| One agent that never stops | None for this scenario | None for this scenario |
| 50 agents in parallel | None for this scenario |
|
| Sandboxes for your users | None for this scenario |
|
| 1,000 short jobs at once |
|
|
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Which one should you use?
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, when you need a domain allowlist on outbound traffic, or when you need a HIPAA BAA.
- 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, and the docs do not mention /dev/kvm for emulators. A second public port or a database client goes 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. On Sprites you try two fixes one after the other: checkpoint, try one, restore, try the other.
- 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 set up and maintain that stack yourself.
Questions people ask
Is boat cheaper than Sprites?
In four of the five scenarios we priced, yes. One coding agent on workdays is $20 a month on boat and $23 on Sprites. One agent that never stops is $26 against $92. 50 agents in parallel are $317 against $1,120. Sandboxes for your users are $200 against $314, but Sprites does not confirm 300 running at once on pay as you go. For 1,000 short jobs at once, Sprites is $1,134 against $8,800 on boat's $2,000 plan with paid extra starts, and neither fits that burst as published. Sprites bills used CPU and memory, so a mostly idle workload can cost less than these estimates. boat bills the full size while a sandbox runs.
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 its auto-stop timer ends: 1 hour by default, up to 30 days, or never once you turn auto-stop off on a paid plan.
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. Docker runs on Sprites too, though a user reports that docker exec fails for containers that do not run as root. The Sprites docs say Sprites don't run systemd; services run through the Sprites services API. The docs do not mention /dev/kvm.
Can I SSH into a Sprite?
Not by default. The Sprites docs give the steps: install an SSH server, run it as a Sprite service and tunnel through the sprite proxy CLI. boat sandboxes have SSH from the start, through a shared IPv4 host and port. boat does not sell a dedicated IPv4, and the IP changes at each resume.
Where do Sprites and boat run?
Sprites has no region option when you create a Sprite. boat sandboxes run on machines in Germany, Finland and France, and you cannot pick a region. boat has no US or Asia region, and boat can store snapshot copies outside the EU.
Is boat SOC 2 compliant?
SOC 2 is in progress. No HIPAA BAA and no SAML SSO are documented. Sprites has SOC 2 Type II and a HIPAA package. 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 Instabox
- boat vs Oracle 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