Fly.io Machines vs Beam

Fly.io Machines are microVMs for hosting your own apps in 17 regions, with wake on request and raw TCP. Beam is a US serverless cloud with quick gVisor sandboxes, separate CPU VMs and GPUs, and its runtime is open source.

The companies and products

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.

Kind of product: App hosting platform; Machines are its VM building block with a REST API
Isolation: Firecracker microVMs with hardware virtualization, on Fly's own servers
Regions: 17 regions in North America, Europe, Asia, Oceania, South America and Africa
CPU classes: Shared vCPUs guarantee 6.25% of each core with a burst balance; performance vCPUs get the full core
Storage: Root file system is ephemeral; one Volume of up to 500GB per Machine for lasting data
Free trial: 2 Machine hours or 7 days, up to 10 Machines of 2 vCPU / 4GB that stop after 5 minutes
Compliance: Lists SOC 2 Type II; a HIPAA package with a pre-signed BAA is sold as an add-on

Beam

Beam is a serverless cloud for GPU inference, sandboxes 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, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.

Isolation: Sandboxes are containers using runc and gVisor, with an opt-in microVM mode for CPU sandboxes; Beam VMs are CPU microVMs
Infrastructure: Runs on AWS and Google Cloud, in the United States; no other region is listed
GPUs: GPU sandboxes and serverless GPUs, from T4 and RTX 4090 up to H100, H200 and B200 machines
Open source: Beta9 runtime under AGPL-3.0, free to self-host
Bring your own cloud: Management fee per vCPU and GB of RAM, on top of your own cloud bill
Plans: Developer (pay as you go, 30 CPU containers), Team at $89 a month (1,000 CPU containers), Growth by contact
Compliance: SOC 2 Type II; HIPAA BAA for Enterprise customers

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. “92nd cheapest of 367” means 91 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	Fly.io Machines: price rank	Beam: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, systemd, /dev/kvm and a disk that lasts, which bochka gives every machine; Fly and Beam each miss some of these.	92nd of 367, with limits $836 a month	69th of 367, with limits $551 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB	125th of 366, with limits $816 a month	115th of 366, with limits $651 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 Beam fits short code runs fully: sandboxes start in a second or two, bill per second and end when their timer runs out; Fly is a compromise on shared CPU.	75th of 345, with limits $94 a month	8th cheapest of 345 $117 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 Beam fits sandboxes for your users fully, while Fly creates about one Machine per second per app; bochka fits too, with a full VM and hosting per user.	69th of 361, with limits $600 a month	3rd cheapest of 361 $290 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	48th of 360, with limits $2,838 a month	341st of 360, with limits $939 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 Beam fits agent evals with fast, disposable sandboxes; bochka fits as well, and Fly's shared vCPUs get throttled once a run keeps the CPU busy.	117th of 364, with limits $457 a month	13th cheapest of 364 $251 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; Beam fits, and bochka adds /dev/kvm for Android and VM builds.	152nd of 377, with limits $288 a month	12th cheapest of 377 $171 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB	118th of 368, with limits $53 a month	13th cheapest of 368 $21 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 Neither Fly nor Beam ships a desktop or browser, so you build one into your image; bochka has a 60fps desktop with Chromium and computer use.	95th of 369, with limits $173 a month	111th of 369, with limits $237 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	160th of 367, with limits $90 a month	195th of 367, with limits $176 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	161st of 346, with limits $67 a month	200th of 346, with limits $131 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 can spread scrapers across 17 regions, while Beam runs only in the US; both bill only for the seconds the scrapers run.	44th of 338, with limits $1,232 a month	42nd of 338, with limits $923 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	118th of 360, with limits $63 a month	175th of 360, with limits $155 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 Beam has GPUs from RTX 4090 to H100 and B200; Fly discontinued its GPU Machines in 2026, and bochka is CPU only.	Can't run it	Cheapest of 98 $458 a month	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	Fly.io Machines	Beam	bochka
Kind of product	App hosting platform; you boot your own image as a microVM	Serverless cloud for GPUs, sandboxes and jobs, plus separate CPU VMs	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	gVisor container by default for sandboxes; Beam VMs are CPU microVMs with their own kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Docker and systemd	Root and Docker you install yourself; Fly's own init, no systemd	Docker in sandboxes with docker_enabled; systemd only in Beam VMs	Docker, systemd and root, like a normal Ubuntu server
Nested virtualization	/dev/kvm not offered	Not documented	Yes, /dev/kvm for Android emulators and VMs
Files after a stop	Root file system is ephemeral; lasting data goes on one Volume, billed for its full size all month	A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk	The whole disk is kept, saved every minute and on stop; a stopped sandbox costs nothing
Memory snapshots	Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move	Memory snapshot of a running sandbox, restored into new sandboxes	Resume reboots from disk (no memory snapshots)
Fork	Clone copies a Machine's config; a cloned Volume starts empty	New sandboxes from a memory snapshot of a running one	Fork a running sandbox, disk included
Wake on request	Fly Proxy stops or suspends idle Machines and wakes them when a request arrives	No	You start and stop machines through the API
GPUs	No; GPU Machines were discontinued in 2026	GPU sandboxes and serverless GPUs up to H100, H200 and B200	No, CPU only
Inbound access	Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network	A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Block all outbound traffic, or allow up to 10 CIDR ranges, changeable while running	Open internet, no provider-side allowlist
Desktop and coding agents	None built in; you add them to your own image	None built in; you install agents through process exec	60fps desktop with Chromium and computer use; Claude Code, Codex and more preinstalled, with a prompt, steer and events API
Keeping keys out of the sandbox	Secrets as environment variables; open-source tokenizer proxy you deploy yourself	Secrets as environment variables inside the sandbox	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Regions and self-hosting	17 regions on six continents; no self-hosting	US only; Beta9 runtime is AGPL-3.0 and free to self-host, or bring your own cloud for a fee	EU only (Germany, Finland, France); no self-hosting

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Beam	bochka
Full VM (own kernel)	Yes	No	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	No	Yes
Root	Yes	Yes	Yes
Systemd	No	No	Yes
Desktop GUI	No	No	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	No	Yes
Automatic snapshots	Yes	No	Yes
Fork/clone	Yes	Yes	Yes
Live fork (no pause)	Yes	Yes	Yes
Memory fork	No	Yes	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	No	No
Wake on request	Yes	No	No
HTTPS preview URLs	Yes	Yes	Yes
Raw TCP inbound	Yes	No	Yes
Public IPv4	Yes	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	No	No	Yes
Secret proxy for any API	No	No	Yes
Preinstalled agents	No	No	Yes
Agent harness API	No	No	Yes
MCP server	Yes	Yes	No
GPU	No	Yes	No
Windows	No	No	No
Arm64	No	No	No
Self-hosting	No	Yes	No
BYOC	No	Yes	No
Open source	Yes	Yes	No
Scoped API keys	Not published	Not published	Yes
Spend limits	No	Not published	Yes
Usage per sandbox (API)	No	No	Yes
Audit logs	Not published	Not published	No
SSO	No	No	No
SOC 2	Yes	Yes	No
HIPAA	Yes	Yes	No
EU data residency	Yes	Not published	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

BeamNot measured

bochka26.69 runs/s

There is no comparable measurement for Fly.io Machines or Beam: neither was part of the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which of the two is faster. bochka did 26.69 Node.js build-and-test runs per second on that test at 4 vCPU / 8 GB. Fly's shared vCPUs guarantee 6.25% of a core with a burst balance, so its results would depend on the 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. Fly.io Machines and Beam 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	Fly.io Machines, a month	Beam, a month	bochka, 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	$15 · Pay As You Go · with limits	$5 · Developer	$20 · $20/mo
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$36 · Pay As You Go · with limits	$22 · 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	$487 · Pay As You Go · with limits	$410 · 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	$110 · Pay As You Go · with limits	$191 · 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	$232 · Pay As You Go · with limits	$259 · Team	$2,000 · $2000/mo · with limits

Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee; Volumes are billed for their full size all month. The figures here use shared vCPUs bought in 1-year reservation blocks, Fly's lowest rate.

Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and GiB of RAM until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team costs $89 a month plus usage, with no usage credit.

Beam: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

Fly is marked a compromise in every scenario: its lowest figures need a 1-year reservation, and its shared vCPUs guarantee only 6.25% of each core, so long builds get throttled. Fly's API also starts about one Machine per second per app, so big bursts need pre-created Machines. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need the Team plan, and Beam publishes no price for extra disk. bochka queues the burst of 1,000 short jobs because of its start limits, even on the $2,000 plan.

Scenario	Fly.io Machines	Beam	bochka
One coding agent, workdays	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown	None that bite
One agent that never stops	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown	None that bite
50 agents in parallel	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown	None that bite
Sandboxes for your users	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown	None that bite
1,000 short jobs at once	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

Use Fly.io Machines when

you host web apps or light services that must run near users around the world, sleep between requests and wake on traffic.

17 regions worldwide. For work that must sit near users outside the US, Fly runs Machines in 17 regions on six continents.
Wake on request and raw TCP. For services that sleep between requests, Fly Proxy wakes Machines on traffic and serves HTTPS, raw TCP and Anycast IPs.
A full app platform around it. For teams hosting a whole product, Fly adds private networking, custom domains and port-level network policies next to each Machine.

Use Beam when

you need GPUs, fast throwaway sandboxes for short code runs, low-cost CPU VMs in the US, or a runtime you can self-host.

GPUs in the same platform. For workloads that need a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100, H200 and B200.
Fast, disposable sandboxes. For short code runs, Beam sandboxes start in a second or two, bill per second and can be restored from memory snapshots.
Open source and your own cloud. For teams that must self-host, Beam's Beta9 runtime is AGPL-3.0, and it can also run in your own cloud for a fee.

Where bochka fits

Fly.io Machines are built for hosting apps and Beam is built around GPUs and short sandboxes, so on both you assemble the agent machine yourself. If what you are really running is agents that install, build and test for hours, bochka gives each one a full VM with the disk, desktop, agents and keys proxy already there.

A full VM with /dev/kvm and systemd

Fly Machines run Fly's own init with no systemd, and Beam sandboxes are gVisor containers. Neither offers /dev/kvm, so Android emulators and nested VMs cannot start. bochka has Docker, systemd and /dev/kvm on every machine.

A disk that survives every stop

A Fly root disk is ephemeral, so lasting files need a Volume billed for its full size all month. A Beam sandbox ends with its timer unless you save an image. bochka keeps the whole disk, saved every minute.

Agents, desktop and keys built in

On both Fly and Beam you build the desktop, browser and agent harness into your image, and secrets sit as environment variables the agent can read. bochka ships a 60fps desktop, preinstalled coding agents and a credentials proxy.

Use bochka when your agents do real work for hours: installs, builds, Docker and emulators on a full VM whose disk survives every stop, with a desktop, coding agents and a keys proxy built in. Compare it one to one: bochka vs Fly.io Machines and bochka vs Beam.

Questions people ask

Is Fly.io Machines cheaper than Beam?

It depends on the job. Beam costs less for one agent on workdays ($5 against $15 a month), one agent that never stops ($22 against $36) and 50 agents in parallel ($410 against $487). Fly costs less for 300 user sandboxes ($110 against $191) and 1,000 short jobs ($232 against $259), using its 1-year reserved shared vCPUs.

Which is faster, Fly.io Machines or Beam?

We cannot say: neither has a result on the StarSling CPU test. Fly's shared vCPUs guarantee 6.25% of a core and throttle under long load, while its performance vCPUs get the full core. bochka did 26.69 runs per second on that test.

Can Fly.io Machines and Beam run Docker?

Yes. On Fly you install Docker yourself inside the microVM, and Beam supports Docker in a sandbox with docker_enabled. Neither offers /dev/kvm for nested VMs, while bochka has Docker, systemd and /dev/kvm on every machine.

Do Fly.io Machines and Beam keep files when they stop?

On Fly only what sits on a Volume lasts, since the root file system is ephemeral. A Beam sandbox ends with its time to live unless you save an image or attach a volume, while a Beam VM keeps its 50 GiB root disk. bochka keeps the whole disk, saved every minute and on stop.

Which one has GPUs?

Beam does, with GPU sandboxes and serverless GPUs from RTX 4090 up to H100, H200 and B200. Fly discontinued its GPU Machines in 2026, and bochka is CPU only.

Where do they run?

Fly runs Machines in 17 regions on six continents, Beam runs in the US only, and bochka runs only in the EU (Germany, Finland and France) with EU data residency.

Try bochka

Install the CLI, then run bochka new.

Product preview