# E2B vs Morph: Morph is 40% cheaper per agent run Runtime Cloud (withruntime.com) costs 62% less than Morph. E2B bills vCPUs and memory separately; Morph bills a whole machine. ## Which is better, E2B or Morph? It depends on machine size and branching. For agents that wait on a model, Runtime costs the least, and it stays cheapest when the CPUs are busy: $0.64 for this job, against $1.67 on Morph and $2.76 on E2B. Runtime's forks keep memory, and it has no monthly plan. Pick Morph to branch a running machine into hundreds of replicas, or for machines up to 1,024 vCPUs. Pick E2B to self-host, or for 20 concurrent sandboxes on a free plan. ## At a glance | | E2B | Morph Cloud | Runtime | | ------------------ | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------ | | Isolation | Firecracker microVM, own kernel | Full virtual machines | Firecracker microVM, own kernel | | Price | $0.0504 per vCPU-hour, $0.0162 per GiB-hour | $0.05 per MCU-hour: 1 vCPU, 4 GB of memory or 16 GB of disk | $0.025 per vCPU-hour of measured CPU, $0.0075 per GiB-hour | | How size is billed | vCPUs plus memory | Whichever of CPU, memory or disk needs the most MCUs | Measured CPU plus reserved memory | | Largest machine | 8 vCPUs and 8 GiB | 64 vCPUs and 256 GB free; 256 on Team, 1,024 on Scale | Up to 16 vCPUs and 64 GiB, sized separately | | Plan fee | Hobby $0; Pro $150 per month | Developer free with no credit; Team $40 and Scale $250 per month | None; prepaid credit from $10 | | Free start | $100 of usage credit, once | 1,000 MCUs with the $40 Team plan | 100 free hours of a 1 GB machine in the first 30 days, no card | | At once | 20 on Hobby, 100 on Pro | 8 devboxes free, 32 on Team, 128 on Scale | 4 without credit; 100 paid | | Branching | Pause keeps files, memory and processes | Infinibranch: a running machine to hundreds of replicas | Forks: 1 to 100 running copies with memory and processes | ## Is Morph cheaper than E2B? For a 2 vCPU, 4 GB machine, yes. One MCU covers 1 vCPU, 4 GB of memory or 16 GB of disk, and a machine pays for whichever resource needs the most MCUs. 2 vCPUs need 2 MCUs and 4 GB needs 1, so the machine is 2 MCUs: $0.10 an hour. E2B charges $0.1008 for the two vCPUs and $0.0648 for the memory, $0.1656 an hour. The MCU rule favors shapes with about 4 GB per vCPU. A 2 vCPU machine with 8 GB is still 2 MCUs on Morph, $0.10 an hour, while E2B adds $0.0648 an hour for the extra memory. A machine with more CPU than memory pays for each vCPU on both. Morph's plans matter too. Its free tier includes no MCUs; the $40 Team plan includes 1,000 and runs 32 devboxes concurrently. E2B's free Hobby plan runs 20 and comes with $100 of credit. Runtime charges for neither the machine nor its allocation: it measures the CPU a run uses, so an agent waiting on a model pays a floor of a twentieth of a vCPU while it waits. ## Cost for the same job 1,000 runs of a 2 vCPU, 4 GiB sandbox (2 MCUs on Morph). Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds: an agent that mostly waits for a model. ``` 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 Morph Size 1,000 × 60 s / 3,600 × 2 MCU × $0.05 = $1.67 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 per month, that is $276.00 on E2B, $166.67 on Morph and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on Runtime, against $2.76 on E2B and $1.67 on Morph, so Runtime is cheaper however busy the sandbox is. Plan fees, included credit, storage, network and taxes are left out. ## Can I branch a running sandbox? On Morph, yes: Infinibranch copies a running machine, memory included, to hundreds of parallel replicas. E2B pauses and resumes a sandbox with its memory and processes, and keeps a paused one with no expiry. Runtime forks a running sandbox into 1 to 100 copies, each with the source's files, memory and running processes, and keeps a snapshot to start more later: ```python check from withruntime import Runtime runtime = Runtime() image = runtime.images.build(name="data", recipe={"pip": ["pandas"], "apt": ["jq"]}, on_log=lambda line: print(line["text"])) with runtime.sandboxes.create(image=image["id"]) as base: forks = base.fork(count=2) # copies as it is now, running for fork in forks: fork.stop() snapshot = base.snapshot(name="with-pandas", retention_days=7) with runtime.sandboxes.create(snapshot=snapshot["id"]): pass runtime.snapshots.delete(snapshot["id"]) ``` ## Which one to pick - **Pick E2B** for vCPUs and memory set separately, a free plan with $100 of credit and 20 concurrent sandboxes, or a runtime you can self-host under Apache-2.0. - **Pick Morph** for machines up to 1,024 vCPUs, branching a running machine into hundreds of replicas, or shareable Devboxes that scale to zero and keep their memory. - **Pick Runtime** for 77% below E2B's price and 62% below Morph's on an agent that waits, with no monthly plan, 100 concurrent sandboxes on a paid account, and forks that keep memory. ## Runtime Cloud Runtime runs the same job for 77% less than E2B and 62% less than Morph. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $2.76 on E2B, $1.67 on Morph and $0.64 on Runtime. Runtime bills the CPU your code uses rather than the machine it holds, and needs no monthly plan. Rates checked 25 October 2026. Create a free account with `npx withruntime login`. It includes monthly usage to test forks. E2B code and Morph's TypeScript client move over with the [migration guide](/docs/migrate). ## Switch from either one From E2B, Runtime's SDK runs your code after one import change: ```ts no-run import { Sandbox } from "withruntime/e2b"; // was: from "e2b" ``` ```python no-run from withruntime.e2b import Sandbox # was: from e2b import Sandbox ``` From Morph, a started instance becomes `Sandbox.create()`, commands run with `exec`, and stopping becomes `stop()`. A snapshot you start instances from becomes a Runtime snapshot, and a branch becomes `fork`: ```ts import { 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(); } ``` Or give your coding agent the one instruction in [migration](/docs/migrate): it switches the project on a branch, tests it on the free usage and reports the monthly saving. The full comparisons are [Runtime vs E2B](/docs/e2b-alternative) and [Runtime vs Morph](/docs/morph-alternative). For evals that fan out from one prepared machine, see [agent evals and SWE-bench](/use-cases/agent-evals-and-swe-bench). ## Sources E2B and Morph pricing pages rechecked 25 October 2026; the rest checked 25 October 2026. - [E2B pricing](https://e2b.dev/pricing), [E2B sandbox persistence](https://docs.e2b.dev/sandbox/persistence) - [Morph Cloud pricing](https://cloud.morph.so/web/pricing), [Morph Devboxes](https://cloud.morph.so/web/product/devboxes), [Morph snapshots](https://cloud.morph.so/docs/documentation/instances/creating-snapshot) - Runtime [pricing](/docs/pricing) and [Python guide](/docs/python#images-volumes-and-snapshots) Facts on this page were checked on 26 October 2026.