What is the best alternative to Runloop?
It depends on whether you came to Runloop for its evaluation tooling. For agents that mostly wait on a model, Runtime has the lowest bill: $0.64 for the job below, against $5.33 on Runloop. It also forks one prepared sandbox into many running copies with their memory. If evaluating models on your own workload is the main reason you use Runloop, staying may be worth the price. Pick Northflank to keep sandboxes in your own cloud account, and Daytona for GPUs.
Why do teams look beyond Runloop?
Runloop's devboxes are aimed at agent development and evaluation. Runloop is the most expensive provider in the published rate comparison for this job. The reasons to move follow from its meters and lifecycle:
- Every meter is higher. $0.108 per CPU-hour against Runtime's $0.025, and $0.0252 per GB-hour of memory against $0.0075 per GiB-hour, plus disk at $0.00034236 per GB-hour while a devbox runs.
- CPUs are billed while held. A devbox's CPUs count for as long as it runs, so an agent waiting on a model pays for them. Runtime measures CPU.
- Suspend keeps only the disk. A suspended devbox keeps its disk, and its processes must be restarted. A paused Runtime sandbox wakes with its processes still running, kept while you have credit.
- Suspend is a Pro feature. Runloop's pricing page, read on 25 October 2026, lists suspend and resume under Pro. Every Runtime account can pause a sandbox, and a sandbox left idle pauses by itself.
- The plan. Pro is $250 a month plus usage. Runtime has no plan fee: prepaid credit from $10, with 100 free hours of a 1 GB machine in the first 30 days.
Which alternatives are cheapest?
The whole table uses one job at list rates: 1,000 runs, 60 seconds
each, on a 2 vCPU, 4 GiB sandbox that works for 20 CPU-seconds per run. On
Runloop that is a MEDIUM devbox with 2 CPUs, 4 GB and 8 GB of disk, and it
comes last. Row-by-row sums are on
pricing. They exclude plan fees,
storage, network, credits and negotiated rates.
| # | Provider | Isolation | CPU billed on | 1,000 runs |
|---|---|---|---|---|
| 1 | Runtime Cloud | Firecracker microVM, own kernel | Measured CPU, with a small floor | $0.64 |
| 2 | Northflank | microVMs for CPU work, gVisor for GPU work | Allocated vCPUs | $1.11 |
| 3 | Cloudflare Sandbox (2 vCPU, 6 GiB, 12 GB disk) | A container in its own VM | Active CPU | $1.35 |
| 4 | Prime Sandboxes (5 GiB disk) | microVM, own guest kernel | Allocated vCPUs while running | $1.52 |
| 5 | Fly Machines, performance-2x with 4 GB |
Firecracker microVM | The machine's size while started | $1.53 |
| 6 | Morph, 2 MCUs | Full virtual machines | The machine's size in MCUs | $1.67 |
| 7 | Vercel Sandbox, iad1 (4 GB) |
Firecracker microVM, own kernel | Active CPU | $2.12 |
| 8 | Freestyle (32 GiB disk) | Full Linux virtual machines | Allocated vCPUs | $2.25 |
| 9 | Fly Sprites (4 GB in use) | Firecracker microVM | Measured CPU | $2.40 |
| 10 | CodeSandbox SDK, a Nano VM | Firecracker microVM | The VM's size, by the minute rounded up | $2.48 |
| 11 | E2B | Firecracker microVM, own kernel | Allocated vCPUs | $2.76 |
| 12 | Daytona | Containers by default; VM class separate | Allocated vCPUs | $2.76 |
| 13 | Blaxel (4 GB) | Lightweight virtual machines | Included with memory, active time | $3.45 |
| 14 | Modal Sandboxes (1 physical core) | gVisor, a user-space kernel | Requested or used, whichever is higher | $3.97 |
| 15 | AWS Lambda MicroVMs, Arm | Firecracker microVM | Baseline vCPUs while running | $4.20 |
| 16 | Runloop, a MEDIUM devbox (the one you are replacing) |
microVM, with a container inside | Allocated CPUs while running | $5.33 |
Cost for the same job
The arithmetic for Runtime, Runloop, and two rivals that also bill CPU for the whole run, one on allocation and one on request:
- CPU
- 1,000 × 20 s / 3,600 × $0.025
- $0.14
- Memory
- 1,000 × 60 s / 3,600 × 4 × $0.0075
- $0.50
- 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
- CPU
- 1,000 × 60 s / 3,600 × 2 × $0.0504
- $1.68
- Memory
- 1,000 × 60 s / 3,600 × 4 × $0.0162
- $1.08
- CPU
- 1,000 × 60 s × 1 core × $0.00003942
- $2.37
- Memory
- 1,000 × 60 s × 4 × $0.00000667
- $1.60
Runloop already bills its CPUs as if they were always working. So with both CPUs busy for the whole minute, the job costs $1.33 on Runtime, $5.33 on Runloop, $2.76 on Daytona and $3.97 on Modal. Runloop's CPU line alone, $3.60, is more than Runtime's whole busy job. A month of 100,000 waiting runs comes to $63.89 on Runtime and $532.56 on Runloop.
What each alternative offers a Runloop user
1. Northflank: in your own cloud, for less
The lowest allocated rates here, $0.01667 per vCPU-hour and $0.00833 per GB-hour. Like Runloop, it deploys into your AWS, GCP or Azure account, and each sandbox is a service with a deployment plan.
2. Cloudflare Sandbox: Workers-first
Active CPU at $0.072 per vCPU-hour and no less than 3 GiB per vCPU, invoked from a Worker on the Workers Paid plan. Public-beta filesystem snapshots restore saved files after a stop. Memory and processes restart.
3. Fly Machines: flat price per size
performance-2x with 4 GB costs $0.0916704 an hour in iad, whatever the load,
in 17 regions.
4. Morph: many branches of one machine
$0.05 per MCU-hour, one MCU being 1 vCPU, 4 GB of memory or 16 GB of disk. Infinibranch makes hundreds of replicas of a running machine with its memory, which suits search over many attempts.
5. Vercel Sandbox: wide concurrency
Firecracker at $0.128 per active CPU-hour and $0.0212 per GB-hour in iad1,
with up to 10,000 sandboxes running in parallel on Pro.
6. CodeSandbox SDK: fixed sizes in credits
A Nano VM (2 cores, 4 GB) is $0.1486 an hour, billed minute by minute and rounded up. Beyond 10 VMs running at the same time, the Scale plan is $170 a month.
7. E2B: about half Runloop's price for this job
Allocated at $0.0504 per vCPU-hour and $0.0162 per GiB-hour, $2.76 here. Hobby caps sessions at an hour and Pro, at $150 a month, at 24; the runtime is Apache-2.0.
8. Daytona: GPUs for model work
E2B's rates, containers by default with VMs as a separate class, GPU sandboxes, Windows machines and $200 of free compute.
9. Blaxel: standby that holds processes
$0.0000115 per GB-second of active time, with CPU included. Standby keeps files and processes, and wakes in about 25 ms.
10. Fly Sprites: self-pausing sandboxes
$0.0385 per measured CPU-hour and $0.021875 per GB-hour of memory in use. The 100 GB disk is always kept.
11. Modal Sandboxes: GPUs and functions
gVisor at $0.1419 per physical core-hour on the higher of request and use, alongside Modal's functions.
Runtime Cloud
Runtime runs Runloop's devbox workload for 88% less, with memory that
survives a pause. On Runtime, the 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost
$0.64, against $5.33 on a Runloop MEDIUM devbox. That is $469 a month saved at
100,000 runs, with no $250 plan. That places Runtime first in the
table above. Rates checked 25 October 2026.
A Firecracker microVM with its own kernel per sandbox, at $0.025 per vCPU-hour of measured CPU, floored at a twentieth of a vCPU, and $0.0075 per reserved GiB-hour. Prepare an environment once and fork it into 1 to 100 running copies, memory and processes included, so every attempt at a task starts from the same point.
Start free with npx withruntime login and build one prepared sandbox to fork.
The migration guide and the next section cover devbox code.
How to switch from Runloop
A devbox created per task becomes a sandbox created per task:
TypeScriptimport { Sandbox } from "withruntime";const box = await Sandbox.create();try { await box.files.write("/workspace/invoice.py", "print(sum([125, 250, 375]))\n"); console.log((await box.exec("python3 /workspace/invoice.py", { check: true })).stdout);} finally { await box.stop();}For benchmark runs, set the environment up once and fork it, so every attempt starts from the same running machine:
Pythonfrom withruntime import Sandboxwith Sandbox.create() as base: base.exec("pip install --quiet requests") forks = base.fork(count=2) # copies as it is now, running for fork in forks: fork.stop()You can also give a coding agent the single instruction in
migration. It converts the project on a branch, checks it on
the free usage and tells you the monthly saving. After a few runs,
npx withruntime compare --from runloop prices those same sandboxes at
Runloop's published rates. For evaluation work, see
agent evals and SWE-bench and
RL environments.
Sources
Cloudflare sandbox lifetime, snapshot behavior checked 25 October 2026. Rival rates were checked 25 October 2026, with Runloop's pricing page read again on 26 October 2026.
Runloop pricing Facts on this page were checked on 26 October 2026.
Runtime pricing and the Runloop comparison