# Fly Machines vs Runloop: pricing, devboxes and limits

A 2 CPU, 4 GB Runloop devbox costs $0.3195 an hour; a Fly Machine of that size costs $0.0861. Runloop adds agent benchmarks.

**Runtime runs the same job for 55% less than a Fly Machine and 88% less than
Runloop.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $1.44 on Fly
Machines, $5.33 on Runloop and $0.64 on Runtime, because Runtime bills the CPU
your code uses rather than the CPUs it holds. A paused Runtime sandbox keeps
its memory and running processes, which neither rival's suspend does at this
size. Rates checked 23 September 2026.

## At a glance

|                 | Fly Machines                                         | Runloop                                                  | Runtime                                                  |
| --------------- | ---------------------------------------------------- | -------------------------------------------------------- | -------------------------------------------------------- |
| Isolation       | Firecracker microVM                                  | microVM, with a container inside                         | Firecracker microVM, own kernel                          |
| CPU             | Inside a fixed size, billed while started            | $0.108 per CPU-hour while the devbox runs                | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory          | Inside the size; more at $5 per GB a month           | $0.0252 per GB-hour                                      | $0.0075 per reserved GiB-hour                            |
| Disk            | Root disk temporary; Fly Volumes for files that last | $0.00034236 per GB-hour; `MEDIUM` comes with 8 GB        | Included while running                                   |
| 2 vCPU, 4 GB    | `performance-2x`, $0.0861 an hour (`iad`)            | `MEDIUM`, $0.3195 an hour                                | $0.08 an hour fully busy, $0.03125 waiting               |
| Sizes           | Fixed sizes up to 16 performance vCPUs and 128 GB    | `X_SMALL` to `XX_LARGE`, or custom up to 16 CPUs, 64 GiB | vCPUs and memory chosen per sandbox                      |
| Plan fee        | None; pay as you go                                  | Basic free; Pro $250 a month plus usage                  | None; prepaid credit from $10                            |
| Free start      | Not stated on the pricing page                       | $50 of credit, no card                                   | 50 sandbox hours, no card                                |
| Suspend, resume | Keeps memory only for Machines with 2 GB or less     | Keeps the disk; processes restart                        | Pause keeps files, memory and processes, 1 to 365 days   |

## Why does a Runloop devbox cost almost four times a Machine?

The rates. Runloop bills $0.108 per CPU-hour, $0.0252 per GB-hour of memory
and its disk by the GB-hour, so its `MEDIUM` devbox, 2 CPUs, 4 GB and 8 GB of
disk, comes to $0.3195 an hour. A Fly `performance-2x` with 4 GB is $0.0861,
about 27% of that. Both bill the whole size for as long as it runs, busy or
waiting.

What the premium buys is around the VM rather than in it: Runloop runs
SWE-Bench and other public benchmarks, builds custom ones from your data,
deploys into your own cloud account and states SOC 2, HIPAA and GDPR
readiness. A Fly Machine is a general-purpose VM in 18 regions, with volumes
and Managed Postgres in the same account.

Runtime is priced below both for agent work, since it bills measured CPU at
$0.025 a vCPU-hour; [agent evals and SWE-bench](/use-cases/agent-evals-and-swe-bench)
shows how to run a benchmark harness on it.

## Cost for the same job

1,000 runs of a 2 vCPU, 4 GiB sandbox. Each run lasts 60 seconds and keeps the
CPU busy for 20 CPU-seconds: an agent that mostly waits for a model. The Fly
Machine is a `performance-2x` with 4 GB; the Runloop devbox is a `MEDIUM`.

```
Machines  Size   1,000 × 60 s / 3,600 × $0.0861           = $1.44

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
```

At 100,000 runs a month that is $143.50 on Fly Machines, $532.56 on Runloop
and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on
Runtime against $1.44 on Machines and $5.33 on Runloop, so Runtime is cheaper
however busy the sandbox is. Plan fees, storage while suspended, network and
free credits are left out.

## What survives a suspend?

On Runloop, only the disk. Its lifecycle docs say in-memory state is not kept
across suspend and resume, though the devbox keeps its ID and SSH keys, and a
suspended devbox is charged for storage until it is shut down. Compute stops
while it is suspended.

A Fly Machine's suspend keeps the whole VM, memory and open files included,
and resumes in a few hundred milliseconds, but it needs 2 GB of memory or
less, so the 4 GB size here only stops. Fly also says a deploy, a host
migration or maintenance discards a suspended snapshot.

A paused Runtime sandbox keeps its files, memory and running processes at any
size, for 1 to 365 days, at $0.08 per GB a month, and a request to it wakes it
by itself.

## Which one to pick

- **Pick Fly Machines** for a service that stays up near its users, at a low
  hourly price, in any of 18 regions.
- **Pick Runloop** if you want benchmarks run for you, a deployment in your own
  cloud, or a stated compliance posture.
- **Pick Runtime** for agent sandboxes that pause and resume with their
  processes still running, measured CPU, and no plan fee.

## Switch from either one

A suspended devbox that must restart its processes becomes a paused sandbox
that carries on where it stopped:

```ts check
import { Sandbox } from "withruntime";

const sbx = await Sandbox.create({ funding: "trial", timeoutSeconds: 600 });
await sbx.exec("echo state > /workspace/state.txt");
await sbx.pause(); // memory, files and processes kept; compute billing stops
const again = await Sandbox.connect(sbx.id);
await again.wake({ timeoutSeconds: 1200 });
console.log((await again.exec("cat /workspace/state.txt")).stdout);
await again.stop();
```

Or give your coding agent the one instruction in [migration](/docs/migrate): it
switches the project on a branch, tests it on the free trial and reports the
monthly saving. `npx withruntime compare --from fly-machines` (or
`--from runloop`) prices what you ran at the old provider's rates, and
`npx withruntime switch --from fly` before your first top-up matches that
top-up with credit, up to $100. The full side-by-sides are
[Runtime vs Fly.io](/docs/fly-alternative) and
[Runtime vs Runloop](/docs/runloop-alternative).

## Sources

Rates checked 23 September 2026; the Fly suspend page and Runloop's sizes and
lifecycle pages read 25 September 2026.

- [Fly.io pricing](https://fly.io/pricing/), [Machine suspend and resume](https://docs.fly.io/reference/suspend-resume/), [Fly.io regions](https://fly.io/docs/reference/regions/)
- [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) and [JavaScript SDK](/docs/javascript#pause-wake-extend)

Facts on this page were checked on 25 September 2026.