Blaxel vs Fly.io Machines
Both run Firecracker microVMs, but they are built for different jobs. Blaxel is a sandbox product for AI agents that sleeps and wakes with its memory, while Fly.io Machines are the building block of an app hosting platform that you turn into a sandbox yourself.
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
Fly.io Machines
Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.
A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.
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 | Fly.io Machines: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Blaxel fits fully while Fly is a compromise, since a Fly Machine's root disk resets on restart and you build the agent image yourself; boat adds /dev/kvm and a disk that stays. | 10th cheapest of 367 $2,373 a month | 92nd of 367, with limits $836 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 12th cheapest of 366 $2,832 a month | 125th of 366, with limits $816 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 Blaxel ranks 14th here against 75th for Fly.io Machines: short runs that sleep right away and resume in milliseconds are what Blaxel is built for. | 14th cheapest of 345 $144 a month | 75th of 345, with limits $94 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 are compromises here: Blaxel's public tiers stop at 200 sandboxes at once, and Fly's API creates about one Machine per second per app; boat fits 300 users at once on a self-serve plan. | 101st of 361, with limits $926 a month | 69th of 361, with limits $600 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 | 48th of 360, with limits $2,838 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 | 117th of 364, with limits $457 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 CI keeps the CPU busy, which drains a shared Fly vCPU's burst balance, while Blaxel bundles full cores with the RAM you pick. | 57th cheapest of 377 $431 a month | 152nd of 377, with limits $288 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Fly gives you SSH into a Machine you leave on, while Blaxel has no native SSH and boat is a plain VM with SSH and a disk that stays. | 265th of 368, with limits $114 a month | 118th of 368, with limits $53 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 ships a desktop, a browser and computer use, while on Fly you build and stream a desktop yourself; boat streams a 60fps desktop you can embed. | 14th cheapest of 369 $634 a month | 95th of 369, with limits $173 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 Blaxel has browser control ready, while on Fly you package the browser into your own image. | 16th cheapest of 367 $317 a month | 160th of 367, with limits $90 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 | 161st of 346, with limits $67 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 Fly ranks higher than Blaxel here, since it can spread scrapers across 17 regions and bill only the seconds they run. | 147th of 338, with limits $4,292 a month | 44th of 338, with limits $1,232 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 | 3rd cheapest of 360 $217 a month | 118th of 360, with limits $63 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 | Fly.io Machines | boat |
|---|---|---|---|
| Kind of product | Sandbox platform for AI agents, with batch jobs and MCP hosting | App hosting platform; Machines are its microVMs with a REST API | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Firecracker microVM, own kernel | Firecracker microVM, own kernel, on Fly's own servers | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Nested virtualization | No /dev/kvm | No /dev/kvm | /dev/kvm on every machine, so Android emulators and VMs run inside |
| SSH and systemd | Root and a terminal through bl connect; no native SSH, no systemd | Root and SSH; Fly's own init, no systemd | Real SSH, root and systemd |
| Docker inside | Yes, with a Docker-in-sandbox image | Yes, if you install it in your image | Yes, ready on every machine |
| Files | Files live in memory (about half the RAM); one volume can be attached at creation | Root file system is ephemeral; one Volume up to 500GB, billed for its full size all month | The whole disk stays, snapshotted every minute and on stop; a stopped sandbox costs nothing |
| Sleep and wake | Standby seconds after the last connection, wakes in under 25 ms with memory and processes | Fly Proxy stops or suspends idle Machines and wakes them on a request; memory kept only up to 2GB | You start and stop through the API; resume reboots from disk |
| Fork | Fork with memory and running processes (private preview) | Clone copies a Machine's config; a cloned Volume starts empty | Fork a running sandbox, disk included |
| Desktop and browser | Desktop, browser and computer use available | None built in; you add them to your own image | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | Claude Code image you drive from its terminal or your own harness | None built in; you install and run agents yourself | Claude Code, Codex, OpenCode and more, driven by a prompt, steer and events API |
| Keeping keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | Secrets arrive as environment variables; an open-source tokenizer proxy you run yourself | AI credentials proxy for model providers and any HTTPS API you register |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound rules | Domain allow and deny lists, method and path rules, static egress IPs | Network policies allow chosen ports and protocols and deny the rest | Open internet; filter inside the VM with nftables |
| Regions | Oregon, North Virginia, London, Frankfurt | 17 regions on six continents | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Fly.io Machines | 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 | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | 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 | Yes | Yes |
| Public IPv4 | No | Yes | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | 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 | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | No | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Yes | Not published | Yes |
Performance
In the same StarSling Node.js build-and-test run at 4 vCPU and 8 GB on September 29, 2026, boat did 26.69 runs per second and Blaxel 19.48, so boat got about 1.4 times the work done in the same time. Fly.io Machines were not in that run, so there is no comparable number for them. Fly's shared vCPUs guarantee 6.25% of a core with a burst balance, so a result would depend on which CPU class you pick.
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). Fly.io Machines 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 | Fly.io Machines, 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 | $15 · Pay As You Go · with limits | $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 | $36 · Pay As You Go · 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,489 · Pay-as-you-go Tier 1 | $487 · Pay As You Go · 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 | $396 · Pay-as-you-go Tier 2 · with limits | $110 · 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 | $232 · Pay As You Go · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox has an open connection, with CPU included (8 GB comes with 4 cores). In standby you pay only snapshot storage, and volumes are billed on their full size.
Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee. The figures here use its lowest rate, shared vCPUs in 1-year reservation blocks, and Volumes are billed for their full size all month.
Fly.io Machines: Your plan payment, from $20 a month, is all 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, and standby sandboxes count toward that, so 300 user sandboxes or 1,000 jobs at once need a sales tier. Fly is a compromise in every scenario: its lowest prices need a 1-year reservation and use shared vCPUs that are throttled above 6.25% of each core, and its API creates about one Machine per second per app. boat fits four of the five scenarios, but it limits starts per minute and per day, so 1,000 jobs at the same moment get queued.
| Scenario | Blaxel | Fly.io Machines | 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 |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Blaxel when
you want a ready agent sandbox whose sandboxes sit idle most of the time and must wake in milliseconds with their memory.
- Built as an agent sandbox. Useful if you want a sandbox product, not parts: a desktop, a browser, a Claude Code image and a secrets proxy come ready.
- Sleeps in seconds, wakes in milliseconds. Useful for sandboxes that sit idle most of the time: standby keeps memory and processes, and a sandbox wakes in under 25 ms.
- Domain-level egress rules. Useful if agents must reach only chosen sites: Blaxel filters by domain, method and path, and gives static egress IPs.
Use Fly.io Machines when
you host apps or light services near users around the world and are happy to build the sandbox parts yourself.
- 17 regions worldwide. Useful if work must run near users outside the US and Europe: Fly runs Machines from Sydney to Johannesburg.
- A full app platform around each Machine. Useful if you also host apps: Fly adds SSH, raw TCP, Anycast IPs, custom domains and a private network.
- Pay only for the seconds you run. Useful for light or bursty work: Fly bills per second with no plan fee, and shared CPUs cost little when code mostly waits.
Where boat fits
If your agents do real work for hours, like installs, builds, tests, Docker and emulators, look at boat. It gives each agent a whole Linux machine with a disk that stays and a faster CPU than Blaxel, plus the desktop and coding agents that Fly leaves you to build.
A whole Linux machine with /dev/kvm
Neither Blaxel nor Fly gives a guest /dev/kvm, so Android emulators and nested VMs do not start. Neither runs systemd, and Blaxel has no native SSH. boat has all of these on every machine.
A disk that keeps everything
Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation. Fly resets the root disk on restart, so files go on one Volume billed for its full size all month.
Agents and a desktop you drive from outside
On Fly you build an image with the browser, desktop and agents, then write the code that drives them. Blaxel ships a Claude Code image but you run your own harness. boat has a prompt, steer and events API.
Use boat when your agents work for hours on builds, tests, Docker and emulators, and need a whole Linux machine with a disk that stays, a desktop and coding agents built in. Compare it one to one: boat vs Blaxel and boat vs Fly.io Machines.
Questions people ask
Is Blaxel cheaper than Fly.io Machines?
Not in our scenarios. One agent running all month is $36 on Fly and $120 on Blaxel, and 50 agents in parallel are $487 on Fly against $1,489 on Blaxel. Fly's figures need a 1-year reservation and assume work that stays within a shared vCPU's 6.25% baseline, and Blaxel bills only while a connection is open.
Which is faster, Blaxel or Fly.io Machines?
There is no shared measurement. Blaxel did 19.48 Node.js build-and-test runs per second at 4 vCPU and 8 GB, against 26.69 for boat, and Fly was not part of that run. Fly's shared vCPUs are throttled above 6.25% of each core, while its performance vCPUs get the full core at a higher rate.
Can Blaxel or Fly.io Machines run Docker?
Both can. Blaxel offers a Docker-in-sandbox image, and on Fly you install Docker in your own image since a Machine gives you root. Neither offers /dev/kvm for Android emulators or nested VMs, which boat has on every machine.
Do Blaxel and Fly.io Machines keep files when they stop?
Blaxel keeps memory and files through standby, but files live in memory unless you attach a volume at creation. A Fly Machine's root file system is ephemeral, so lasting files go on its one Volume. boat keeps the whole disk, with snapshots every minute and on stop.
Which is better as an AI agent sandbox?
Blaxel is built as one, with a desktop, a browser, a Claude Code image and a secrets proxy. Fly.io Machines are an app hosting building block, so you package the tools, browser and agents yourself. boat adds a full VM, a disk that stays and an API to drive agents inside from outside.
Where do Blaxel and Fly.io Machines run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. Fly runs Machines in 17 regions on six continents. boat runs only in the EU, in Germany, Finland and France, with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial