Blaxel vs Sprites
Blaxel and Sprites both give each sandbox its own Firecracker microVM that sleeps when idle and wakes on the next request. Blaxel wakes in under 25 ms, runs custom Docker images and lets you pick US or EU regions, while a Sprite keeps a fixed 8 vCPU machine with a 100 GB disk and bills only the CPU and memory it really uses.
The companies and products
Blaxel
Blaxel is a San Francisco company that runs cloud infrastructure for AI agents, and since September 2026 it is part of Baseten.
You get sandboxes, batch jobs, MCP server hosting and a model gateway. Each sandbox is a Firecracker microVM with its own kernel that drops to standby when nothing is connected and resumes in under 25 ms with its memory and running processes. It is built for agent products that start many sandboxes and want them asleep most of the time.
- Headquarters
- San Francisco, founded 2024
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
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. “10th cheapest of 367” means 9 of the other 366 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 | Blaxel: price rank | Sprites: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 10th cheapest of 367 $2,373 a month | 66th of 367, with limits $546 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Blaxel's standby keeps memory and processes for mostly idle assistants, while a Sprite drops open connections on every pause; boat simply keeps the machine running. | 12th cheapest of 366 $2,832 a month | 157th of 366, with limits $1,166 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 suit short code runs that sleep right after: Blaxel wakes in under 25 ms, and Sprites bills only the CPU and memory a run really uses. | 14th cheapest of 345 $144 a month | 93rd of 345, with limits $140 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 Both wake a user's sandbox on request, but Blaxel's public tiers stop at 200 at once and Sprites does not publish a cap; boat fits 300 at once on a self-serve plan. | 101st of 361, with limits $926 a month | 56th of 361, with limits $428 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 | 77th of 360, with limits $4,378 a month | 105th of 360, with limits $6,540 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 | 136th of 364, with limits $704 a month | 125th of 364, with limits $545 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 All three run Docker, but builds that need /dev/kvm, such as Android emulators, only work on boat. | 57th cheapest of 377 $431 a month | 63rd cheapest of 377 $476 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box wants SSH and systemd: neither Blaxel nor Sprites has native SSH or systemd, and boat has both. | 265th of 368, with limits $114 a month | 213th of 368, with limits $27 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 Blaxel runs a desktop and a browser, while Sprites is headless; boat streams a 60fps desktop you can embed in your app. | 14th cheapest of 369 $634 a month | 85th of 369, with limits $136 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 On Sprites you install and run a headless browser yourself, while Blaxel and boat both offer browser control. | 16th cheapest of 367 $317 a month | 171st of 367, with limits $122 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 | 16th cheapest of 346 $215 a month | 229th of 346, with limits $206 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 | 147th of 338, with limits $4,292 a month | 141st of 338, with limits $4,113 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 Blaxel adds domain, method and path egress rules plus static egress IPs, while Sprites offers a DNS domain allowlist; boat gives root with raw TCP and nftables. | 3rd cheapest of 360 $217 a month | 210th of 360, with limits $223 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 | Blaxel | Sprites | boat |
|---|---|---|---|
| Isolation | Firecracker microVM, own kernel | Firecracker microVM, own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | You pick the RAM; 8 GB comes with 4 cores | Fixed 8 vCPU; memory set and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Sleep and wake | Standby a few seconds after the last connection; wakes in under 25 ms with memory and processes | Pauses about 30 seconds after activity stops; wakes in 100 to 500 ms with memory, or 1 to 2 s after a cold stop | Runs until you stop it; a stopped sandbox costs nothing and resume boots the VM again |
| Disk | Files live in memory (about half the RAM); one block volume can be attached at creation | Fixed 100 GB disk that syncs to object storage | A real disk that stays, snapshotted every minute and on stop |
| Images | Custom images built from Docker images | One managed Ubuntu image; you install on top of it | Templates from named snapshots, shareable by code |
| Fork | Fork with memory and running processes (private preview) | No fork; checkpoints restore in place | Fork a running sandbox with its disk into a new one |
| Inside the machine | Root and Docker with a Docker-in-sandbox image; no systemd, no /dev/kvm | Root and Docker (with rough edges users report); no systemd, no /dev/kvm in the docs | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| SSH | No native SSH; terminal through bl connect | No direct SSH; install a server and tunnel it through the sprite proxy CLI | Real SSH, plus a dedicated IPv4 or IPv6 |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP | One HTTPS URL to one HTTP port; other ports only through the sprite proxy | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | DNS-based domain allowlist; private IPs always blocked | Open internet; filter inside the VM with nftables |
| Keeping keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | Connectors gateway holds tokens for any HTTP API, with path allow and block lists | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Desktop and browser | Desktop, browser and computer use | Headless; no desktop or browser product | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | Claude Code image you drive from its terminal or your own harness | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Regions | Oregon, North Virginia, London, Frankfurt | Region not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Blaxel | Sprites | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | No | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | No | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | 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 | Yes | 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 | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB, in the same run on September 29, 2026, boat did 26.69 runs per second and Blaxel 19.48, so boat does about 1.4 times the work in the same time. Sprites has no comparable measurement: it is not in those results, and a Sprite always has 8 vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). Sprites has 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 | Blaxel, a month | Sprites, 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 | $33 · Pay-as-you-go Tier 1 | $23 · Pay-as-you-go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $120 · Pay-as-you-go Tier 1 | $92 · Pay-as-you-go | $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,489 · Pay-as-you-go Tier 1 | $1,120 · Pay-as-you-go | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $314 · Pay-as-you-go · 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 | $876 · Pay-as-you-go Tier 2 · with limits | $1,134 · Pay-as-you-go · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, meaning a connection is open, with CPU included. In standby you pay only snapshot storage, and volumes are billed on their full size.
Sprites: Sprites bills CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while awake, plus storage on the bytes you write. Optional plans buy fixed CPU, memory and storage allowances that are not credit.
Sprites: Plans start at $20 a month, and the whole fee is usage credit, billed per second while a machine runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Blaxel's self-serve tiers allow 10, 50 or 200 sandboxes at once, counting those in standby, and Tier 0 and 1 delete sandboxes after 7 or 30 days. Sprites does not publish how many can run at once on pay as you go and allows 10 creates a minute without a plan, so 300 user sandboxes or 1,000 jobs at once are not confirmed on either. A Sprite also stays awake only while something holds it, so an always-on agent needs a task hold renewed every hour. boat has no session cap on paid plans, but it queues starts above 90 a minute, so it does not fit 1,000 jobs at once either.
| Scenario | Blaxel | Sprites | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite | None that bite | None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Blaxel when
your sandboxes sleep most of the time and must wake in milliseconds with memory, when you start from your own Docker image, or when you need US regions.
- Wakes in milliseconds with memory. For sandboxes that sleep between steps: Blaxel resumes in under 25 ms with memory and running processes.
- Your own image and region. Teams with an existing Docker image or US users can build custom images and run in Oregon, North Virginia, London or Frankfurt.
- Finer network rules. Blaxel can limit a sandbox to chosen domains, down to methods and paths, and give it static egress IPs.
Use Sprites when
you want one persistent machine per agent with a large disk, billed on what it really uses, or when you already run agents on Claude Managed Agents, Cursor Cloud Agents or Fly.io.
- A big disk that stays. Each Sprite has a 100 GB disk that survives sleep, so large repos fit without attaching volumes.
- Pay for real use. Sprites bills the CPU time and memory a machine actually uses while awake, so mostly idle agents cost little.
- Plugs into agent platforms. Teams on Claude Managed Agents or Cursor Cloud Agents can use Sprites as the machine behind them, with a remote MCP server.
Where boat fits
Blaxel and Sprites are both built for sandboxes that sleep most of the time. If your agents work for hours on builds, tests, Docker and emulators, boat gives each one a whole Linux machine that keeps running, with a real disk, a faster CPU and agents you drive from outside.
A whole Linux machine
Neither Blaxel nor Sprites runs systemd or exposes /dev/kvm, so Android emulators and nested VMs do not start. SSH needs bl connect or the sprite proxy, and boat has systemd, /dev/kvm, real SSH and raw TCP.
Keeps running, keeps its disk
Blaxel keeps files in memory unless you attach a volume, and a Sprite pauses about 30 seconds after work stops and drops open connections. boat runs until you stop it and saves its disk every minute.
Agents driven from outside, and a screen
On both you run agents through a terminal, exec or your own harness. boat lets you prompt, steer and follow seven preinstalled agents through one API, fork a running sandbox, and watch a 60fps desktop.
Use boat when your agents do real work for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: boat vs Blaxel and boat vs Sprites.
Questions people ask
Is Blaxel cheaper than Sprites?
In most scenarios we priced, Sprites costs less: one coding agent on workdays is $23 a month on Sprites against $33 on Blaxel, and 50 agents in parallel are $1,120 against $1,489. For 1,000 short jobs at once Blaxel is lower, $876 against $1,134. boat comes to $20 and $317 for the first two.
Which is faster, Blaxel or Sprites?
Blaxel wakes faster, in under 25 ms against 100 to 500 ms for a Sprite. For CPU work, Blaxel did 19.48 runs per second on our 4 vCPU benchmark and boat 26.69, while Sprites has not been measured.
Can Blaxel and Sprites run Docker?
Yes, both run Docker inside, Blaxel with a Docker-in-sandbox image. Users report rough edges with Docker on Sprites, and neither runs systemd or exposes /dev/kvm, which boat does.
Do Blaxel and Sprites keep my files?
A Sprite keeps a 100 GB disk that syncs to object storage. Blaxel keeps files in memory, about half the RAM, unless you attach a block volume at creation, and lower tiers delete sandboxes after 7 or 30 days.
Where do Blaxel and Sprites run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Sprites does not let you choose a region. boat runs only in the EU, in Germany, Finland and France.
Can I SSH into Blaxel or Sprites?
Not natively. Blaxel gives a terminal through bl connect, and on Sprites you install an SSH server and tunnel it through the sprite proxy CLI. boat sandboxes have real SSH, raw TCP and a dedicated IP.
Try boat
Install the CLI, then run boat new.
7-day free trial