# 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. ## 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](/docs/pricing#published-rate-comparison); 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: ``` 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 Morph Size 1,000 × 60 s / 3,600 × 2 MCU × $0.05 = $1.67 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 E2B 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: ```ts check import { 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 together await 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: ```python from withruntime import Sandbox with 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](/docs/migrate): 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](/glossary/sandbox-fork) and [RL environments](/use-cases/rl-environments). ## Sources Rival rates were checked 23 September 2026, and Morph's pricing page was read again on 25 September 2026. - [Morph Cloud pricing](https://cloud.morph.so/web/pricing) - [Northflank pricing](https://northflank.com/pricing) Facts on this page were checked on 25 September 2026. - [Fly.io pricing](https://fly.io/pricing/) - [E2B pricing](https://e2b.dev/pricing) - [Runloop pricing](https://www.runloop.ai/pricing) - [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing) - [Together Code Sandbox](https://docs.together.ai/docs/together-code-sandbox) - [Modal pricing](https://modal.com/pricing) - [Blaxel pricing](https://blaxel.ai/pricing) - [Cloudflare Containers pricing](https://developers.cloudflare.com/containers/pricing/) - [Daytona pricing](https://www.daytona.io/pricing) - Runtime [pricing](/docs/pricing) and the [Morph comparison](/docs/morph-alternative)