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.

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:
- 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.
- Issue finders replay those tests against the emulator and log every mismatch as an issue.
- 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, notlocalhost. Withlocalhost, 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 needsNODE_EXTRA_CA_CERTS, Rust and .NET needSSL_CERT_FILE, and Java needs thetruststore.p12file 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/healthreturns HTTP 200 withokwhen it's ready, handy for CI scripts. - Only set
AWS_DISABLE_HOST_PREFIX_INJECTIONfor 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
- About Amazon: How we built the agents that built AWS Emulator
- AWS Emulator on GitHub (README)
- AWS Emulator releases
- AWS Emulator User Guide: What is AWS Emulator?
- AWS Emulator User Guide: Pointing your AWS SDK at AWS Emulator
- AWS Emulator User Guide: Fidelity
- All Things Distributed: AWS Emulator and the engineer's job when agents write the code
- LocalStack blog: The Road Ahead for LocalStack
- Hacker News discussion: AWS emulator
Featured image: an AWS data center aisle with server racks (an AWS facility, not AWS Emulator, which is software). Photo: Amazon. Source