# Morph vs AWS Lambda MicroVMs: branching VMs against AWS microVMs

Morph bills VMs in MCUs; Lambda MicroVMs bill a Firecracker baseline. The 2 vCPU, 4 GB benchmark is $1.67 on Morph and $4.20 on Lambda.

**Runtime is 62% cheaper than Morph and 85% cheaper than Lambda MicroVMs on
that benchmark,** 1,000 runs of a minute on 2 vCPU and 4 GiB with 20
CPU-seconds of work each. Morph's MCU pricing keeps it well under Lambda;
Runtime's measured CPU keeps it under both.

## At a glance

|           | Morph                                                 | AWS Lambda MicroVMs                  | Runtime                                     |
| --------- | ----------------------------------------------------- | ------------------------------------ | ------------------------------------------- |
| Isolation | Full virtual machines                                 | Firecracker microVM                  | Firecracker microVM, own kernel             |
| Price     | $0.05 per MCU-hour: 1 vCPU, 4 GB or 16 GB of disk     | $0.2522 an hour for 2 vCPUs and 4 GB | Measured CPU and reserved memory            |
| Branching | Infinibranch: a running VM to hundreds of replicas    | None                                 | Forks: a running sandbox to up to 10 copies |
| Lifetime  | Devboxes scale to zero and keep memory                | State kept up to 8 hours             | Pauses kept 1 to 365 days                   |
| Plan      | Free with no credit; Developer $40, Team $250 a month | None                                 | None; prepaid credit from $10               |

## Branching is the difference

Morph's reason to exist is branching a live machine, memory included, into
many copies, for agents that search several paths from one state. Lambda
MicroVMs have nothing like it; each MicroVM starts from its image or its own
snapshot. Runtime forks a running sandbox into up to ten copies with memory
and processes.

## Cost for the same job

2 vCPU and 4 GB (2 MCUs on Morph), 60 seconds, 20 CPU-seconds, 1,000 runs:

```
Morph    Size   1,000 × 60 s / 3,600 × 2 MCU × $0.05          = $1.67

Lambda   CPU    1,000 × 60 s × 2 × $0.0000276944              = $3.32
         Memory 1,000 × 60 s × 4 × $0.0000036667              = $0.88
         Total                                                  $4.20

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

With both CPUs busy for the whole minute, the totals are $1.67 on Morph, $4.20 on Lambda and $1.33 on Runtime.

## Which one to pick

- **Morph** for search over many branches of one running machine.
- **Lambda MicroVMs** for AWS-native sandboxes.
- **Runtime** for the lowest price per run, with forks when a few branches
  are enough.

See [Runtime vs Morph](/docs/morph-alternative) and
[Runtime vs AWS Lambda MicroVMs](/docs/aws-lambda-microvms-alternative).

## Sources

Morph rates checked 23 September 2026; Lambda MicroVMs rates checked 25 September 2026.

- [Morph Cloud pricing](https://cloud.morph.so/web/pricing), [Morph Devboxes](https://cloud.morph.so/web/product/devboxes)
- [AWS Lambda pricing](https://aws.amazon.com/lambda/pricing/), [Lambda MicroVMs](https://aws.amazon.com/lambda/lambda-microvms/)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.