Sprites vs Beam
Sprites gives each agent a persistent Firecracker microVM that pauses when idle and wakes on the next request. Beam is a serverless GPU platform with two CPU products: quick gVisor sandboxes that run until you end them, and Beam VMs that keep their disk, pause with memory and have a browser desktop.
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 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
Beam
Beam is a serverless cloud for GPU inference, sandboxes, VMs and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor by default. It lives until you terminate it or its time to live runs out, and you can save it as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd, a root disk that stays when it stops, and a browser desktop. A VM can pause with its memory, fork and take disk snapshots. CPU work runs on Spot, Shared or Performance tiers at different prices.
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 374” means 62 of the other 373 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 | Beam: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 101st of 365, with limits $546 a month | 7th cheapest of 365 $1,200 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB On Sprites, an assistant that waits all month needs a Tasks API hold renewed every hour, or it pauses and drops open connections. A Beam VM runs until you stop it and can pause with its memory. boat keeps a sandbox running with auto-stop off (default 1 hour), billed at full rate. | 214th of 361, with limits $1,166 a month | 12th cheapest of 361 $1,495 a month | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Beam fits short code runs well: sandboxes bill per millisecond while they run and end on their own when the time to live runs out. Sprites also fits: it sleeps about 30 seconds after the last command and bills used CPU and memory. | 99th of 336, with limits $140 a month | 21st cheapest of 336 $161 a month | 189th of 336, 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 Beam gives each user a quick sandbox with public URLs that your app must protect. Sprites gives each user a persistent microVM, but does not publish a pay-as-you-go running cap. boat gives each user a full VM with token-gated URLs, with start limits per plan. | 61st of 349, with limits $428 a month | 14th cheapest of 349 $567 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Sprites bills the CPU and memory it uses. Beam sandboxes bill the CPU and memory you request until they end, and memory snapshots of a running sandbox start new copies. | 114th of 349, with limits $6,540 a month | 332nd of 349, with limits $984 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 130th of 359, with limits $545 a month | 16th cheapest of 359 $258 a month | 10th cheapest of 359 $200 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. Every boat sandbox has it; neither Sprites nor Beam documents it. | 63rd cheapest of 374 $476 a month | 29th cheapest of 374 $300 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB All three keep work between days: a Sprite keeps its 100 GB disk, a Beam VM keeps its root disk (50 GiB by default, up to 100 GiB), and boat saves the disk every minute and at stop. | 120th cheapest of 371 $27 a month | 44th cheapest of 371 $55 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Beam VMs have a browser desktop with Chrome and an SDK for screenshots, clicks and typing. On Sprites you install a display server and a browser yourself. boat streams a 60fps desktop with Chrome and computer tools in every sandbox. | 132nd of 367, with limits $136 a month | 12th cheapest of 367 $431 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 236th of 356, with limits $122 a month | 73rd of 356, with limits $272 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 279th of 343, with limits $206 a month | 16th cheapest of 343 $196 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 139th of 327, with limits $4,113 a month | 44th of 327, with limits $967 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 243rd of 351, with limits $223 a month | 6th cheapest of 351 $219 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Beam has GPUs from RTX 4090 to H100, H200 and B200. Sprites and boat have no GPU. | Not ranked: misses a requirement | Cheapest of 102 $547 a month | 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 | Not ranked: misses a requirement |
Key features
| Feature | Sprites | Beam | boat |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | gVisor container by default for sandboxes, with an opt-in VM-backed mode; Beam VMs are CPU microVMs with their own kernel | Full VM with its own kernel, on AMD Ryzen 7 9700X and Ryzen 9 9950X hosts dedicated to boat; vCPUs are shared |
| Machine size | Fixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB and bills on use | You request vCPU and memory per sandbox or VM; Developer allows 30 vCPUs at once in total | 2 to 8 vCPU on every plan; 16 vCPU / 32 GB on the $100 plan and above |
| Docker and systemd | Root and Docker (a user reports docker exec fails for non-root containers); services API, not systemd | Beam VMs have Docker and systemd; sandboxes run Docker with docker_enabled, without systemd | Root, Docker and systemd, like a normal Ubuntu server |
| Nested virtualization | No /dev/kvm in the docs | Not documented for sandboxes or VMs | Yes, /dev/kvm for Android emulators and VMs |
| Idle behavior | Pauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 ms | Sandbox default 10 minutes, or -1 to run until you end it; VMs run until you stop them, with optional idle sleep | No idle sleep; auto-stop after a set time (default 1 hour). A stopped sandbox has no compute charge |
| Disk between runs | Persistent 100 GB disk, with checkpoints that restore in place | A sandbox keeps files through a saved image, a memory snapshot or a volume; a Beam VM keeps its root disk while stopped | Disk saved every minute and at stop; kept at least 14 days after a stop, longer as a saved snapshot |
| Fork and snapshots | Filesystem checkpoints restored in place; no fork command in the docs | Sandbox memory snapshots with running processes; VMs pause with RAM kept, fork and take disk snapshots | Fork a running sandbox from its last 1-minute disk snapshot; the fork boots fresh |
| GPUs | None documented | GPU sandboxes, serverless GPUs and GPU machines up to H100, H200 and B200 | No GPU on any size |
| Reaching the sandbox | One HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLI | Sandboxes: a public HTTPS URL per port, no built-in auth. VMs: token-protected URLs and TCP ports on a public IPv6 address | SSH; up to 50 HTTPS URLs, token-gated by default; a public IPv6 address per sandbox; the IP changes at each resume |
| Outbound rules | Optional DNS-based domain allowlist; private IPs always blocked | Block all outbound traffic, or allow up to 64 hosts, wildcard domains, IPs or CIDRs, changeable while running | Open internet, no provider-side allowlist |
| Keeping keys out of the sandbox | Connectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block lists | Brokered secrets in sandboxes and VMs: the guest sees a placeholder, and Beam adds the real key to HTTPS headers for approved hosts | Optional AI credentials proxy, $1 per UTC day plus $1 per 1,000 requests; covers supported AI providers only |
| Coding agents | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | You install agents and run them through process exec; Beam's MCP server plugs into Claude Code, Codex and Cursor | Seven harnesses installed, with a prompt, steer and events API |
| Desktop and browser | No desktop or browser built in; you install a browser, display server and stream yourself | Beam VMs have a browser Linux desktop (Chrome on x86) and an SDK for screenshots, clicks, typing and recording; documented for VMs, not sandboxes | Linux desktop and Chrome streamed at 1920x1080, 60fps, with computer-use tools |
| Regions and self-hosting | No region option; hosted only | US by default, another region if you choose one; Beta9 runtime is AGPL-3.0 and free to self-host, or bring your own cloud for a fee | Germany, Finland and France; you cannot pick a region; hosted only |
Every feature Battleships tracks (43)
| Feature | Sprites | Beam | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | No documented way | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No documented way | No documented way | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No documented way | No documented way | Yes |
| Desktop GUI | No documented way | No documented way | Yes |
| Browser | No documented way | No documented way | Yes |
| Computer-use API | No documented way | No documented way | Yes |
| SSH | With your own setup | Yes | Yes |
| Persistent disk | Yes | With your own setup | Yes |
| Pause/resume | Yes | No documented way | Yes |
| Automatic snapshots | Yes | No documented way | Yes |
| Fork/clone | No documented way | Yes | Yes |
| Live fork (no pause) | No documented way | Yes | Yes |
| Memory fork | No documented way | Yes | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No documented way | No documented way |
| Wake on request | Yes | No documented way | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No documented way | Yes |
| Preinstalled agents | Yes | No documented way | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | No documented way | Yes | No documented way |
| Windows | No documented way | No documented way | No documented way |
| Arm64 | No documented way | No documented way | No documented way |
| Self-hosting | No documented way | Yes | No documented way |
| BYOC | No documented way | Yes | No documented way |
| Open source | No documented way | Yes | No documented way |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No documented way | No documented way | Yes |
| Audit logs | Not published | Not published | No documented way |
| SSO | Yes | No documented way | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | No documented way | Not published | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
Sprites and Beam are not in StarSling's run of 3 October 2026 (run 37073680030), so we cannot say which is faster at CPU work. In that run 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 sandboxes on Ryzen 7 9700X hosts, which this run did not measure. For start time, ComputeSDK measured a Beam sandbox at 534 ms median with 100 at once (2026-11-06), at Beam's default size. Sprites and boat are not in ComputeSDK.
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 and Beam are 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 | Sprites, a month | Beam, 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 | $20 · Developer | $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 | $58 · Developer | $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 | $836 · Team | $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 | $312 · Team | $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 | $527 · Team · with limits | $8,800 · $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. 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. Optional plans add fixed allowances that are not credit.
Beam: Beam bills sandboxes per millisecond while they run, for each vCPU and GiB, on Spot, Shared or Performance tiers; new accounts default to Performance. For 4 vCPU / 8 GiB that is $0.28 an hour on Performance, $0.088 on Shared and $0.036 on Spot. VMs bill per second while running. Developer is $20 a month with $20 of credit; Team is $89 a month plus usage. There are no egress fees, and storage is not billed yet.
Limits in those scenarios
Sprites does not publish how many Sprites run at once on pay as you go, so 300 sandboxes for your users and 1,000 jobs at once are not confirmed, and creation is 10 a minute without a plan. Beam's Developer plan allows 30 vCPUs at once, so 50 parallel agents need the Team plan. For 1,000 short jobs at once, Beam's Team plan allows 1,000 vCPUs where the burst needs 2,000. Beam does not bill storage yet, so the scenarios count no disk cost for it. Beam Spot can stop a machine with 30 seconds of notice. boat runs 100 sandboxes at once on the $20 plan and 2,000 on the $2,000 plan. At 1,000 short jobs at once, the $2,000 plan charges for starts above 90 a minute and refuses them above 270. boat never queues a start, so none of the three fits that burst as listed.
| Scenario | Sprites | Beam | boat |
|---|---|---|---|
| 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 |
|
|
|
Which one should you use?
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, keep a persistent disk without extra steps, or need a domain allowlist and API connectors.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day, a Sprite stops billing compute and wakes on the next request.
- A persistent machine by default. Each Sprite keeps its 100 GB disk and installed software between uses, with no image to save first.
- Agents and API keys handled for you. Coding agents come preinstalled, and Connectors keep tokens outside the Sprite with per-path allow and block lists.
Use Beam when
your work needs GPUs, many short sandboxes, memory snapshots, VMs with a browser desktop, US hosting, or a runtime you can self-host.
- GPUs in the same platform. For work that needs a GPU, Beam offers GPU sandboxes, serverless GPUs and GPU machines from RTX 4090 to H100, H200 and B200.
- VMs that pause with memory, and a desktop. A Beam VM can pause with its RAM kept, fork, take disk snapshots and run a browser desktop with an SDK.
- Open source and your own cloud. The Beta9 runtime is AGPL-3.0 and free to self-host, and Beam can also run in your own cloud for a fee.
Where boat fits
Sprites and Beam both give an agent a Linux machine. Look at boat if your agents install things, run services, test apps in a browser or serve ports for hours: every sandbox is a full VM with systemd, /dev/kvm, a desktop and up to 50 HTTPS URLs. boat has no GPU, does not keep memory across a stop, and caps starts per plan.
A full VM with systemd and /dev/kvm
boat has systemd, Docker and /dev/kvm on every sandbox. A Sprite runs services through its services API, not systemd. Beam VMs have Docker and systemd, and its sandboxes do not run systemd. Neither documents /dev/kvm, so Android emulators need another host.
Hosting with access control
boat serves up to 50 token-gated HTTPS URLs and SSH. A Sprite exposes one HTTP port, and other ports go through the sprite proxy CLI. A Beam sandbox port URL is public with no built-in auth; Beam VMs have token-protected URLs and TCP ports.
Agents driven by API
boat ships seven coding agents with a prompt, steer and events API, and a desktop on every sandbox. On Sprites and Beam you start agents through exec and write your own code to prompt and watch them.
Use boat when your agents need a full machine for hours: systemd, Docker, /dev/kvm, up to 50 token-gated HTTPS URLs, a desktop and browser, forks, and an API to drive the agents inside. Compare it one to one: boat vs Sprites and boat vs Beam.
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
Questions people ask
Is Sprites cheaper than Beam?
In the scenarios we priced, Beam costs less: one agent that never stops is $58 a month on Beam against $92 on Sprites, and 50 agents in parallel are $836 against $1,120. boat is $26 and $317. Beam does not bill storage yet, and Sprites bills used CPU, so a mostly idle workload can cost less on Sprites than these estimates.
Which is faster, Sprites or Beam?
Neither is in the public CPU benchmarks we use, so we cannot say. Sprites says it wakes in 100 to 500 ms from a pause. ComputeSDK measured a Beam sandbox at 534 ms median to its first command with 100 at once (2026-11-06).
Can Sprites and Beam run Docker?
Yes, both. Beam sandboxes need docker_enabled, and Beam VMs have Docker and systemd. A Sprites user reports that docker exec fails for containers that do not run as root. boat runs Docker, systemd and /dev/kvm in every sandbox.
Does Sprites or Beam have GPUs?
Beam does, with GPU sandboxes, serverless GPUs and GPU machines from RTX 4090 up to H100, H200 and B200. Sprites documents no GPU, and boat has no GPU on any size.
What happens to my files when the sandbox stops?
A Sprite keeps its 100 GB disk when it pauses. A Beam sandbox keeps files through a saved image, a memory snapshot or a volume, and a Beam VM keeps its root disk. boat saves the disk every minute and at stop, and keeps it at least 14 days; if a machine fails, writes after the last good snapshot are lost.
Is boat SOC 2 compliant?
SOC 2 is in progress; there is no SOC 2 report today. Beam states SOC 2 Type II. Live boat status is at status.ascii.dev and the data retention policy is at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial