AWS Emulator: What It Is, How to Use It, and How It Compares With LocalStack

AWS Emulator is a free local emulator of AWS APIs built by AI agents. Setup steps, limits, fidelity scores and how it compares with LocalStack.

Sanchana Charles12 November 202613 min read0 viewsAWS
AWS Emulator: What It Is, How to Use It, and How It Compares With LocalStack

AWS Emulator is a free, official tool from Amazon Web Services that runs a fake copy of the AWS APIs on your own computer, so you can test code without an AWS account or a bill. AWS released it on 11 November 2026 and published the source code on GitHub under a CC0 licence. The unusual part: AWS says autonomous AI agents wrote all of its code, and that the team has not written or reviewed any of it by hand.

If you use LocalStack, Moto or a home-made mock for integration tests, this is the first-party alternative many developers have been asking for. Below we explain what it does, what it costs, how to set it up, where it falls short, and how it compares with LocalStack.

What is AWS Emulator?

In AWS's own words, AWS Emulator is "a local emulator of the AWS APIs. You use it to test your software without calling AWS, on your own machine, on a development server, or in continuous integration (CI)." Your requests go to the emulator instead of AWS, so you create and change emulated resources, not real ones (AWS Emulator User Guide).

The key facts at a glance:

Question Answer (from AWS)
Released 11 November 2026
Price No additional service fee. You pay only for real AWS resources when you deploy to AWS
AWS account needed? No
Coverage APIs of AWS services that have a model in the public AWS API models repo. Amazon cites 438 API models; Swami Sivasubramanian's launch post says "more than 200" services
Platforms Linux (RPM or Debian package, x86_64 and aarch64); macOS and Windows through Docker; embedded mode for Rust tests
Default endpoint https://127.0.0.1:9297 (self-signed certificate)
Interface Command line only, no graphical interface
Licence CC0 1.0 (code in vendor/ is Apache 2.0)
Telemetry On by default (anonymous usage and error data); can be turned off
Accepts pull requests? No. Bugs and fidelity gaps go to GitHub Issues

Sources: AWS Emulator README, AWS docs, About Amazon, All Things Distributed.

Is AWS Emulator free?

Yes. The README says AWS Emulator "has no additional service fee. You pay only for AWS resources when you deploy on AWS." You don't need an AWS account to run it at all, which also means there is no risk of a surprise bill from test resources. If surprise bills are what worry you on real AWS, our AWS Free Tier explainer covers how to avoid them.

The one "cost" worth knowing about is telemetry. AWS says the emulator sends anonymous usage and error data by default, never your requests, responses, code, credentials or personal data. You can switch it off with the --telemetry off flag, the EMULATOR_TELEMETRY=off environment variable, or a setting in ~/.aws/emulator/config.toml.

How was AWS Emulator built by AI agents?

This is the part that drew the most attention on Hacker News. In a post on About Amazon, Matthew Goldberg, a senior principal engineer at AWS, writes that "thousands of autonomous AI agents wrote every line of code in AWS Emulator" (About Amazon).

According to Goldberg, the project started when he gave Kiro, AWS's agentic coding tool, a simple prompt and got a first version of an Amazon SQS emulator in about 15 minutes. The system then grew into three teams of agents working through a shared repository:

  1. Test writers generate "fidelity tests" from the public AWS API models and check them against real AWS. There are now tens of thousands of these tests.
  2. Issue finders replay those tests against the emulator and log every mismatch as an issue.
  3. Fixers each take a single issue, write a fix, and push it through a "merge gate" that checks the build, code review, security and fidelity.

Goldberg says hundreds of agents run at the same time and fix thousands of issues a day, and that without the merge gate the team wouldn't trust what the agents produce. He also notes the agents once wrote their own Python interpreter to emulate Lambda, which is why their guidance now tells them to reuse existing libraries.

In a guest post on Werner Vogels' All Things Distributed blog, Swami Sivasubramanian frames the emulator as a lesson about the engineer's job: "Software quality in the AI era depends on the guardrails that engineers design around agents." He adds: "We expect agents to build and check most software, with engineers deciding what gets built and when the work is correct" (All Things Distributed).

This fits a pattern we've been tracking: Amazon recently rewrote its internal engineering guidance for a world where agents write most code (see what changes for Amazon developers), and it is pushing developers from Amazon Q Developer towards Kiro (our explainer).

How do I install and use AWS Emulator?

AWS documents three ways to run it. Pick the one that matches your setup:

Your setup Recommended route
You use an AI coding agent Install the aws-emulator skill (needs AWS CLI v2.35.0 or later) and ask the agent to set it up
Linux machine or Linux CI runner Install the RPM or Debian package and run aws-emulator
macOS or Windows Build and run the container from AWS's short Dockerfile
Rust tests using the AWS SDK for Rust Embedded mode: add it as a dev-dependency, one isolated emulator per test

For the agent route, the README gives this command:

aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1

Once the emulator is running, you point the AWS CLI or SDK at it with environment variables. AWS's guide lists these for macOS and Linux (change 9297 if you use another port):

export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1

AWS also tells you to unset any real credentials in that shell, because environment variables beat the credentials file and the emulator will reject requests signed with real keys:

unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

To confirm you're talking to the emulator and not your real account, run aws sts get-caller-identity. On the emulator, the account shows as 000000000000 and the ARN as arn:aws:iam::000000000000:user/emulator. If you see your own account ID, your requests are going to AWS (AWS docs).

Setup checklist (the gotchas AWS documents)

  • Keep 127.0.0.1, not localhost. With localhost, the JavaScript, Java and Go SDKs put the S3 bucket name in the host name by default, and the emulator doesn't accept that.
  • Trust the certificate. The AWS CLI, Boto3 and Go SDK read AWS_CA_BUNDLE. Node.js needs NODE_EXTRA_CA_CERTS, Rust and .NET need SSL_CERT_FILE, and Java needs the truststore.p12 file the emulator writes.
  • New keys every run. The emulator generates fresh credentials and a fresh certificate each time it starts, stored under ~/.aws/emulator/<port>/.
  • S3 Control won't work. The SDK always puts your account ID in the host name for S3 Control requests, so they can't reach the emulator.
  • Health check. https://127.0.0.1:9297/__admin/health returns HTTP 200 with ok when it's ready, handy for CI scripts.
  • Only set AWS_DISABLE_HOST_PREFIX_INJECTION for emulator shells. On real AWS, operations that use host prefixes fail with it set.

What are AWS Emulator's limitations?

AWS is unusually upfront here. Its documentation lists these limits:

  • No real security testing. The emulator "doesn't evaluate AWS Identity and Access Management (IAM) policies and resource-based policies the way AWS does." Don't use it to test permissions.
  • One Region and one account. It accepts any Region and account ID but doesn't keep resources separate by them. To test several Regions, run one emulator per Region on separate ports.
  • Fidelity varies. AWS says it currently matches AWS "most closely for control plane APIs" (create, describe, update, delete, list). Data-plane behaviour and support for CloudFormation, Terraform and the CDK "varies by service."
  • Checked in one Region. Behaviour is verified against US West (Oregon), or US East (N. Virginia) for global services, so Region differences aren't reflected.
  • Memory only. Everything lives in RAM and is deleted when the emulator stops.
  • Not for long-running or load testing. AWS hasn't tested it for that. Start it per test run, or use --idle-timeout.
  • Unimplemented operations fail loudly. They return HTTP 501 with NotImplemented.

AWS publishes per-service "fidelity scores" (tests passed out of total, for example 40 of 50) with each release on GitHub, and keeps a list of things that don't work yet in the repo's issues/ folder (Fidelity in AWS Emulator). When we checked the releases page on 12 November, the most recent releases shown did not display scores on the page itself, so check the release assets or run AWS's open test suite against the services you use.

AWS Emulator vs LocalStack: which should you use?

LocalStack has been the default local AWS emulator for years, but its terms changed in 2026. LocalStack's own blog says that beginning in March 2026 it would ship "a single, unified version" and that "the new unified distribution will require authentication via an auth token for use." Its free tier "is intended for non-commercial use," and older Community tags remain available but get no further updates or security patches (LocalStack blog).

Here is how the two compare on what each publisher states. We have not benchmarked either tool.

AWS Emulator LocalStack for AWS
Publisher AWS (first party) LocalStack (third party)
Price No fee Free tier for non-commercial use; paid plans for commercial use
Account or token None needed Auth token required since the March 2026 change
Licence CC0 (vendor code Apache 2.0) Not covered in this article; check LocalStack's terms
How it's built Agents, measured against real AWS with published fidelity tests Human-maintained commercial product
GUI None Not covered here
Track record Days old Years of production use in CI
IAM policy evaluation Not done "the way AWS does" Check LocalStack's docs for your plan

Our quick decision guide:

  • Hobby or open-source project, small set of common services: try AWS Emulator first. It's free, needs no sign-up, and comes from AWS.
  • Commercial team already paying for LocalStack and relying on CloudFormation/Terraform/CDK deploys: keep LocalStack for now and trial AWS Emulator in a branch. AWS itself says IaC support "varies by service."
  • You need to test IAM permissions: neither replaces a real sandbox AWS account; AWS Emulator explicitly isn't for that.
  • Rust shop: AWS Emulator's embedded mode is a unique advantage (isolated in-process emulator per test), though AWS warns building from source needs 100 GB of free disk.

What are developers saying about AWS Emulator?

The main Hacker News discussion, which links to the GitHub repo, had 731 points and 222 comments when we read it (Hacker News). Reactions were split:

  • Welcome: "Good! Been waiting for a first party thing like this." (gigatexal)
  • On LocalStack: "Localstack is no longer free and if you're using it commercially you need to pay for a license." (sequence7)
  • Skeptical: "Feels more like a science experiment than a product from that announcement." (CharlieDigital)
  • On the AI-written code: "Looks like this was ~100% generated with Claude within the past month." (paavohtl). AWS's posts say the agents used Kiro; they don't say which models powered every agent, and we couldn't verify that claim.
  • Another commenter replied: "It's a real product that we plan to maintain." (ke4qqq)

The questions we saw developers asking most were whether an agent-written codebase can be trusted, whether it will be maintained long term, and how it handles CloudFormation and Terraform deployments. AWS's documented answers are the published fidelity tests, the merge gate, and that IaC support currently varies by service.

Editor's take

The real story isn't another LocalStack alternative. It's that AWS shipped a developer tool and openly said no human wrote or reviewed the code, then published the tests it uses to judge it. That's a bold bet, and the documentation is refreshingly honest about what doesn't work yet.

For most developers, the sensible move is low-risk: point one CI job at AWS Emulator, run your integration tests, and compare results with what you use today. Just make sure your test shell can't fall back to real credentials. If you're heading to AWS re:Invent 2026, expect agent-built tooling like this to be a major theme. And if your interest in AWS is more about where it's expanding, see our report on the new AWS Chile Region and its $4 billion investment.

FAQ

What is AWS Emulator?

A free, local emulator of the AWS APIs from Amazon Web Services. It runs on your machine, a dev server or CI, so you can test code that calls AWS without an AWS account.

Is AWS Emulator free?

Yes. AWS says it has no additional service fee. You only pay for real AWS resources when you deploy to AWS.

Is AWS Emulator open source?

The source code is on GitHub at aws/aws-emulator under the CC0 1.0 licence, with vendored framework code under Apache 2.0. The repository does not accept pull requests; you report problems through GitHub Issues.

Does AWS Emulator work on Mac and Windows?

Yes, through Docker. AWS provides a short Dockerfile. Native packages are for Linux (x86_64 and aarch64).

Is AWS Emulator a replacement for LocalStack?

It can be for many test suites, especially those that use common service APIs. But AWS says fidelity varies by service and IaC support (CloudFormation, Terraform, CDK) varies, so test your own project first. AWS documents a way to check whether your project is expected to work.

Was AWS Emulator really written by AI?

AWS says so. Matthew Goldberg writes that thousands of autonomous AI agents wrote every line, and that the team hasn't written or reviewed the code. Quality is enforced by fidelity tests checked against real AWS and a merge gate.

Can I use AWS Emulator to test IAM permissions?

No. AWS says it doesn't evaluate IAM and resource-based policies the way AWS does and should not be used to test security.

What port does AWS Emulator use?

By default it serves HTTPS on 127.0.0.1:9297 with a self-signed certificate.

Sources

Featured image: an AWS data center aisle with server racks (an AWS facility, not AWS Emulator, which is software). Photo: Amazon. Source

Share:

Comments

Leave a comment