Fly Sprites vs Runloop: pricing, persistence and limits

Sprites bill measured CPU and memory in use and pause themselves; Runloop bills a devbox's CPUs, memory and disk while it runs.

Runtime runs this job for 81% less than Sprites and 88% less than Runloop, and its pause is the only one of the three that keeps processes alive. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox are $3.31 on Fly Sprites, $5.33 on Runloop and $0.64 on Runtime. A cold Sprite and a suspended devbox both come back with their processes restarted; a paused Runtime sandbox comes back with memory and processes as they were, for as long as you choose to keep it. Rates checked 23 September 2026.

At a glance

	Fly Sprites	Runloop	Runtime
Isolation	Firecracker microVM	microVM, with a container inside	Firecracker microVM, own kernel
CPU	$0.07 per CPU-hour of measured CPU	$0.108 per CPU-hour while the devbox runs	$0.025 per vCPU-hour of measured CPU, with a small floor
Memory	$0.04375 per GB-hour of memory in use	$0.0252 per GB-hour	$0.0075 per reserved GiB-hour
Disk	100 GB, billed on use: $0.000683 per GB-hour awake	$0.00034236 per GB-hour; MEDIUM comes with 8 GB	Included while running
Sizes	Memory managed by Fly	X_SMALL (0.5 CPU, 1 GB) to XX_LARGE (8 CPUs, 32 GB)	vCPUs and memory chosen per sandbox
Plan fee	None required; optional monthly plans	Basic free; Pro $250 a month plus usage	None; prepaid credit from $10
Free start	$30 of trial credit	$50 of credit, no card	50 sandbox hours, no card
Asleep	Disk kept; memory kept while warm, dropped when cold	Disk kept; processes restart; storage still charged	Files, memory and processes kept, 1 to 365 days

What is kept when the sandbox sleeps?

A Sprite keeps its disk every time and its memory for a while. It pauses by itself about 30 seconds after activity stops. A warm pause freezes memory, and the Sprite resumes in 100 to 500 ms with its processes mid-operation. If it stays idle it goes cold: memory is dropped, the next wake takes 1 to 2 seconds, and processes start fresh. Fly does not say how long the warm stage lasts. Open TCP connections do not survive either. A sleeping Sprite is not billed for compute, and its cold disk costs $0.000027 per GB-hour.

A Runloop devbox keeps its disk. Its lifecycle docs say suspend and resume preserve disk state, not memory; the devbox keeps its ID and SSH keys. Compute is billed only while it is initializing, running, suspending or resuming, and a suspended devbox still pays for storage until it is shut down.

A Runtime sandbox keeps everything. pause() saves its files, memory and running processes for the retention you choose, 1 to 365 days on a paid account, at $0.08 per GB a month. The next request wakes it by itself, usually in about half a second, and it carries on where it stopped. See how to pause and resume a sandbox.

Cost for the same job

A thousand runs, one minute each on 2 vCPU and 4 GiB, in which the code works for 20 CPU-seconds and otherwise waits. The Sprite is charged as if its full 4 GB were in use for all 60 seconds. On Runloop the size is MEDIUM: 2 CPUs, 4 GB and an 8 GB disk.

TextSprites  CPU    1,000 × 20 s / 3,600 × $0.07            = $0.39         Memory 1,000 × 60 s / 3,600 × 4 × $0.04375     = $2.92         Total                                             $3.31Runloop  CPU    1,000 × 60 s / 3,600 × 2 × $0.108       = $3.60         Memory 1,000 × 60 s / 3,600 × 4 × $0.0252      = $1.68         Disk   1,000 × 60 s / 3,600 × 8 × $0.00034236  = $0.05         Total                                             $5.33Runtime  CPU    1,000 × 20 s / 3,600 × $0.025           = $0.14         Memory 1,000 × 60 s / 3,600 × 4 × $0.0075      = $0.50         Total                                             $0.64

For 100,000 runs a month, that becomes $330.56 on Sprites, $532.56 on Runloop and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on Runtime, $5.25 on Sprites and $5.33 on Runloop. Between the rivals, Sprites win clearly while the code waits and tie roughly when it is busy, because Runloop's price ignores CPU load. Plan fees, storage while asleep, network and free credit are excluded.

Which one to pick

• Fly Sprites: one persistent computer per agent, a 100 GB disk that is cheap while asleep, and filesystem checkpoints in about a second.
• Runloop: SWE-Bench and similar benchmark runs, devboxes inside your own cloud account, and a stated readiness for SOC 2, HIPAA and GDPR.
• Runtime: processes that are still running after a pause, measured CPU at $0.025 a vCPU-hour, and no plan fee. A benchmark harness built on it is in agent evals and SWE-bench.

Pausing and coming back

Here is the pattern both rivals approximate: pause a sandbox, then reconnect later, even from a different process, and find its state where you left it.

Pythonfrom withruntime import Sandboxsbx = Sandbox.create(funding="trial", timeout_seconds=600)sbx.exec("echo state > /workspace/state.txt")sbx.pause()  # memory, files and processes kept; compute billing stopsagain = Sandbox.connect(sbx.id)again.wake(timeout_seconds=1200)print(again.exec("cat /workspace/state.txt").stdout)again.stop()

Sprites code ports directly: client.createSprite(name) is Sandbox.create(), and sprite.execFile(cmd, args) is exec([cmd, ...args]). npx withruntime compare --from fly or --from runloop reprices past usage, and npx withruntime switch --from fly before the first top-up matches that top-up with up to $100 of credit. For a hands-off port, the migration instruction lets a coding agent do it on a branch against the free trial. Full comparisons: Runtime vs Fly.io, Runtime vs Runloop.

Sources

Rates checked 23 September 2026; the Sprites, Sprites lifecycle and Runloop sizes and lifecycle pages read 25 September 2026.

• Fly.io pricing, Sprites, Sprites lifecycle
• Runloop pricing, Devbox sizes, Devbox lifecycle, Runloop
• Runtime pricing

Facts on this page were checked on 25 September 2026.