Runtime

Morph Cloud alternatives: agent sandboxes ranked by cost

Runtime is the cheapest Morph Cloud alternative, 62% less per job, and still forks a running sandbox with its memory.

Runtime runs Morph's workload for 62% less and still forks a running sandbox with its memory. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $0.64 on Runtime and $1.67 on Morph, $103 a month saved at 100,000 runs, with no monthly plan to buy credit through. Rates checked 23 September 2026.

Estimated compute cost

62% less than Morph70% less than Vercel Sandbox77% less than E2B

2 vCPUs · 4 GiB · 60 s a run · 20 CPU-seconds busy

1,000

Compute only, at list rates checked 23 September 2026 (Morph Cloud pricing, Vercel Sandbox pricing, E2B pricing). Plan fees, network, taxes and free credits are left out. The worked example below shows the arithmetic.

Why do teams look beyond Morph?

Morph bills in MCUs, Morph Compute Units. One MCU covers 1 vCPU, 4 GB of memory or 16 GB of disk, and a machine pays for as many MCUs as its largest need, for as long as it runs. The reasons to move come from that unit:

  • The full size while it runs. A 2 vCPU machine is 2 MCUs an hour whether its CPUs are busy or waiting on a model. Runtime measures the CPU your code uses, so waiting costs a floor of a twentieth of a vCPU.
  • CPU and memory move together. A machine that needs 8 GB and 1 vCPU still pays for 2 MCUs. Runtime prices vCPUs and memory apart.
  • Credit comes through plans. The Developer plan is $40 a month with 1,000 MCUs of starting credit, and Team is $250 with 7,500. Runtime is prepaid credit from $10, with 50 free sandbox hours to start.

Which alternatives are cheapest?

List rates, one job: 1,000 runs of 60 seconds on a 2 vCPU, 4 GiB sandbox, which spends 20 CPU-seconds of each run working. Morph needs 2 MCUs an hour for that shape and ranks fifth. The arithmetic for each line is on pricing; plan fees, storage, network, free credits and negotiated prices are not in it.

# Provider Isolation CPU billed on 1,000 runs
1 Runtime 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 Fly Machines, performance-2x with 4 GB Firecracker microVM The machine's size while started $1.44
5 Morph, 2 MCUs (the one you are replacing) Full virtual machines The machine's size in MCUs $1.67
6 Vercel Sandbox, iad1 (4 GB) Firecracker microVM, own kernel Active CPU $2.12
7 CodeSandbox SDK, a Nano VM Firecracker microVM The VM's size, by the minute rounded up $2.48
8 E2B Firecracker microVM, own kernel Allocated vCPUs $2.76
9 Daytona Containers by default; VM class separate Allocated vCPUs $2.76
10 Blaxel (4 GB) Lightweight virtual machines Included with memory, active time $2.76
11 Fly Sprites (4 GB in use) Firecracker microVM Measured CPU $3.31
12 Modal Sandboxes (1 physical core) gVisor, a user-space kernel Requested or used, whichever is higher $3.97
13 Runloop, a MEDIUM devbox microVM, with a container inside Allocated CPUs while running $5.33

Cost for the same job

The working for Runtime, Morph and two microVM providers that bill differently, one on active CPU and one on allocation:

TextRuntime  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.64Morph    Size   1,000 × 60 s / 3,600 × 2 MCU × $0.05   = $1.67Vercel   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.12E2B      CPU    1,000 × 60 s / 3,600 × 2 × $0.0504     = $1.68         Memory 1,000 × 60 s / 3,600 × 4 × $0.0162     = $1.08         Total                                            $2.76

An MCU is billed in full whether it computes or not, so with both CPUs busy for the whole minute the job is still $1.67 on Morph, against $1.33 on Runtime, $5.68 on Vercel and $2.76 on E2B. Runtime remains the cheapest of the four at any load. A month of 100,000 waiting runs costs $63.89 on Runtime and $166.67 on Morph.

How each alternative serves a Morph user

1. Runtime: forks with memory, billed on use

Each sandbox is a Firecracker microVM with its own kernel. CPU is measured, at $0.025 per vCPU-hour with a floor of a twentieth of a vCPU, and memory is reserved at $0.0075 per GiB-hour, set apart from the vCPU count. One fork call turns a running sandbox into 1 to 10 copies with its files, memory and processes, and a snapshot saves that state to start more from later.

2. Northflank: separate meters, lowest allocation

$0.01667 per vCPU-hour and $0.00833 per GB-hour, so memory and CPU need not grow together as MCUs do. Sandboxes are services with deployment plans, in Northflank's regions or your AWS, GCP or Azure account.

3. Cloudflare Sandbox: Workers apps

Active CPU at $0.072 per vCPU-hour, 3 GiB per vCPU at minimum, reached from a Worker on the Workers Paid plan. After 10 idle minutes a sandbox sleeps and comes back from its image.

4. Fly Machines: memory kept through suspend

performance-2x with 4 GB is $0.0861 an hour in iad, busy or not, across 18 regions. Suspend holds a Machine's memory; the root disk is temporary.

5. Vercel Sandbox: filesystem forks only

Firecracker microVMs at $0.128 per active CPU-hour and $0.0212 per GB-hour in iad1. Its snapshots and forks copy the filesystem, and processes start over.

6. CodeSandbox SDK: memory snapshot and restore

The Nano VM (2 cores, 4 GB) costs $0.1486 an hour, rounded up to the minute. It can snapshot and restore memory, and VMs go as large as 64 cores and 128 GB.

7. E2B: allocation on microVMs

$0.0504 per vCPU-hour and $0.0162 per GiB-hour. Sessions end after 1 hour on Hobby and 24 on the $150-a-month Pro plan.

8. Daytona: GPUs and Windows

E2B's rates, containers unless you pick the VM class, GPU sandboxes and Windows machines in the US and the EU.

9. Blaxel: standby that keeps processes

Active memory at $0.0000115 per GB-second, CPU included. Standby snapshots hold files and processes for $0.20 per GB a month, and resuming takes about 25 ms.

10. Fly Sprites: sleeps on its own

$0.07 per measured CPU-hour and $0.04375 per GB-hour of memory in use. A Sprite keeps its memory for a while after sleeping and its 100 GB disk always.

11. Modal Sandboxes: GPUs beside functions

gVisor, and CPU at $0.1419 per physical core-hour on the greater of request and use.

12. Runloop: benchmark suites

$0.108 per CPU-hour and $0.0252 per GB-hour plus disk, with SWE-Bench and other public benchmarks on its devboxes.

How to switch from Morph

The pattern most Morph projects rely on, preparing a machine once and branching it, is a fork on Runtime. It copies the sandbox as it is now, running:

TypeScriptimport { Runtime, Sandbox } from "withruntime";const runtime = new Runtime();await using base = await Sandbox.create();await base.exec("pip install --quiet requests");const [a, b] = await base.fork({ count: 2 }); // both running, answered togetherawait Promise.all([a!.stop(), b!.stop()]);// Or keep the machine to start copies from later:const snapshot = await base.snapshot({ name: "with-requests", retentionDays: 7 });await using later = await runtime.sandboxes.create({ snapshot: snapshot.id });await runtime.snapshots.delete(snapshot.id);

A plain run is a create, an exec and a stop:

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

If a coding agent should do the work, give it the instruction in migration: it ports the project on a branch, runs it on the free trial and reports the monthly saving. After a few runs, npx withruntime compare --from morph shows what your own sandboxes would have cost at Morph's published rates. More on branching: sandbox fork and RL environments.

Sources

Rival rates were checked 23 September 2026, and Morph's pricing page was read again on 25 September 2026.

Claim 50 hours free