Fly.io Machines vs smol machines
Fly.io Machines are microVMs for hosting your own apps in 17 regions, with wake on request and a full app platform around them. smol machines is a sandbox built on an open-source microVM engine that runs on your laptop, in smol cloud or on your own servers, and can branch a running machine with its memory.
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.
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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 | smol machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 92nd of 367, with limits $836 a month | 73rd of 367, with limits $604 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 | 148th of 366, with limits $1,038 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 smol machines fits short code runs fully, with a one-minute minimum and branches of a warm machine, while Fly needs a 1-year reservation for its lowest rate. | 75th of 345, with limits $94 a month | 12th cheapest of 345 $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 smol machines fits sandboxes for your users fully, while Fly's API creates about one Machine per second per app; bochka ranks first here, with a desktop and hosting on up to 50 ports. | 69th of 361, with limits $600 a month | 7th cheapest of 361 $531 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 Fly ranks above smol machines here on price, though smol can branch a running machine with its memory so many rollouts start from one prepared state. | 48th of 360, with limits $2,838 a month | 111th of 360, with limits $6,978 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 | 117th of 364, with limits $457 a month | 36th cheapest of 364 $670 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; smol machines fits fully, and bochka adds /dev/kvm for Android builds. | 152nd of 377, with limits $288 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that runs all month costs $29 on smol machines and $53 on Fly; bochka is $26 and keeps its whole disk on every stop. | 118th of 368, with limits $53 a month | 216th of 368, with limits $29 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 has a hosted desktop, so on both you build and stream your own; bochka ships a 60fps desktop with Chromium and computer use. | 95th of 369, with limits $173 a month | 90th of 369, with limits $156 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 | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 well above smol machines here: it spreads scrapers across 17 regions and bills only the seconds they run. | 44th of 338, with limits $1,232 a month | 148th of 338, with limits $4,344 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 Fly ranks 118 and smol machines 252 for parallel red teaming; bochka ranks 2, with the same full VM on every machine. | 118th of 360, with limits $63 a month | 252nd of 360, with limits $377 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 | Fly.io Machines | smol machines | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel, on Fly's own servers | libkrun microVM with its own guest kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker, systemd and nested virtualization | Root and Docker you install yourself; Fly's own init, no systemd; no /dev/kvm | Docker inside the VM, with its data on the machine's ext4 disk; no nested virtualization on hosted machines | Docker, root, systemd and /dev/kvm on every machine |
| Files after a stop | Root file system is ephemeral; one Volume of up to 500GB, billed for its full size around the clock | Filesystem survives a stop, memory paths like /tmp are emptied; stopped disk keeps billing; cloud snapshot routes return 501 | Whole disk kept, saved every minute and on stop; a stopped sandbox costs nothing |
| Fork | Clone copies a Machine's config; a cloned Volume starts empty | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk; the fork boots fresh |
| Sleep and wake | Fly Proxy stops or suspends idle Machines and wakes them on a request; suspend keeps memory up to 2GB | A command or terminal starts a stopped machine; idle apps wake on the next request | Started and stopped through the API; resume reboots from disk |
| Shell access | SSH into a Machine | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network between Machines | Up to 16 published ports through a returned URL or an authenticated connect route; no 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 | Blocked, open, or an allowlist of hosts and CIDR ranges | Open internet on every plan; no provider-side allowlist |
| Desktop and browser | None built in; you add a desktop and browser to your own image | No hosted desktop; a guide shows running your own Chromium inside a machine | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | None built in; you install and run agents yourself | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself | Cloud secrets are environment variables the guest can read; placeholder swapping only in self-hosted smolvm | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | 17 regions on six continents | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | No; Machines run only on Fly's servers | Open-source smolvm runs on your laptop or your own servers, with the same .smolmachine artifact | No; hosted only |
Every feature Battleships tracks (43)
| Feature | Fly.io Machines | smol machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | 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 | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | 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 | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Fly.io Machines nor smol cloud was part of the StarSling CPU run where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly's shared vCPUs guarantee only 6.25% of each core with a burst balance, while its performance vCPUs get the full core. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.
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 smol machines 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 | smol machines, 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 | $25 · Standard | $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 | $93 · Standard | $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 | $1,139 · Pro | $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 | $465 · Startup | $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 | $1,389 · Startup | $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 table uses Fly's lowest rate: shared vCPUs bought in 1-year reservation blocks for 40% off.
smol machines: smol cloud charges a base fee for every hour a machine runs plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed while stopped. Pro ($20 a month) and Startup ($150 a month) are fees on top of usage, not credit.
Limits in those scenarios
Fly is a compromise in all five scenarios: its lowest figures need a 1-year reservation and use shared vCPUs that guarantee 6.25% of each core, so long builds get throttled, and its API creates about one Machine per second per app. smol machines caps how many machines you hold at once by plan, 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still taking a slot. So 50 agents in parallel needs Pro, and 1,000 short jobs at once needs Startup. bochka queues that 1,000-job burst even on its $2,000 plan, since starts above 90 a minute wait.
| Scenario | Fly.io Machines | smol machines | bochka |
|---|---|---|---|
| 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 | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use Fly.io Machines when
you host web apps or light services that must run near users on several continents, sleep between requests and wake on traffic.
- 17 regions worldwide. Useful if your users are outside Europe: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
- Wake on request and memory suspend. Useful for services that sleep between requests: Fly Proxy wakes a Machine on traffic, and small Machines resume with memory kept.
- A full app platform around each Machine. Useful if you host whole apps: Anycast IPs, custom domains, raw TCP, a private network and port-level network policies.
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, or you fan out many branches of a running machine with its memory.
- Open source, from laptop to your own servers. Teams that want the same VM locally, in a hosted cloud and on their own servers get it from one open-source engine.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, paying the one-minute minimum once.
- Host-level outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
Where bochka fits
Fly.io Machines is an app platform and smol machines is a lean microVM sandbox, so on both you build the agent's working machine yourself. If your agents spend hours installing, building and testing, bochka gives each one a full VM with its own kernel, /dev/kvm, a desktop, coding agents you drive from outside and a disk that survives every stop. It runs only in the EU, so pick Fly when you need other continents.
A disk that keeps everything, with free stops
A Fly Machine's root file system is ephemeral, so an agent's tools and caches live on one Volume billed for its full size all month. smol keeps the filesystem but bills stopped disk and has no cloud snapshots. bochka saves the whole disk every minute, and stops cost nothing.
A whole machine, not just a VM boundary
Neither Fly nor smol cloud offers /dev/kvm, so Android emulators and nested VMs cannot start, and neither has a desktop or browser built in. Fly also has no systemd. On bochka all of these come ready on every machine.
Agents and keys built in
On both, secrets are environment variables that agent-written code can read and send anywhere. Fly's workaround is running and securing your own tokenizer app; smol's swapping works only in self-hosted smolvm. bochka's credentials proxy keeps keys outside, and you prompt and steer preinstalled agents by API.
Use bochka when your agents do real work for hours: Docker, emulators, SSH, a desktop and a browser on a full VM whose disk survives every stop, with coding agents and a keys proxy built in. Compare it one to one: bochka vs Fly.io Machines and bochka vs smol machines.
Questions people ask
Is Fly.io Machines cheaper than smol machines?
On Fly's lowest rate, yes, in all five scenarios: one agent on workdays is $15 a month on Fly and $25 on smol, and 50 agents in parallel are $487 versus $1,139. That rate needs a 1-year reservation and shared vCPUs that guarantee 6.25% of each core. bochka is $20 and $317 for the same two.
Which is faster, Fly.io Machines or smol machines?
Neither has a comparable CPU measurement; bochka did 26.69 runs per second on the StarSling test. Fly's speed depends on the class you pick: shared vCPUs throttle above 6.25% of a core, while performance vCPUs get the full core. smol publishes boot times under 200ms, which is start time, not CPU speed.
Can Fly.io Machines and smol machines run Docker?
Both can: on Fly you install Docker in your own image, and on smol Docker data must live on the machine's ext4 disk. Neither offers /dev/kvm, so nested VMs and Android emulators are out. bochka has Docker, systemd and /dev/kvm on every machine.
Do they keep my files when a machine stops?
On Fly only what sits on the Machine's one Volume lasts, since the root file system is ephemeral. smol keeps the filesystem across a stop but empties /tmp and bills the stopped disk. bochka keeps the whole disk, saved every minute and on stop, and a stopped sandbox costs nothing.
Can I fork a running machine?
smol machines can branch a running machine into children that keep its memory and processes. A Fly clone copies a Machine's config, and a cloned Volume starts empty. bochka forks a running sandbox with its disk, and the fork boots fresh.
Can I self-host either one?
smol machines, yes: the smolvm engine is open source and runs on macOS, Linux and Windows hosts. Fly Machines run only on Fly's own servers. bochka is a hosted service only.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs Fly.io Machines
- bochka vs smol machines
- E2B vs Fly.io Machines
- Daytona vs Fly.io Machines
- Modal vs Fly.io Machines
- Vercel Sandbox vs Fly.io Machines
- Cloudflare Sandbox vs Fly.io Machines
- Blaxel vs Fly.io Machines
- Runloop vs Fly.io Machines
- Tensorlake vs Fly.io Machines
- Morph Cloud vs Fly.io Machines
- CodeSandbox SDK vs Fly.io Machines