# Prized vs AWS Nitro Sandboxes and Lambda MicroVMs

> How Prized sandboxes compare with AWS Nitro Sandboxes and AWS Lambda MicroVMs on what you get, where it runs, pause with memory, fork, lifetime and price, each AWS fact from AWS's or Firecracker's own pages, checked November 10, 2026.

URL: https://prized.dev/docs/sandboxes-vs-aws-nitro-sandboxes-lambda-microvms
Updated: 2026-11-10

AWS Nitro Sandboxes are a building block: a VM boundary for workloads on your own EC2 instances, switched on per pod on Amazon EKS, per task on Amazon ECS Managed Instances, or driven by your own orchestrator. Prized [sandboxes](https://prized.dev/docs/sandboxes) (beta) and AWS Lambda MicroVMs are managed APIs for Firecracker microVMs that pause with their memory: a Lambda MicroVM lives 8 hours in all, and a Prized sandbox stays paused until you delete it and forks into live copies. Pick Nitro Sandboxes to isolate workloads you already run in your own AWS account, Lambda MicroVMs for managed sessions of up to 8 hours inside AWS, and Prized when a session has to keep its memory through a longer pause, or fork while it runs.

As of November 10, 2026. AWS announced Nitro Sandboxes on November 9, 2026, so what it does may change; we will update this page when it does.

## At a glance [#at-a-glance]

|  | Prized sandboxes | AWS Nitro Sandboxes | AWS Lambda MicroVMs |
| --- | --- | --- | --- |
| What you get | A managed API, CLI and dashboard: create a sandbox, run commands, move files, pause, fork, delete | A building block: each EKS pod, ECS Managed Instances task, or VM your own orchestrator launches runs in its own lightweight VM | A managed AWS API: build an image from your Dockerfile, then run, suspend, resume and terminate MicroVMs from it |
| Where it runs | In Prized's account, on AWS in US West (Oregon) ([Sub-processors](https://prized.dev/docs/security#sub-processors)); not in your own cloud account | On your EC2 instances of a supported type (most Nitro-based ones), in your AWS account, in all commercial AWS regions | In your AWS account, on compute Lambda runs; 14 AWS regions as of October 22, 2026 |
| Isolation | Firecracker microVM with its own kernel | A VM per pod, task or workload, isolated by the Nitro hypervisor; confidential mode adds attestation and treats the parent instance as untrusted | Firecracker microVM |
| Start time, as each states it | No figure for a new sandbox; a resume is usually back to `running` in under a second ([Pause and resume](https://prized.dev/docs/sandboxes#pause-and-resume)) | No figure in AWS's guides. AWS's EKS launch post says a warm pool hands over a VM that has already booted "in about two seconds". AWS's EKS sample measured 3.2 to 3.7 seconds from create to Ready for a sandboxed pod, on a node already up with the image already pulled, and 0.8 seconds for a warm-pool claim, timed from when the create call returned | "Rapid startup" from a snapshot; no figure stated |
| Pause and resume, memory included | Yes, kept on the machine it ran on until you delete it (30 days after last use on the free tier); a move to a different kind of machine keeps only the disk | No: Firecracker rejects pause and resume for a Nitro Sandbox. In AWS's EKS sample, a suspend ends the pod and its VM and keeps the disk volume | Yes: a suspend keeps memory and disk, by an idle policy or an API call |
| Snapshots | A paused sandbox is the saved state, and forks into copies any time; saving one as a template is not available yet | No: Firecracker rejects snapshot and restore for a Nitro Sandbox, and AWS's EKS guide lists their absence | Taken by Lambda: one when an image is built, and one at each suspend |
| Fork a running sandbox | Yes, memory included: the parent pauses while it is copied, then keeps running ([Fork](https://prized.dev/docs/sandboxes#fork)) | Not stated; snapshot and restore are rejected | Not stated; one image starts many MicroVMs, each from the image's snapshot |
| How long one lives | 24 hours of running by default, up to 7 days at a time; a resume restarts the clock, and you can extend it anytime. Paused, until you delete it. On the free tier, 60 minutes of running in all ([Run time](https://prized.dev/docs/sandboxes#run-time)) | No limit stated | 8 hours in all, running and suspended time together |
| Largest size | 32 vCPU, 128 GB of memory and 128 GB of disk; 2 vCPU and 4 GB of memory on the free tier ([Templates](https://prized.dev/docs/sandboxes#templates)) | Up to the instance's vCPU count, and the memory the instance can give it | A baseline of up to 4 vCPU and 8 GB of memory, scaling to 16 vCPU and 32 GB at peak; up to 32 GB of disk |
| GPU in the sandbox | No | No: "GPU passthrough into a Nitro Sandbox is currently unavailable" | Not stated |
| Pricing model | Per second, by vCPU, memory and disk; paused, storage only ([Billing: Sandboxes](https://prized.dev/docs/billing#sandboxes)) | No additional charge: you pay for the EC2 instances, and your usual EKS or ECS fees | Per second: a baseline while running, plus use above it; suspended, snapshot storage; snapshot reads and writes on top |
| What you operate | No infrastructure: Prized runs the hosts, kernels, images and networking | Your cluster or instances, and how many sandboxes fit on them; with your own orchestrator, also guest images, device backends, memory and CPU accounting, shutdown and attestation | Your image and each MicroVM's lifecycle; no servers or networking |

A paused Prized sandbox lives on one machine: if that machine fails, the sandbox goes to `error` and what it held is lost, so keep anything you need outside the sandbox ([Pause and resume](https://prized.dev/docs/sandboxes#pause-and-resume)).

## Price [#price]

What Prized sandboxes and Lambda MicroVMs charge, in the units AWS prices in.

|  | Prized sandboxes | AWS Lambda MicroVMs |
| --- | --- | --- |
| CPU, per vCPU-second | $0.0000111111 | $0.0000276944 |
| Memory, per GB-second | $0.0000034722 | $0.0000036667 |
| Disk, per GB-second | $0.0000000278 | No separate rate on AWS's pricing page; up to 8 GB of disk at 1 vCPU and 2 GB |
| 1 vCPU and 2 GB for an hour | $0.066, with a 10 GB disk | $0.126, before snapshot and data transfer charges |
| Paused or suspended | No compute; disk and saved memory count toward the workspace's paused storage at their full size (2 GB of memory and a 10 GB disk hold 12 GB), of which the first 20 GB are included, then $0.05 per GB-month | No compute; $0.08 per GB-month of snapshot storage (2 GB in AWS's example for this size), for the up to 8 hours a MicroVM can stay suspended |
| Each pause and resume | Not charged | $0.0038 per GB of snapshot written at a suspend, and $0.00155 per GB read at a start or resume |

AWS's prices are the ones in its pricing examples for Lambda MicroVMs, for US East (N. Virginia) on Arm; its per-second rates are before snapshot and data transfer charges. Prized's are its list rates in US West (Oregon): $0.04 per vCPU-hour, $0.0125 per GB-hour of memory and $0.0001 per GB-hour of disk ([Billing: Sandboxes](https://prized.dev/docs/billing#sandboxes)), divided by 3,600 and rounded to ten decimal places. Prized sandboxes are x86\_64; Lambda MicroVMs run on Arm, the default, or x86\_64, and AWS's pricing examples give Arm rates only.

The hour is 3,600 seconds at the rates above: 1 vCPU, 2 GB and a 10 GB disk on Prized, and 1 vCPU and 2 GB, the default baseline, on Lambda MicroVMs. A Lambda MicroVM is billed its baseline while it runs and can scale up to 4 times the baseline, 4 vCPU and 8 GB here; what it uses above the baseline is billed on top, for as long as it lasts. A Prized sandbox keeps the vCPU, memory and disk it was created with.

Nitro Sandboxes have no rate of their own (Pricing model, above).

## When AWS fits better [#when-aws-fits-better]

* **You already run EKS, ECS Managed Instances or EC2:** Nitro Sandboxes. On EKS Auto Mode it is one field on the pod, `runtimeClassName: isolated-sandbox`, at no additional charge, and the pod keeps its IAM identity, storage and networking.
* **The code has to run in your own AWS account,** for compliance or data rules: Nitro Sandboxes or Lambda MicroVMs. Prized sandboxes do not run in your account.
* **A region other than US West (Oregon):** Nitro Sandboxes are in all commercial AWS regions, and Lambda MicroVMs in 14. Prized sandboxes run in one.
* **You want to own the orchestration:** Nitro Sandboxes on EC2, with your own AMI, orchestrator and VMM.
* **Proof of what ran, or isolation from your own operators:** Nitro Sandboxes in confidential mode, with attestation.
* **Your own image:** your container images on EKS and ECS, or a Dockerfile on one of Lambda's base images for Lambda MicroVMs. Prized sandboxes have [two fixed templates](https://prized.dev/docs/sandboxes#templates).
* **Network rules for each sandbox:** on EKS, a network policy on the pod, or `sandbox.amazonaws.com/network-isolated: "true"` for no network at all; on Lambda MicroVMs, egress to the public internet or your VPC. Every Prized sandbox has outbound internet, with no allow or deny lists yet.
* **Root, system packages or Docker in the sandbox:** Lambda MicroVMs have "full operating system capabilities (for example, installing system packages or mounting filesystems)", and AWS's EKS launch post describes `docker build` jobs running inside a sandboxed pod. Prized sandboxes run commands as `prized`, without sudo, and have no Docker.
* **A managed API inside AWS, for sessions that fit in 8 hours:** Lambda MicroVMs.

## What a building block leaves to you [#what-a-building-block-leaves-to-you]

With Nitro Sandboxes, from AWS's and Firecracker's docs:

* **Orchestration.** On EKS and ECS, AWS starts a sandbox for each pod or task you mark. On EC2 your orchestrator does it: "you are the parent operator", responsible for guest images, device backends, memory and CPU accounting, shutdown and relaying attestation.
* **Memory, reserved in full.** A sandbox's memory is set aside when it starts, returns only when it terminates, and is not overcommitted. The vCPUs of all the sandboxes on an instance add up to at most 5 times the instance's own.
* **No pause and no snapshot.** Firecracker's docs: "No snapshots and no paused state, so the snapshot and pause/resume APIs do not apply." An idle session keeps running and holding its memory, or ends and starts again later from its disk, as AWS's pause and resume sample does.
* **A warm pool for fast starts.** AWS's EKS post recommends one for latency-sensitive agent sessions. Each warm sandbox holds its full memory while it waits.

## Using both [#using-both]

On AWS you can use both: run workloads in your own cluster, with Nitro Sandboxes where you want a VM boundary, and send the agent sessions that need a pause with memory past 8 hours, or a fork, to Prized over the [API](https://prized.dev/docs/sandboxes-api), outside your AWS account.

## Common questions [#common-questions]

### Do AWS Nitro Sandboxes replace a sandbox API? [#do-aws-nitro-sandboxes-replace-a-sandbox-api]

They cover isolation: each workload gets its own VM on instances you already run. Creating a sandbox for each session and cleaning it up stays with Kubernetes, ECS or your own orchestrator, and there is no pause or snapshot. For a managed API inside AWS, AWS's docs point to Lambda MicroVMs; for a pause with memory that outlasts 8 hours, or a fork, Prized.

## More [#more]

* [Prized vs E2B, Daytona and Modal](https://prized.dev/docs/sandboxes-vs-e2b-daytona-modal): the same table against three sandbox APIs.
* [Best cloud sandboxes for AI agents (2026)](https://prized.dev/docs/best-cloud-sandboxes-for-ai-agents): which fits which job.
* [AI agent sandbox that pauses with memory and runs past 24 hours](https://prized.dev/docs/sandboxes-long-running): one sandbox for an agent that works for days.
* [Fork a running VM to run work in parallel](https://prized.dev/docs/sandboxes-fork-parallel): one setup, many live copies.
* [Run hosted Firecracker microVMs for AI agents through an API](https://prized.dev/docs/sandboxes-firecracker-api): what Prized runs for you.

## Sources [#sources]

Checked November 10, 2026:

* **AWS Nitro Sandboxes:** [announcement](https://aws.amazon.com/about-aws/whats-new/2026/11/nitro-sandboxes-eks-ecs-ec2/), [EC2 User Guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/amazon-ec2-nitro-sandboxes.html), [EKS launch post](https://aws.amazon.com/blogs/containers/aws-nitro-sandboxes-hardware-enforced-workload-isolation-on-amazon-eks/), [EKS User Guide](https://docs.aws.amazon.com/eks/latest/userguide/sandboxing.html) and its [considerations](https://docs.aws.amazon.com/eks/latest/userguide/sandboxing-limitations.html), [ECS Developer Guide](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/isolated-confidential-tasks.html) and its [getting started](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ict-getting-started.html) (Managed Instances, fees), and AWS's EKS samples: [warm pool](https://github.com/aws-samples/sample-eks-nitro-sandbox/blob/43aa7c77150e4a1c456663448b5a7a0180c075fc/examples/getting-started/warm-pool/README.md) (start times), [pause and resume](https://github.com/aws-samples/sample-eks-nitro-sandbox/blob/43aa7c77150e4a1c456663448b5a7a0180c075fc/examples/agent-sandbox/pause-resume/README.md).
* **Firecracker:** [Nitro Sandboxes compared with KVM microVMs](https://github.com/firecracker-microvm/firecracker/blob/6951529f887d6d2b020e0d3dddaf349babb617d1/docs/nitro-sandboxes/comparison-with-kvm.md), on the v1.18 branch.
* **AWS Lambda MicroVMs:** [developer guide](https://docs.aws.amazon.com/lambda/latest/dg/lambda-microvms-guide.html), [running MicroVMs](https://docs.aws.amazon.com/lambda/latest/dg/microvms-launching.html) (suspend, lifetime), [images](https://docs.aws.amazon.com/lambda/latest/dg/microvms-images.html) (sizes, disk, CPU architectures), [how it works](https://docs.aws.amazon.com/lambda/latest/dg/microvms-how-it-works.html) (base images), [pricing](https://aws.amazon.com/lambda/pricing/) (the MicroVMs section and its two pricing examples, for every AWS price here), [regions, October 22, 2026](https://aws.amazon.com/about-aws/whats-new/2026/10/lambda-microvms-4-additional-regions/).

Something here out of date? Write to the support address shown on https://prized.dev/docs/troubleshooting.