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.

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 workloadSprites: price rankBeam: price rankboat: 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 requirementCheapest 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureSpritesBeamboat
IsolationFirecracker microVM with its own kernelgVisor container by default for sandboxes, with an opt-in VM-backed mode; Beam VMs are CPU microVMs with their own kernelFull VM with its own kernel, on AMD Ryzen 7 9700X and Ryzen 9 9950X hosts dedicated to boat; vCPUs are shared
Machine sizeFixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB and bills on useYou request vCPU and memory per sandbox or VM; Developer allows 30 vCPUs at once in total2 to 8 vCPU on every plan; 16 vCPU / 32 GB on the $100 plan and above
Docker and systemdRoot and Docker (a user reports docker exec fails for non-root containers); services API, not systemdBeam VMs have Docker and systemd; sandboxes run Docker with docker_enabled, without systemdRoot, Docker and systemd, like a normal Ubuntu server
Nested virtualizationNo /dev/kvm in the docsNot documented for sandboxes or VMsYes, /dev/kvm for Android emulators and VMs
Idle behaviorPauses about 30 seconds after activity stops and wakes on the next request in 100 to 500 msSandbox default 10 minutes, or -1 to run until you end it; VMs run until you stop them, with optional idle sleepNo idle sleep; auto-stop after a set time (default 1 hour). A stopped sandbox has no compute charge
Disk between runsPersistent 100 GB disk, with checkpoints that restore in placeA sandbox keeps files through a saved image, a memory snapshot or a volume; a Beam VM keeps its root disk while stoppedDisk saved every minute and at stop; kept at least 14 days after a stop, longer as a saved snapshot
Fork and snapshotsFilesystem checkpoints restored in place; no fork command in the docsSandbox memory snapshots with running processes; VMs pause with RAM kept, fork and take disk snapshotsFork a running sandbox from its last 1-minute disk snapshot; the fork boots fresh
GPUsNone documentedGPU sandboxes, serverless GPUs and GPU machines up to H100, H200 and B200No GPU on any size
Reaching the sandboxOne HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLISandboxes: a public HTTPS URL per port, no built-in auth. VMs: token-protected URLs and TCP ports on a public IPv6 addressSSH; up to 50 HTTPS URLs, token-gated by default; a public IPv6 address per sandbox; the IP changes at each resume
Outbound rulesOptional DNS-based domain allowlist; private IPs always blockedBlock all outbound traffic, or allow up to 64 hosts, wildcard domains, IPs or CIDRs, changeable while runningOpen internet, no provider-side allowlist
Keeping keys out of the sandboxConnectors gateway holds the token for GitHub, OpenRouter, Slack or any HTTP API, with path allow and block listsBrokered secrets in sandboxes and VMs: the guest sees a placeholder, and Beam adds the real key to HTTPS headers for approved hostsOptional AI credentials proxy, $1 per UTC day plus $1 per 1,000 requests; covers supported AI providers only
Coding agentsClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a consoleYou install agents and run them through process exec; Beam's MCP server plugs into Claude Code, Codex and CursorSeven harnesses installed, with a prompt, steer and events API
Desktop and browserNo desktop or browser built in; you install a browser, display server and stream yourselfBeam VMs have a browser Linux desktop (Chrome on x86) and an SDK for screenshots, clicks, typing and recording; documented for VMs, not sandboxesLinux desktop and Chrome streamed at 1920x1080, 60fps, with computer-use tools
Regions and self-hostingNo region option; hosted onlyUS 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 feeGermany, Finland and France; you cannot pick a region; hosted only
Every feature Battleships tracks (43)
FeatureSpritesBeamboat
Full VM (own kernel)YesNo documented wayYes
Docker insideYesYesYes
Nested virtualizationNo documented wayNo documented wayYes
RootYesYesYes
SystemdNo documented wayNo documented wayYes
Desktop GUINo documented wayNo documented wayYes
BrowserNo documented wayNo documented wayYes
Computer-use APINo documented wayNo documented wayYes
SSHWith your own setupYesYes
Persistent diskYesWith your own setupYes
Pause/resumeYesNo documented wayYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneNo documented wayYesYes
Live fork (no pause)No documented wayYesYes
Memory forkNo documented wayYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesNo documented wayNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesNo documented wayYes
Preinstalled agentsYesNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUNo documented wayYesNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayYesNo documented way
BYOCNo documented wayYesNo documented way
Open sourceNo documented wayYesNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedNot publishedYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedNot publishedNo documented way
SSOYesNo documented wayNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyNo documented wayNot publishedNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

SpritesNot measured
BeamNot measured
boat28.06 runs/s

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.

ScenarioSprites, a monthBeam, a monthboat, 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.

ScenarioSpritesBeamboat
One coding agent, workdaysNone for this scenario
  • disk beyond 0 GiB: price unknown
None for this scenario
One agent that never stopsNone for this scenario
  • disk beyond 0 GiB: price unknown
None for this scenario
50 agents in parallel
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
  • disk beyond 0 GiB: price unknown
None for this scenario
Sandboxes for your users
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • disk beyond 0 GiB: price unknown
None for this scenario
1,000 short jobs at once
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • Team: max 1,000 vCPU running at once (needs 2,000)
  • disk beyond 0 GiB: price unknown
  • 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

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

More comparisons