Which is better, Fly Sprites or Morph?
It depends on whether you need one lasting computer or many branches of one. For agents that mostly wait on a model, Runtime has the lowest bill: $0.64 for 1,000 one-minute runs, against $2.40 on Sprites and $1.67 on Morph. It meters CPU, and its snapshots and forks keep memory and processes. Pick Fly Sprites for a 100 GB disk that costs little while asleep, and fast rollbacks of its filesystem. Pick Morph for an agent that branches a running VM into hundreds of replicas.
At a glance
| Fly Sprites | Morph | Runtime | |
|---|---|---|---|
| Isolation | Firecracker microVM | Full virtual machines | Firecracker microVM, own kernel |
| CPU | $0.0385 per CPU-hour of measured CPU | $0.05 per MCU-hour for the machine's size | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory | $0.021875 per GB-hour of memory in use | Inside the MCU: 4 GB per MCU | $0.0075 per reserved GiB-hour |
| Snapshots | The filesystem, copy-on-write, in about a second | Memory and disk; branches to many replicas | Files, memory and running processes |
| Pause | Automatic; memory kept in a warm pause, dropped when cold | Devboxes scale to zero and keep their memory | Keeps files, memory and processes while you have credit |
| Plan fee | None required; optional monthly plans | Developer free with no credit; Team $40 and Scale $250 per month | None; prepaid credit from $10 |
| Free start | $30 of trial credit | 1,000 MCUs on the $40 Team plan | 100 free hours of a 1 GB machine in the first 30 days, no card |
| At once | Not stated on the pricing page | 8 devboxes free, 32 on Team, 128 on Scale | 100 sandboxes on a paid account |
Which one keeps a machine's state?
They save different things. A Sprite snapshot covers the filesystem only. Fly says it takes about a second. It is copy-on-write, so it stores only what changed, and it rolls the disk back to that point. Running processes are not included. A paused Sprite keeps its memory only while the pause is warm. Once it goes cold, memory is dropped, and processes start fresh on the next wake, which takes 1 to 2 seconds. Open TCP connections do not survive either kind of pause.
A Morph snapshot holds the machine's memory and disk, and Infinibranch starts hundreds of parallel replicas from one running machine. Snapshot storage is billed in MCUs: one MCU covers 5 TB-hours of snapshot, and Morph's example keeps an 8 vCPU, 8 GB, 8 GB-disk machine for $0.12 per month.
Runtime keeps the whole machine in each case. A pause keeps files, memory and processes while you have credit. A snapshot starts new sandboxes later. A fork makes 1 to 100 copies that run concurrently. See what a sandbox snapshot is and what a sandbox fork is.
Cost for the same job
Priced for 1,000 runs of 60 seconds on 2 vCPU and 4 GiB, each with 20 CPU-seconds of work. The Sprite is charged for all 4 GB throughout the minute. Morph counts 2 vCPUs and 4 GB as 2 MCUs an hour.
- CPU
- 1,000 × 20 s / 3,600 × $0.0385
- $0.21
- Memory
- 1,000 × 90 s / 3,600 × 4 × $0.021875
- $2.19
- Size
- 1,000 × 60 s / 3,600 × 2 MCU × $0.05
- $1.67
- CPU
- 1,000 × 20 s / 3,600 × $0.025
- $0.14
- Memory
- 1,000 × 60 s / 3,600 × 4 × $0.0075
- $0.50
That is $240.14 on Sprites, $166.67 on Morph and $63.89 on Runtime for 100,000 runs per month. If both CPUs are busy for the whole minute, it is $1.33 on Runtime, $3.47 on Sprites and $1.67 on Morph. Of the two other providers, Morph is cheaper at both loads, because a Sprite's memory rate is high. At 1 GB in use, a Sprite would pay $0.76. Plan fees, included credit, storage, network and free credit are excluded.
Which one to pick
| You want | Best fit |
|---|---|
| A 100 GB disk that is cheap while asleep | Fly Sprites |
| Fast rollbacks of the filesystem | Fly Sprites |
| An agent that searches by branching into hundreds of replicas | Morph |
| Snapshots and forks with memory and processes, measured CPU | Runtime |
Runtime Cloud
Runtime takes Morph's memory snapshots and Sprites' metered CPU, and prices the result 73% below Sprites and 62% below Morph. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.40 on Fly Sprites, $1.67 on Morph and $0.64 on Runtime. A Runtime snapshot or fork holds a running sandbox's memory, and its CPU rate is 35% below Sprites'. Rates checked 25 October 2026.
It also keeps a pause while you have credit, and has no plan fee.
To try it, sign in with npx withruntime login and use the free usage. The migration guide covers moving code from either one.
Moving to Runtime
Both other providers serve the same pattern: set a machine up once, then start from it later. On Runtime, it looks like this:
Pythonfrom withruntime import Runtimeruntime = Runtime()with runtime.sandboxes.create() as base: base.exec("pip install --quiet requests") snapshot = base.snapshot(name="with-requests", retention_days=7) with runtime.sandboxes.create(snapshot=snapshot["id"]) as copy: print(copy.exec("python3 -c 'import requests; print(requests.__version__)'").stdout) runtime.snapshots.delete(snapshot["id"])Sprites calls map directly to Runtime calls: client.createSprite(name) to
Sandbox.create(), and sprite.execFile(cmd, args) to exec([cmd, ...args]).
npx withruntime compare --from fly or --from morph reprices what you ran.
Credit you add within 30 days of signing up is matched, up to $1,000 in total. The one instruction in the migration guide lets a coding agent make the change on a
branch and test it on the free usage. More: Runtime vs Fly.io,
Runtime vs Morph.
Sources
Fly.io prices checked 25 October 2026.
Rates checked 25 October 2026; the Sprites, Sprites lifecycle and Morph pricing pages read 26 October 2026.
- Fly.io pricing, Sprites, Sprites lifecycle
- Morph Cloud pricing, Morph Devboxes, Morph snapshots
- Runtime pricing and Python SDK
Facts on this page were checked on 26 October 2026.