Morph Cloud vs Fly.io Machines
Morph Cloud is built for AI agents: full VMs you can snapshot and branch with their memory, then pause and wake on demand. Fly.io Machines are fast Firecracker microVMs for hosting your own apps in 17 regions, so as an agent sandbox you build most of the pieces yourself.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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. “16th cheapest of 345” means 15 of the other 344 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 | Morph Cloud: price rank | Fly.io Machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month bochka ranks 3rd with Docker, /dev/kvm, a desktop and a disk that survives stops; Fly and Morph both fit only as a compromise for long build-and-test agents. | 198th of 367, with limits $2,288 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 | 235th of 366, with limits $3,014 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 Morph Cloud ranks 16th and fits fully, since a machine can pause with its memory, cost almost nothing while paused and wake on the next request; Fly ranks 75th as a compromise on shared CPU. | 16th cheapest of 345 $154 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 Morph Cloud ranks 12th and fits fully with pause and wake per user, while Fly creates about one Machine per second per app; bochka ranks 1st with token-protected HTTPS on up to 50 ports per sandbox. | 12th cheapest of 361 $905 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 Morph's memory branching suits rollouts that all start from the same running state, while Fly is cheaper on paper but its clones start with an empty Volume. | 86th of 360, with limits $4,847 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 Morph fits evals fully and can branch many copies of one prepared machine; on Fly each eval machine boots from your image, and the work that builds up on it is lost on restart unless you put it on a Volume. | 38th cheapest of 364 $675 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 Morph also sells managed GitHub Actions runners, while busy CI jobs drain a shared Fly vCPU's burst balance; on bochka you run your own runner on a full VM with /dev/kvm. | 39th cheapest of 377 $355 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 | 85th cheapest of 368 $116 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 bochka ships a 60fps desktop with Chromium and a computer use API; Morph offers browser-based remote desktop access, and on Fly you build and stream a desktop yourself. | 182nd of 369, with limits $595 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 | 214th of 367, with limits $250 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 | 239th of 346, with limits $234 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 here than Morph, since it can spread scrapers across 17 regions and bill only the seconds they run. | 154th of 338, with limits $4,750 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 | 214th of 360, with limits $228 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 | Morph Cloud | Fly.io Machines | bochka |
|---|---|---|---|
| Kind of product | Agent sandbox: full VMs, with Devboxes as ready workspaces on top | App hosting platform; you boot your own image as a microVM | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Full VM with its own kernel | Firecracker microVM with its own kernel, on Fly's own servers | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker, systemd and nested virtualization | Root and Docker, including Docker in Docker and local Kubernetes; nested virtualization is experimental | Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered | Docker, root, systemd and /dev/kvm on every machine |
| Pause with memory | Yes; resume brings back every process, and a paused VM bills only its snapshot | Suspend keeps memory for Machines up to 2GB; the snapshot is dropped on deploy or host move | No; the disk is kept and resume boots the machine again |
| Fork a running machine | Branch with its memory, as many copies as you ask for, in under 250 ms | Clone copies a Machine's config; a cloned Volume starts empty | Fork a running sandbox, disk included |
| Wake on request | A paused VM resumes on the next HTTP request, SSH or exec call | Fly Proxy stops or suspends idle Machines and wakes them when a request arrives | No; you start and stop machines through the API |
| Files after a stop | Saved when you pause or snapshot; a plain stop deletes the instance | Root file system is ephemeral; lasting data goes on one Volume, billed for its full size around the clock | Whole disk kept, saved every minute and on every stop; a stopped sandbox costs nothing |
| Desktop and computer use | Browser-based remote desktop; you install the browser and any computer use agent yourself | None built in; you add a desktop and browser to your own image | 60fps Linux desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | You install the agent, then drive it through a tmux API that sends keys and reads the screen | None built in; you install and run agents yourself | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Responses Proxy for model APIs; other secrets are handed to the machine | Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network between Machines | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Open internet; no egress allowlist | Network policies allow chosen ports and protocols and deny the rest | Open internet on every plan; no provider-side allowlist |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Regions | Not published | 17 regions on six continents | EU only: Germany, Finland, France, with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Fly.io Machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | 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 | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Not published | No | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for either Morph Cloud or Fly.io Machines: neither was in the hpc-sandbox-benchmarks run. bochka did 26.69 Node.js build-and-test runs per second there at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Fly's shared vCPUs guarantee only 6.25% of each core with a burst balance, so busy work on Fly depends on which CPU class you buy.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Morph Cloud and Fly.io 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 | Morph Cloud, a month | Fly.io 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 | $32 · Developer | $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 | $121 · Team | $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,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $232 · Pay As You Go · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 an hour: a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot storage.
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 for 40% off, the lowest rate Fly sells.
Fly.io Machines: 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
Morph prices each machine by its largest resource, so more than 16 GiB of disk per vCPU raises the bill, egress prices are not published, and the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. Fly is marked 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. Fly's API also starts about one Machine per second per app, so 1,000 jobs at once need pre-created Machines or several apps. bochka has no session cap, but its start limits queue the 1,000-job burst even on the $2,000 plan, where Morph Scale fits.
| Scenario | Morph Cloud | Fly.io Machines | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Morph Cloud when
your agents branch from one running state with its memory, sleep between requests and wake on demand, or need experimental Windows and macOS guests.
- Branch a running VM with its memory. Morph copies a running VM with its memory into many branches in under 250 ms, which suits agents that fan out from one state.
- Pause any machine and wake it on demand. A paused Morph VM keeps every process, bills only its snapshot, and wakes on the next HTTP request, SSH or exec call.
- Made for agents, not app hosting. Morph gives agents a full VM with Docker in Docker, a tmux API for coding agents and a proxy for model keys.
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. Useful when agents or users sit outside Europe: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
- A full app platform around each Machine. Useful if you host whole products: Fly adds raw TCP, Anycast IPs, custom domains, a private network and port-level network policies.
- Per-second billing with no plan fee. Fly bills each Machine per second with no plan fee, and its shared CPUs suit light code that mostly waits.
Where bochka fits
Look at bochka if your agents do long hours of real work: installs, builds, tests, Docker and emulators. Morph is strongest at memory branching and Fly at hosting apps worldwide, but on both you still build the agent setup, the desktop and the key handling yourself. bochka ships those in every full VM, and its disk survives every stop.
A disk that survives every stop
On Morph a plain stop deletes the instance, so you pause or snapshot to keep work. On Fly the root disk is ephemeral and one Volume is billed at full size all month. bochka saves the whole disk every minute, and a stopped sandbox is free.
Agents and a desktop already inside
On Morph you install the agent and drive it by sending keystrokes to tmux; on Fly you build the whole image yourself. bochka has seven coding agents with a prompt, steer and events API, and a 60fps desktop with Chromium.
Real keys never enter the machine
Morph's proxy covers model APIs only, so keys for GitHub or Stripe sit inside the machine. Fly passes secrets as environment variables unless you run its tokenizer yourself. bochka's credentials proxy covers any HTTPS API.
Use bochka when your agents need to arrive ready and keep their work: a full VM with Docker and /dev/kvm, a disk saved every minute, coding agents you drive from outside, a desktop with Chromium and real keys kept outside the machine. Compare it one to one: bochka vs Morph Cloud and bochka vs Fly.io Machines.
Questions people ask
Is Morph Cloud cheaper than Fly.io Machines?
On paper Fly is lower in all five scenarios: one agent running all month is $36 on Fly against $121 on Morph, and 50 agents in parallel are $487 against $1,459. Fly's figures need a 1-year reservation and assume work that stays within a shared vCPU's 6.25% baseline. bochka is $26 and $317 for those two.
Which is faster, Morph Cloud or Fly.io Machines?
Neither has a comparable CPU measurement, so there is no fair speed ratio. Morph says it restores a snapshot in under 250 ms, which measures start time, not CPU speed. bochka did 26.69 runs per second on the Node.js build-and-test benchmark at 4 vCPU / 8 GB.
Can Morph Cloud and Fly.io Machines run Docker?
Yes. Morph runs Docker in Docker and local Kubernetes, and lists nested virtualization as experimental. On Fly you install Docker in your own image, with no systemd and no /dev/kvm. bochka has Docker, systemd and /dev/kvm ready on every machine.
Do they keep my files when a machine stops?
On Morph you pause or snapshot to keep work, since a plain stop deletes the instance. On Fly only what sits on the one attached Volume lasts. bochka keeps the whole disk, saved every minute and on every stop.
Can I branch a running machine with its memory?
On Morph, yes: Infinibranch copies a running VM with its memory into many branches. Fly's clone copies a Machine's config with an empty Volume, and its suspend keeps memory only for Machines up to 2GB. bochka forks a running sandbox with its disk, not its memory.
Where do Morph Cloud and Fly.io Machines run?
Morph does not publish its regions. Fly runs Machines in 17 regions on six continents. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview