# Vercel Sandbox vs Runloop: pricing, isolation and limits

Vercel Sandbox bills active CPU and Runloop bills every CPU a devbox holds, so an agent that waits on a model costs less on Vercel.

**Runtime runs the same job for 70% less than Vercel and 88% less than
Runloop.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.12 on
Vercel, $5.33 on Runloop and $0.64 on Runtime. Runtime bills measured CPU like
Vercel, at about a fifth of Vercel's rate, and a paused Runtime sandbox keeps
its running processes, which neither rival does. Rates checked 23 September 2026.

## At a glance

Vercel's figures are at the rates of its default `iad1` region. Runloop's are
for its `MEDIUM` devbox: 2 CPUs, 4 GB and 8 GB of disk.

|                 | Vercel Sandbox                                       | Runloop                                   | Runtime                                                  |
| --------------- | ---------------------------------------------------- | ----------------------------------------- | -------------------------------------------------------- |
| Isolation       | Firecracker microVM, own kernel                      | microVM, with a container inside          | Firecracker microVM, own kernel                          |
| CPU             | $0.128 per active CPU-hour                           | $0.108 per CPU-hour while the devbox runs | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory          | $0.0212 per provisioned GB-hour                      | $0.0252 per GB-hour                       | $0.0075 per reserved GiB-hour                            |
| Plan fee        | Hobby allowance free; usage beyond it needs Pro      | Basic free; Pro $250 a month plus usage   | None; prepaid credit from $10                            |
| Free start      | 5 active CPU-hours and 420 GB-hours a month on Hobby | $50 of credit, no card                    | 50 sandbox hours, no card                                |
| Stop or suspend | Stop keeps the filesystem; processes start again     | Suspend keeps the disk; processes restart | Pause keeps files, memory and processes, 1 to 365 days   |
| Session length  | 45 minutes on Hobby, 24 hours on Pro                 | Not stated on the pricing page            | Leases of up to an hour, extended as often as needed     |

## Why does Runloop cost more than twice as much for the same agent?

Because of what each one counts. Runloop bills both of a devbox's CPUs for
every second it runs, at $0.108 a CPU-hour, whether the code is computing or
waiting for a model to answer. Vercel bills only the CPU time a sandbox uses:
time spent waiting on I/O does not count. In the example below the agent is
busy for 20 of its 120 CPU-seconds, so Vercel charges for a sixth of what
Runloop charges for.

The gap closes as the work gets busier. Runloop's rate per CPU-hour is lower
than Vercel's, and its total does not change with load, so Runloop becomes the
cheaper of the two only when a run keeps its CPUs busy for more than about 110
of its 120 CPU-seconds. Memory is the other difference: $0.0212 per GB-hour on
Vercel against $0.0252 on Runloop, and Runloop adds a small disk charge.

## Cost for the same job

1,000 runs of a 2 vCPU sandbox with 4 GiB, or 4 GB on Vercel and Runloop. Each
run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds: an agent that
mostly waits for a model.

```
Vercel   CPU    1,000 × 20 s / 3,600 × $0.128           = $0.71
         Memory 1,000 × 60 s / 3,600 × 4 × $0.0212      = $1.41
         Total                                             $2.12

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 $212.44 on Vercel, $532.56 on Runloop and
$63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on
Runtime against $5.68 on Vercel and $5.33 on Runloop, so Runtime is cheaper
however busy the sandbox is. Plan fees, creations, storage while stopped or
suspended, network and free allowances are left out.

## What survives a stop or a suspend?

On both rivals, files do and processes do not. A stopped Vercel sandbox keeps
its filesystem and its processes start again. A suspended Runloop devbox keeps
its disk, its ID and its SSH keys, and Runloop's docs say daemons running at
suspend time must be restarted by hand. Runloop stops billing compute while a
devbox is suspended and keeps billing its storage.

A paused Runtime sandbox keeps its memory and running processes as well as its
files, and wakes on the next request, so a dev server or a half-finished agent
loop carries on where it was. [Forks](/glossary/sandbox-fork) copy a running
sandbox the same way:

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

const sbx = await Sandbox.create({ timeoutSeconds: 600 });
await sbx.exec("echo state > /workspace/state.txt");
await sbx.pause(); // memory and files are kept; compute billing stops
// ... later, even from another process:
const again = await Sandbox.connect(sbx.id);
await again.wake({ timeoutSeconds: 1200 });
await again.stop();
```

See [how to pause and resume a sandbox](/how-to/pause-and-resume-a-sandbox).

## Which one to pick

- **Pick Vercel Sandbox** if your app already lives on Vercel, or you need
  sandboxes in many regions: Vercel runs them in 19, with up to 10,000 at once
  on Pro.
- **Pick Runloop** if you want agent benchmarks run for you (it runs SWE-Bench
  and other public benchmarks and builds custom ones from your data), or need
  devboxes deployed into your own cloud account with SOC 2, HIPAA and GDPR
  readiness.
- **Pick Runtime** for measured CPU at about a fifth of Vercel's rate and under
  a quarter of Runloop's, pause and forks that keep running processes, and no
  plan fee. For running benchmarks yourself, see
  [agent evals and SWE-bench](/use-cases/agent-evals-and-swe-bench).

## Switch from either one

From Vercel Sandbox, Runtime's SDK runs your code after one import change, with
no Vercel project or token:

```ts no-run
import { Sandbox } from "withruntime/vercel"; // was: from "@vercel/sandbox"
```

```python no-run
from withruntime.vercel import sandbox  # was: from vercel import sandbox
```

From Runloop there is no compatible import. Create a Runtime sandbox where you
create a devbox, run commands with `exec`, move files with `files.write` and
`files.read`, and call `stop()` where you shut the devbox down. Where you
suspend and resume, use `pause()` and `wake()`, and the processes come back too.

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. From Vercel, `npx withruntime switch --from vercel` before your
first top-up matches that top-up with credit, up to $100. The full
side-by-sides are [Runtime vs Vercel Sandbox](/docs/vercel-sandbox-alternative)
and [Runtime vs Runloop](/docs/runloop-alternative).

## Sources

Rates checked 23 September 2026; Runloop's devbox lifecycle page read 25
September 2026.

- [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing), [Understanding Vercel Sandboxes](https://vercel.com/docs/sandbox/concepts)
- [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)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.