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.

Sanchana Charles12 November 202612 min read0 viewsAWS
AWS Lambda MicroVMs Now Runs on x86: Pricing, Limits, Regions and How It Compares With 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:

  1. You zip your code with a Dockerfile and upload it to Amazon S3.
  2. You call the API to create a MicroVM image. Lambda runs the Dockerfile, starts your app and snapshots memory and disk.
  3. You call run-microvm whenever a user, job or agent needs its own environment. It starts from the snapshot instead of booting cold.
  4. Clients connect through the MicroVM's own HTTPS endpoint, using a short-lived auth token.
  5. When it goes idle, the MicroVM suspends and keeps its state. Traffic or an API call resumes it.
  6. 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-versions and check that supportedCpuConfigurations includes X86_64.
  • Architecture is fixed per image version. To switch an existing image, call update-microvm-image with 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

Featured image: Server racks inside an Amazon data center (Amazon photo; not specific to Lambda MicroVMs). Source

Share:

Comments

Leave a comment