Sprites vs Claude Managed Agents
Sprites rents you a Linux microVM that sleeps when idle and wakes on the next request, and you run any agent inside it. Claude Managed Agents is Anthropic's hosted agent: you send Claude a task as events, and it works in a small container that Anthropic runs for you.
The companies and products
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
Claude Managed Agents
Claude Managed Agents is Anthropic's ready-made agent harness: Claude runs as an autonomous agent in a cloud sandbox that Anthropic manages, and you talk to it through an events API.
This is an agent platform, not a sandbox you rent. You define an agent (model, prompt, tools, MCP servers, skills) and an environment, then start sessions, send messages as events and stream back what Claude does; the harness handles tool calls, prompt caching and compaction. Each session gets its own Ubuntu container, or runs its tools on a worker you host yourself. It is built for teams that want Claude doing long tasks without building their own agent loop or sandbox.
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. “63rd cheapest of 377” means 62 of the other 376 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 | Sprites: price rank | Claude Managed Agents: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Sprites gives a coding agent a fixed 8 vCPU VM with a 100 GB disk, while Managed Agents gives it a container with up to 8 GB of memory and 10 GB of disk; boat adds systemd, /dev/kvm and many public ports. | 66th of 367, with limits $546 a month | 106th of 367, with limits $964 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both sleep between bursts of work, but a Sprite drops open connections on every pause and Managed Agents keeps sandbox state only 30 days; a boat sandbox just keeps running. | 157th of 366, with limits $1,166 a month | 219th of 366, with limits $2,511 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 Both bill only while working: Sprites charges real CPU and memory used, and Managed Agents charges runtime only while the session is running. | 93rd of 345, with limits $140 a month | 163rd of 345, with limits $756 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 A Sprite gives each user an HTTPS URL that wakes it, while a Managed Agents sandbox has no inbound ports; boat gives each sandbox HTTPS on up to 50 ports, raw TCP and SSH. | 56th of 361, with limits $428 a month | 231st of 361, with limits $823 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 | 105th of 360, with limits $6,540 a month | 252nd of 360, with limits $3,978 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 | 125th of 364, with limits $545 a month | 244th of 364, with limits $320 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 runs Docker with rough edges users report, Managed Agents lists Docker as limited availability, and only boat exposes /dev/kvm for Android and VM builds. | 63rd cheapest of 377 $476 a month | 227th of 377, with limits $96 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Neither gives you plain SSH: Sprites tunnels it through its CLI and Managed Agents reaches the sandbox only through its API; boat has SSH and systemd. | 213th of 368, with limits $27 a month | 224th of 368, with limits $48 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 Sprites is headless and Managed Agents ships only headless Chromium; boat streams a 60fps desktop with computer use. | 85th of 369, with limits $136 a month | 127th of 369, with limits $288 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 Managed Agents has Chromium with Playwright built in, on Sprites you install a browser yourself, and boat shows Chromium on a live desktop you can watch. | 171st of 367, with limits $122 a month | 126th of 367, with limits $288 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 | 229th of 346, with limits $206 a month | 127th of 346, with limits $390 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 | 141st of 338, with limits $4,113 a month | 155th of 338, with limits $4,798 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 | 210th of 360, with limits $223 a month | 179th of 360, with limits $160 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 | Sprites | Claude Managed Agents | boat |
|---|---|---|---|
| What it is | A persistent Linux microVM you rent by API or CLI, for any agent or app | A hosted Claude agent: Anthropic's harness runs Claude in a sandbox and you send it events | A sandbox platform: each agent gets its own full Linux VM, with coding agents built in |
| Isolation | Firecracker microVM with its own kernel | Isolated Linux container per session | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | Up to 8 GB memory and 10 GB disk; vCPU not published; not configurable | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker, systemd and /dev/kvm | Root and Docker, with rough edges users report; no systemd; no /dev/kvm in the docs | Docker listed as limited availability; root, systemd and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm for Android emulators and nested VMs |
| Idle and wake | Pauses about 30 seconds after activity stops; wakes on the next request in 100 to 500 ms, or 1 to 2 s after a cold stop | Idle session is checkpointed and resumes on the next message; idle time is not billed | Runs until you stop it or its time to live ends; a stopped sandbox costs nothing and is started again by API |
| What persists | The 100 GB disk, synced to object storage, with checkpoints that restore in place | Sandbox files are checkpointed, but kept only 30 days after the sandbox is created | The whole disk, saved every minute and on stop, for as long as you keep the sandbox |
| Fork | No fork in the public API or CLI | No fork or clone of a session or sandbox | Fork a running sandbox with its disk into a new one |
| Inbound access | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | No inbound ports or SSH; reached only through the sessions and events API | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Anthropic's harness with Claude models only, with steering, interrupts, memory stores and webhooks | Claude Code, Codex and five more preinstalled, driven from outside with a prompt, steer and events API |
| Desktop and browser | Headless; no desktop or browser product | Headless Chromium with Playwright; no desktop or computer-use tool | 60fps Linux desktop with Chromium, computer use and an embeddable stream |
| Keeping keys out of the sandbox | Connectors gateway holds tokens for any HTTP API, with path allow and block lists | Vault secrets sit in the sandbox as placeholders and are swapped in at egress, per host | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Unrestricted, or limited to listed hosts plus optional package registries and MCP servers | Open internet, no provider-side allowlist |
| Running on your own machines | No; Sprites can itself be the self-hosted backend for Claude Managed Agents | Self-hosted sandboxes run tool calls on workers you host | No |
| Where it runs | Region not selectable | US workspace geo only; not eligible for Zero Data Retention | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Sprites | Claude Managed Agents | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | 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 | No | 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 | No | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | No | No | Yes |
| Zero data retention | Not published | No | Yes |
Performance
There is no comparable measurement for Sprites or Claude Managed Agents: neither is in the hpc-sandbox-benchmarks results, and Anthropic does not publish how many vCPUs a sandbox gets. boat did 26.69 runs per second on the Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. 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 and Claude Managed Agents have 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 | Sprites, a month | Claude Managed Agents, 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 | $23 · Pay-as-you-go | $13 · Claude API (pay-as-you-go, usage tiers) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $92 · Pay-as-you-go | $53 · Claude API (pay-as-you-go, usage tiers) · with limits | $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 | $1,120 · Pay-as-you-go | $634 · Claude API (pay-as-you-go, usage tiers) · with limits | $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 | $314 · Pay-as-you-go · with limits | $360 · Claude API (pay-as-you-go, usage tiers) · 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 | $1,134 · Pay-as-you-go · with limits | $796 · Claude API (pay-as-you-go, usage tiers) · with limits | $2,000 · $2000/mo · with limits |
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 include fixed CPU, memory and storage allowances that are not credit.
Claude Managed Agents: Managed Agents bills model tokens at API list rates plus a flat session runtime fee of $0.08 an hour, metered only while the session runs, including time waiting on the model. The table shows runtime only; tokens come on top and usually cost more.
Claude Managed Agents: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
No scenario counts as a clean fit for Managed Agents: its machine size is not published, Docker is in limited availability, and it is a different kind of product, so its runtime-only prices leave out model tokens. Neither Sprites nor Managed Agents publishes how many sandboxes can run at once, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed on either. Sprites limits creates to 10 a minute without a plan, and Managed Agents to 300 a minute per organization. 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 allows 2,400 starts a day.
| Scenario | Sprites | Claude Managed Agents | 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 Sprites when
you want a persistent VM for any coding agent that sleeps when idle, wakes on a request and keeps its 100 GB disk.
- Any agent, on a bigger VM. Teams running Claude Code, Codex, Gemini CLI or Cursor get an 8 vCPU microVM with a 100 GB disk, not a Claude-only container.
- A public URL that wakes the machine. Apps and agents that sit idle most of the day get an HTTPS URL that wakes the Sprite on the next request.
- Disk that lasts. A Sprite keeps its disk for as long as it exists, so long-lived projects do not hit a 30-day limit.
Use Claude Managed Agents when
you want Claude itself to do long tasks with no harness to build, idle time that costs nothing, and the option to run tools on your own workers.
- No agent loop to build. Teams that want Claude doing long tasks get the harness, caching, compaction, memory and webhooks ready to use.
- Wakes on the next message. Agents that wait a long time between messages pay runtime only while working, and resume with no separate start call.
- Tools on your own workers. Teams with strict network rules can run every tool call on their own infrastructure, including on Sprites, while Anthropic orchestrates.
Where boat fits
If your agents need a whole machine for hours, with Docker, emulators, ports you can open and a screen to look at, both Sprites and Managed Agents leave gaps. boat gives each agent a full VM that keeps running, keeps its disk and runs any coding agent you drive from outside.
A full machine with systemd and /dev/kvm
A Sprite has no systemd and no /dev/kvm in its docs, and a Managed Agents container lists Docker as limited, with 10 GB of disk. Android emulators, nested VMs and service stacks stall on both; on boat they run like on any Linux server.
Open what the agent builds, and watch it
Sprites exposes one HTTP port, with other ports and SSH tunneled through its CLI, and Managed Agents has no inbound access at all. Neither has a desktop. boat gives HTTPS on 50 ports, raw TCP, SSH and a 60fps desktop with computer use.
Keep running, keep the disk, fork it
A Sprite drops connections on every pause unless a task hold, renewed each hour, keeps it awake, and Managed Agents drops state after 30 days. Neither can fork. boat runs until you stop it, saves the disk every minute and forks a running sandbox.
Use boat when your agents need a full machine for hours: systemd, Docker, emulators, many open ports, a desktop and browser, forks, and any coding agent you drive from outside. Compare it one to one: boat vs Sprites and boat vs Claude Managed Agents.
Questions people ask
Is Sprites cheaper than Claude Managed Agents?
For runtime alone, Managed Agents comes out lower in four of the five scenarios we priced, such as $53 against $92 a month for one agent that never stops. But those figures leave out model tokens, which Managed Agents always bills on top and which usually cost more than the runtime. Sprites is lower for sandboxes for your users, $314 against $360 a month.
Which is faster?
Neither has a comparable CPU measurement in the benchmarks we use, and Anthropic does not publish a sandbox's vCPU count. A Sprite always has 8 vCPU. boat did 26.69 runs per second on the Node.js build-and-test loop at 4 vCPU / 8 GB.
Can I use Sprites with Claude Managed Agents?
Yes. Managed Agents can run its tools on self-hosted sandboxes, and Fly.io documents Sprites as one of the environments behind Claude Managed Agents. You then pay Fly.io for the Sprite and Anthropic for the agent.
Can Sprites or Claude Managed Agents run Docker?
Users run Docker inside Sprites, though a community report shows docker exec failing for containers whose main process is not root, and Sprites does not run systemd. Managed Agents lists Docker as limited availability. boat runs Docker, systemd and /dev/kvm in every sandbox.
Can I run Codex or Claude Code on each?
Sprites comes with Claude Code, Codex, Gemini CLI and Cursor preinstalled. Managed Agents runs only Anthropic's own harness with Claude models. boat has Claude Code, Codex and five other agents preinstalled, driven from outside through one API.
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.
Try boat
Install the CLI, then run boat new.
7-day free trial