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.

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.

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 workloadboat: price rankSprites: 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 requirementNot 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 requirementNot ranked: misses a requirement

Key features

FeatureboatSprites
IsolationFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are sharedFirecracker microVM with its own kernel
Machine sizeYou 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 machineRoot, Docker, systemd and /dev/kvm for emulators and VMsRoot 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 behaviorRuns 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 chargePauses 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
SnapshotsDisk saved every minute and at each stop, plus saved snapshots to start new sandboxes from; memory and running programs are not savedFilesystem checkpoints by hand or automatic; restore replaces the current disk in place; memory is kept while a Sprite is paused
ForkFork 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 sandboxHTTPS URLs for up to 50 ports, token-protected; SSH through a shared IPv4 host and port; public IPv6 for raw ports; no dedicated IPv4One HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLI on your machine
Outbound rulesOpen internet, no provider-side allowlistOptional DNS-based domain allowlist set from outside; private IPs always blocked
Keeping keys out of the sandboxOptional 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 outConnectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists
Coding agentsSeven agents preinstalled, with a prompt, steer and events API to drive them from outsideClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console
Desktop and browser60fps desktop and Chromium, computer use and browser control, embeddable streamNo desktop or browser built in; you install a browser, display server and stream yourself
IntegrationsREST API, CLI and SDKsRemote MCP server, agent plugins, and backends for Claude Managed Agents and Cursor Cloud Agents
RegionsGermany, Finland and France; no US or Asia region; you cannot pick oneNo region option when you create a Sprite
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatSprites
Full VM (own kernel)YesYes
Docker insideYesYes
Nested virtualizationYesNo documented way
RootYesYes
SystemdYesNo documented way
Desktop GUIYesNo documented way
BrowserYesNo documented way
Computer-use APIYesNo documented way
SSHYesWith your own setup
Persistent diskYesYes
Pause/resumeYesYes
Automatic snapshotsYesYes
Fork/cloneYesNo documented way
Live fork (no pause)YesNo documented way
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesYes
≥24 h sessionsYesYes
Idle auto-stopNo documented wayYes
Wake on requestNo documented wayYes
HTTPS preview URLsYesYes
Raw TCP inboundYesNo documented way
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesYes
Secret proxy for any APIYesYes
Preinstalled agentsYesYes
Agent harness APIYesNo documented way
MCP serverNo documented wayYes
GPUNo documented wayNo documented way
WindowsNo documented wayNo documented way
Arm64No documented wayNo documented way
Self-hostingNo documented wayNo documented way
BYOCNo documented wayNo documented way
Open sourceNo documented wayNo documented way
Scoped API keysYesNot published
Spend limitsYesNot published
Usage per sandbox (API)YesNo documented way
Audit logsNo documented wayNot published
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayYes
EU data residencyNo documented wayNo documented way
Zero data retentionYesNot published

Performance

boat28.06 runs/s
SpritesNot measured

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.

Scenarioboat, a monthSprites, 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.

ScenarioboatSprites
One coding agent, workdaysNone for this scenarioNone for this scenario
One agent that never stopsNone for this scenarioNone for this scenario
50 agents in parallelNone for this scenario
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
Sandboxes for your usersNone for this scenario
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
1,000 short jobs at once
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
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