# 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](/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. ``` Sprites 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.31 Runloop 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.33 Runtime 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](/use-cases/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. ```python check from withruntime import Sandbox sbx = Sandbox.create(funding="trial", timeout_seconds=600) sbx.exec("echo state > /workspace/state.txt") sbx.pause() # memory, files and processes kept; compute billing stops again = 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](/docs/migrate) instruction lets a coding agent do it on a branch against the free trial. Full comparisons: [Runtime vs Fly.io](/docs/fly-alternative), [Runtime vs Runloop](/docs/runloop-alternative). ## Sources Rates checked 23 September 2026; the Sprites, Sprites lifecycle and Runloop sizes and lifecycle pages read 25 September 2026. - [Fly.io pricing](https://fly.io/pricing/), [Sprites](https://fly.io/sprites/), [Sprites lifecycle](https://docs.fly.io/sprites/concepts/lifecycle/) - [Runloop pricing](https://www.runloop.ai/pricing), [Devbox sizes](https://docs.runloop.ai/docs/devboxes/configuration/sizes), [Devbox lifecycle](https://docs.runloop.ai/docs/devboxes/lifecycle), [Runloop](https://www.runloop.ai/) - Runtime [pricing](/docs/pricing) Facts on this page were checked on 25 September 2026.