# Runtime vs Modal Sandboxes

Runtime gives each agent sandbox its own kernel in a Firecracker microVM, where Modal uses gVisor, and bills CPU by use.

This page compares the two for teams looking for a Modal Sandboxes alternative.
Facts about Modal come from its public pricing and documentation, checked
22 September 2026; check the links at the end before relying on them. Equal CPU
counts do not prove equal performance, and the two services have not been
benchmarked against each other.

## At a glance

|                | Runtime                                                  | Modal Sandboxes                                           |
| -------------- | -------------------------------------------------------- | --------------------------------------------------------- |
| Isolation      | Firecracker microVM, own kernel                          | gVisor, a user-space kernel that intercepts system calls  |
| CPU billing    | $0.025 per vCPU-hour of measured CPU, with a small floor | $0.1419 per physical core-hour (2 vCPUs), request or use  |
| Memory billing | $0.0075 per reserved GiB-hour                            | $0.0240 per GiB-hour, request or use                      |
| Plan fee       | None; prepaid credit from $10                            | Starter $0 with $30 a month of compute; Team $250 a month |
| Free start     | 20 sandbox hours, no card                                | $30 of compute a month on Starter                         |
| Session length | Leases of up to an hour, extended as often as needed     | Up to 24 hours; snapshots carry state beyond that         |
| Setup          | One call; no app or project                              | A Modal App is needed outside Modal                       |
| GPUs           | None                                                     | Yes                                                       |

## Cost for the same job

Take 1,000 runs of a sandbox with 2 vCPUs (one physical core on Modal) and
4 GiB. Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds,
which is typical of an agent that spends most of its time waiting for a model.

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

Modal    CPU    1,000 × 60 s × 1 core × $0.00003942 = $2.37
         Memory 1,000 × 60 s × 4 × $0.00000667      = $1.60
         Total                                        $3.97
```

Modal charges whichever is higher, the resources a sandbox requested or the
resources it used, so a requested core is billed while it waits. A smaller
request lowers Modal's figure but also caps what the sandbox can use when it
needs it. With both CPUs busy for the whole minute, the same job costs $1.33 on
Runtime and $3.97 on Modal. Plan fees, storage, network, taxes and free credits
are excluded from both. See [pricing](./pricing) for Runtime's terms.

## Where Modal is stronger

- **GPUs.** Modal sandboxes can use GPUs. Runtime has none.
- **A whole platform.** Functions, web endpoints, scheduled jobs and volumes sit
  beside sandboxes in the same account and SDK.
- **Snapshots.** Modal snapshots a sandbox's filesystem, and its memory, to start
  others from. Runtime's snapshots and forks are paused while an issue is fixed;
  build a [custom image](./javascript#custom-images) to start many sandboxes
  from one setup.
- **Track record and reach.** Modal has run production workloads for years.
  Runtime opened public signup in September 2026 and runs in one region.

## Where Runtime is stronger

- **Own kernel per sandbox.** A microVM puts a hardware virtualization boundary
  between sandboxes. Runtime has not completed an outside security audit; see
  [security](./security).
- **Cost for agents that wait.** CPU you do not use is not billed, and there is
  no request to size in advance.
- **Setup by the agent.** An agent runs `npx withruntime run --trial -- ...`,
  shows you a link, and starts work once you approve it in the browser. No API
  key is copied into a prompt or a config file, and the [MCP server](./mcp)
  reuses the same connection.
- **Pause with memory, by default.** Every sandbox can pause and wake with its
  processes running, with paid retention from 1 to 365 days.

## Moving from Modal

Modal:

```python check
import modal
app = modal.App.lookup("my-app", create_if_missing=True)
sb = modal.Sandbox.create(app=app)
process = sb.exec("python3", "-c", "print(6 * 7)")
print(process.stdout.read())
sb.terminate()
```

Runtime:

```python
from withruntime import Sandbox
with Sandbox.create(funding="trial") as box:
    print(box.exec("python3 -c 'print(6 * 7)'", check=True).stdout)
```

To have a coding agent make the switch, test it and compare costs on your own
workload, give it the prompt in [migration](./migrate). Keep Modal available
until the same job passes on both.

## Sources

- [Modal pricing](https://modal.com/pricing)
- [Modal resources and billing](https://modal.com/docs/guide/resources)
- [Modal Sandboxes](https://modal.com/docs/guide/sandbox)
- [Modal security](https://modal.com/docs/guide/security)
- Runtime [pricing](./pricing), [security](./security) and [products](./products)