AWS Lambda MicroVMs Now Runs on x86: Pricing, Limits, Regions and How It Compares With Fargate
Lambda MicroVMs now supports x86. US East Arm vs x86 prices, all 14 Regions, the 8-hour and size limits, and how MicroVMs compare with Lambda and Fargate.

AWS Lambda MicroVMs, the isolated "sandbox" VMs AWS launched in June for running untrusted or AI-generated code, now run on x86 as well as Arm (Graviton). AWS announced the change on 11 November 2026. You pick x86 when you build a MicroVM image, and it works in 10 of the 14 Regions where MicroVMs are offered. In US East (N. Virginia), x86 costs about 18% more per second than Arm.
Below: what Lambda MicroVMs actually are, what x86 changes, the full price list, the limits that trip people up, and how they compare with Lambda functions and Fargate.
What is AWS Lambda MicroVMs?
Lambda MicroVMs is a separate compute product inside AWS Lambda. It is not a new kind of Lambda function. Each MicroVM is its own Firecracker virtual machine with its own kernel. It launches from a pre-initialised snapshot, gets a dedicated HTTPS endpoint, and can be suspended and resumed with its memory and disk intact.
AWS first announced it on 22 June 2026 in the AWS News Blog. The developer guide lists the target workloads as interactive code environments, AI code-execution sandboxes, Jupyter-style data notebooks, security scanning, reinforcement-learning environments, multi-tenant CI/CD and game servers that run user scripts (Lambda MicroVMs developer guide).
How it works, in AWS's own order:
- You zip your code with a
Dockerfileand upload it to Amazon S3. - You call the API to create a MicroVM image. Lambda runs the Dockerfile, starts your app and snapshots memory and disk.
- You call
run-microvmwhenever a user, job or agent needs its own environment. It starts from the snapshot instead of booting cold. - Clients connect through the MicroVM's own HTTPS endpoint, using a short-lived auth token.
- When it goes idle, the MicroVM suspends and keeps its state. Traffic or an API call resumes it.
- When the session is over, you terminate it and charges stop.
If you're comparing AWS's other new developer tools, our explainer on the AWS Emulator for local testing covers a very different problem: running AWS APIs on your laptop, not isolating untrusted code in the cloud.
What changed on 11 November: x86 support
Until this week, every MicroVM ran on Arm64 (Graviton). That was a real blocker for teams whose sandboxes run x86-only binaries, older toolchains or prebuilt dependencies. In its 11 November announcement, AWS says existing x86 applications, tools and dependencies can now run "without recompiling or porting".
The details from the docs (MicroVM images):
- Arm64 stays the default. If you don't specify an architecture, Lambda builds for Arm.
- x86 needs base image version 3 or later. Run
list-managed-microvm-image-versionsand check thatsupportedCpuConfigurationsincludesX86_64. - Architecture is fixed per image version. To switch an existing image, call
update-microvm-imagewith a new CPU configuration. That produces a new version. - Everything has to match. Your container base image and any prebuilt binaries must be built for the architecture you pick. A mismatch fails the build, or, if a wrong binary gets in at run time, your app fails with an
Exec format error.
This is the example command from AWS's documentation for building an x86 image:
aws lambda-microvms create-microvm-image \
--name my-microvm-image \
--code-artifact uri=s3://your-bucket-name/app.zip \
--base-image-arn arn:aws:lambda:us-east-1:aws:microvm-image:al2023-1 \
--build-role-arn arn:aws:iam::123456789012:role/MicrovmBuildRole \
--cpu-configurations architecture=X86_64
Which Regions support Lambda MicroVMs (and x86)?
MicroVMs launched in five Regions, added five more on 19 August and four more on 22 October, for 14 in total. x86 is available everywhere except the four Regions added in October.
| Region | MicroVMs since | x86 available? |
|---|---|---|
| US East (N. Virginia) | June 2026 launch | Yes |
| US East (Ohio) | June 2026 launch | Yes |
| US West (Oregon) | June 2026 launch | Yes |
| Europe (Ireland) | June 2026 launch | Yes |
| Asia Pacific (Tokyo) | June 2026 launch | Yes |
| Asia Pacific (Mumbai) | 19 Aug 2026 | Yes |
| Asia Pacific (Singapore) | 19 Aug 2026 | Yes |
| Asia Pacific (Sydney) | 19 Aug 2026 | Yes |
| Europe (Frankfurt) | 19 Aug 2026 | Yes |
| Europe (Stockholm) | 19 Aug 2026 | Yes |
| Asia Pacific (Hong Kong) | 22 Oct 2026 | No (Arm only) |
| Asia Pacific (Malaysia) | 22 Oct 2026 | No (Arm only) |
| Asia Pacific (Thailand) | 22 Oct 2026 | No (Arm only) |
| Europe (Spain) | 22 Oct 2026 | No (Arm only) |
Sources: launch post, August expansion, October expansion, x86 announcement. AWS points to its Capabilities by Region page for the latest list.
How much does Lambda MicroVMs cost?
You pay for three things: compute per second (vCPU and memory), snapshot reads and writes, and snapshot storage. Data transfer is billed at standard AWS rates. These are the US East (N. Virginia) list prices on the Lambda pricing page as of 12 November 2026:
| Charge | Arm (Graviton) | x86 |
|---|---|---|
| vCPU, per second | $0.0000276944 | $0.0000326557 |
| Memory, per GB-second | $0.0000036667 | $0.0000043235 |
| Snapshot data written (on suspend) | about $0.0038 per GB | same |
| Snapshot data read (on launch or resume) | about $0.00155 per GB | same |
| Snapshot storage | $0.08 per GB-month | same |
Two pricing rules matter more than the raw rates:
- You pay the baseline while running, not the peak. You set a baseline size, and the MicroVM can burst to 4x it. You only pay for burst resources while they're actually in use.
- Suspended MicroVMs pay no compute. A suspended MicroVM only costs snapshot storage. MicroVM images have a one-week minimum storage period.
What a MicroVM costs per hour (our arithmetic)
We multiplied AWS's US East rates for the default 2 GB / 1 vCPU baseline, running non-stop with no bursting. These are our estimates, not AWS figures.
| Default size (2 GB, 1 vCPU) | Per hour | Per 24 hours | Per 730-hour month |
|---|---|---|---|
| Arm | ~$0.126 | ~$3.03 | ~$92 |
| x86 | ~$0.149 | ~$3.57 | ~$109 |
That's why suspend matters. AWS's own worked example (100 developers, each with a sandbox used 2.5 hours a day and suspended the rest of the time) comes to $1,241.22 a month, or $12.41 per developer. A second AWS example, 10,000 CI or security-scan jobs of 10 minutes each, comes to $1,124.03, about $0.11 per job (Lambda pricing page). Both examples are Arm.
If you're new to AWS billing, our AWS Free Tier guide explains how to set budgets and alerts before you experiment. The pricing page doesn't mention a free tier for MicroVMs.
Lambda MicroVMs limits you should know
From the developer guide and image docs:
| Limit | Value |
|---|---|
| Sizes (baseline → peak) | 0.5 GB/0.25 vCPU → 2 GB/1 vCPU, up to 8 GB/4 vCPU → 32 GB/16 vCPU |
| Disk | 8 GB on the three smallest sizes, 16 GB at 4 GB baseline, 32 GB at 8 GB baseline |
| Maximum lifetime | 28,800 seconds (8 hours), running plus suspended time |
| Idle timeout before suspend | Up to 8 hours |
| Run-time payload | Up to 16 KB per MicroVM |
| Environment variables | Up to 50, set at image build |
| Endpoint | One endpoint per MicroVM, no load balancing across MicroVMs |
| Account capacity | Regional quota on total memory across running and suspended MicroVMs (raise it in Service Quotas) |
Every request to an endpoint needs a JWE token. AWS says there's no unauthenticated option. Traffic goes to port 8080 by default. HTTP/2, WebSockets, gRPC and server-sent events are supported.
Lambda MicroVMs vs Lambda functions vs Fargate: which should you use?
This is the comparison readers keep asking about. Here's how the three line up on AWS's documented features:
| Question | Lambda functions | Lambda MicroVMs | AWS Fargate |
|---|---|---|---|
| Unit of work | One invocation (request/response) | One long-lived VM per user, job or agent | A container task or pod |
| Max run time | 15 minutes | 8 hours (running + suspended) | No fixed limit |
| Keeps state between requests | No guarantee | Yes, memory and disk, including through suspend | Yes, while the task runs |
| Pause and resume with state | No | Yes, built in | No |
| Own endpoint per instance | No | Yes, an HTTPS URL per MicroVM | No, you add a load balancer or service discovery |
| Billing granularity | Per millisecond | Per second | Per second |
| Arm vs x86 | Both | Both (since 11 Nov) | Both |
On cost, Fargate is far cheaper for a container that's always on. Using AWS's published per-second rates for US East, a Fargate task with 1 vCPU and 2 GB comes to about $0.039 an hour on Arm and $0.049 on x86 (Fargate pricing). That's roughly a third of the MicroVM rates above (our arithmetic). MicroVMs only win on price if your sandboxes spend most of their time suspended, or if you'd otherwise have to build snapshotting, per-tenant endpoints and VM isolation yourself.
AWS itself says to use both: functions for the event-driven core of your app, and MicroVMs for the steps that run untrusted code.
If you want to share EC2 instances you already run, rather than going serverless, AWS's newer Nitro Sandboxes put each pod, task or VM in its own hardware-isolated sandbox at no extra charge. AWS's EC2 docs name Lambda MicroVMs as the "manage none of it" option and Nitro Sandboxes as the "your instance" option.
What developers are saying
We found no community reaction to the x86 news yet; it's only a day old. Reactions to the June launch focused on cost and on how new the product really is:
- On r/aws, as reported by InfoQ, one commenter worked out that a "min setup of 1 vCPU + 2 GB RAM will run you $3.03/day. This is 9x+ Fargate spot pricing", and advised modelling idle-to-active ratios first. Our own Arm arithmetic gives the same $3.03 a day. Another commenter in the same thread argued that MicroVMs "don't really enable entirely new workloads that were impossible before", and instead change the cost, performance and security trade-off.
- Serverless consultant Yan Cui (theburningmonk) wrote that "Lambda MicroVMs isn't request/response at all", and that on pricing "this is closer to Fargate than Lambda". His list of drawbacks included "ARM64 only at launch", which the 11 November update now fixes in most Regions.
The questions people keep asking are about pricing compared with Fargate, regional limits and quotas, and whether MicroVMs replace third-party sandbox services. AWS hasn't published benchmark comparisons against those services, and we haven't tested MicroVMs ourselves.
Editor's take
The x86 update matters more than its one-paragraph announcement suggests. The use cases AWS is pitching are coding agents, CI runners and vulnerability scanners. Those are exactly the workloads that tend to pull in arbitrary x86 binaries, and the Arm-only rule was the most common objection at launch. With x86 about 18% more expensive per second, staying on Arm is still the cheaper choice if your code builds cleanly on Graviton.
The bigger decision is still the cost model. Left running non-stop, a MicroVM costs roughly three times as much as an equivalent Fargate task. It earns its price when sessions are short, bursty and mostly suspended. That's AWS's own coding-sandbox example, where the bill comes to about $12 per developer per month. Model your idle time before you commit.
FAQ
Does AWS Lambda MicroVMs support x86?
Yes, since 11 November 2026. Arm64 (Graviton) is still the default. To get x86, set cpuConfigurations to X86_64 when you create or update a MicroVM image. You'll need base image version 3 or later.
What is the difference between Lambda MicroVMs and Lambda functions?
Functions handle short request/response invocations, up to 15 minutes each, with no guaranteed state. MicroVMs are long-lived VMs, one per user or job, that last up to 8 hours. They keep memory and disk across suspend and resume and get their own HTTPS endpoint. Both run on Firecracker.
How much does Lambda MicroVMs cost per hour?
In US East, the default 2 GB / 1 vCPU size costs about $0.126 an hour on Arm and about $0.149 on x86 while running (our calculation from AWS's list prices). When suspended, you pay only snapshot storage at $0.08 per GB-month, plus about $0.0038 per GB to suspend and $0.00155 per GB to resume.
What are the Lambda MicroVMs limits?
A maximum lifetime of 8 hours (28,800 seconds), up to 32 GB of memory and 16 vCPUs at peak, and up to 32 GB of disk on the largest size. There's also a regional account quota on total memory, plus API rate limits.
Which regions is Lambda MicroVMs available in?
14 Regions: N. Virginia, Ohio, Oregon, Ireland, Tokyo, Mumbai, Singapore, Sydney, Frankfurt, Stockholm, Hong Kong, Malaysia, Thailand and Spain. x86 works in all of them except the last four.
Is Lambda MicroVMs cheaper than Fargate?
Not for always-on workloads. On AWS's list prices, a running MicroVM costs roughly three times as much as a Fargate task of the same size. It can work out cheaper overall when sessions spend most of their time suspended, because suspended MicroVMs pay no compute.
Is there a free tier for Lambda MicroVMs?
The Lambda pricing page doesn't list a MicroVMs free tier. Plan on paying from your first MicroVM.
Can Lambda MicroVMs run Docker images?
Your image is built from a Dockerfile. You can start from AWS's public.ecr.aws/lambda/microvms:al2023-minimal base or bring your own Linux base image, as long as it's snapshot-compatible and built for the right architecture.
Sources
- AWS What's New: Lambda MicroVMs now supports x86 (11 Nov 2026)
- AWS News Blog: AWS Lambda introduces MicroVMs (22 Jun 2026)
- AWS What's New: 5 additional Regions (19 Aug 2026)
- AWS What's New: 4 additional Regions (22 Oct 2026)
- Lambda MicroVMs developer guide
- Lambda MicroVMs: MicroVM images
- Lambda MicroVMs: Running and using MicroVMs
- AWS Lambda pricing
- AWS Fargate pricing
- InfoQ: AWS Launches Lambda MicroVMs
- Yan Cui: What you need to know about Lambda MicroVMs
- AWS EC2 User Guide: Nitro Sandboxes
Featured image: Server racks inside an Amazon data center (Amazon photo; not specific to Lambda MicroVMs). Source