AWS Emulator is free, CC0 and written by AI agents. Install steps, the real limits (no IAM checks, one account) and how it stacks up against LocalStack.
AWS Emulator is a free, CC0-licensed local copy of the AWS APIs that AWS released on November 11, 2026, and it deserves a trial in your CI pipeline now, provided you do not need it to enforce IAM. It runs as one HTTPS endpoint on 127.0.0.1:9297, accepts your existing CLI and SDK calls, needs no AWS account, and answers HTTP 501 for any operation it has not built yet.[1][2] AWS also says agents wrote all of the code and the team reviewed none of it.[3] We built AWS's Docker image on one Apple silicon Mac, ran version 1.0.385, and executed S3, STS and DynamoDB calls; those results are single-run observations, not guarantees. Below: setup, limits, a LocalStack comparison, and what the agent-built claim does and does not tell you.
What AWS Emulator is, and what it is not
It is a local program with no graphical interface. You start it, set environment variables, and your CLI or SDK talks to it instead of AWS.[4] It is written in Rust.[2] Resources live in memory and disappear when the process stops, and each copy you start gets its own port, keys and state, so parallel test suites and CI jobs never see each other's resources.[1]
Service coverage comes from AWS's published API models, the same ones behind the SDKs.[1] The agents began from an empty web server that could handle requests for the 438 AWS API models but did nothing with them.[3] A launch essay from AWS's Swami Sivasubramanian puts the finished scope at more than 400 models covering more than 200 services.[10] AWS says the emulator matches real AWS most closely on control plane calls (create, describe, update, delete, list), while data plane behavior and support for CloudFormation, Terraform and the CDK vary by service.[5]
The repository is CC0 1.0, except the vendor/ directory, which is Apache 2.0.[8] There is no service fee.[1] Telemetry is on by default; turn it off with aws-emulator --telemetry off or EMULATOR_TELEMETRY=off.[8]
Install on Linux, macOS and Windows
On Linux, AWS ships RPM and Debian packages for x86_64 and aarch64.[4] AWS demonstrated this on Amazon Linux 2023:[2]
PKG=https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest
sudo dnf install -y $PKG/aws-emulator-x86_64.rpm
aws-emulator -v
aws-emulatorThe second aws-emulator starts the server on 127.0.0.1:9297. At startup it generates credentials, a config file and a certificate under ~/.aws/emulator/9297/.[2]
macOS and Windows have no native package. AWS does not publish a ready-made image either; you build one from a short Dockerfile that installs the Linux package.[7] On Apple silicon, swap x86_64 for aarch64 in the ADD line.
FROM public.ecr.aws/amazonlinux/amazonlinux:2023-minimal
ADD https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator-x86_64.rpm /tmp/aws-emulator.rpm
RUN rpm -i /tmp/aws-emulator.rpm && rm /tmp/aws-emulator.rpm \
&& mkdir -p /home/emulator && chown 1000 /home/emulator
USER 1000
ENV HOME=/home/emulator
EXPOSE 9297
ENTRYPOINT ["aws-emulator", "-b", "0.0.0.0"]docker build -t aws-emulator .
mkdir -p ~/.aws/emulator
PORT=9297
docker run --rm --memory=2g --memory-swap=2g -p 127.0.0.1:$PORT:$PORT \
-e HOME="$HOME" -v "$HOME/.aws/emulator:$HOME/.aws/emulator" \
aws-emulator -p $PORTTwo details in AWS's Docker page matter. Publish the port as 127.0.0.1:9297:9297, not 9297:9297, because the short form exposes the emulator to your whole network. And the 2 GiB memory cap is real: go over it and the container exits with code 137 and you lose every emulated resource.[7] To move this into a Compose file, use our docker run to Compose converter and check the flag-by-flag guide for flags it drops.
Point the AWS CLI, SDKs and Terraform at it
Below are the exports from AWS's documented setup for macOS and Linux, followed by the unset line from the next step of the same page. Replace 9297 if you picked another port.[6]
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
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILEThe unset line is not optional: environment variables beat the credentials file, so leftover real keys sign requests and the emulator rejects them.[6] The emulator mints a new key pair on every start, with access key IDs beginning EMULATOR. It rejects unsigned requests and requests signed with other keys, although keys you create inside the emulator through IAM or STS also work.[2][16] To confirm you reached it, run aws sts get-caller-identity: the emulator uses the single account 000000000000, and the ARN reads arn:aws:iam::000000000000:user/emulator. Your own account ID means your calls reach AWS.[6] If you keep these in a .env file for CI, our .env validator and converter checks syntax before a job fails on a typo.
SDK gotchas from the same page:[6]
- Keep
127.0.0.1in the endpoint URL. Withlocalhost, the JavaScript, Java and Go SDKs put the S3 bucket name in the hostname, and the emulator does not accept that form. - S3 Control requests cannot reach the emulator at all, because the SDK always puts the account ID in the hostname.
- Certificate trust differs by SDK. AWS CLI v2, Boto3 and Go v2 read
AWS_CA_BUNDLE. Node.js needsNODE_EXTRA_CA_CERTS, Rust and .NET needSSL_CERT_FILE, and Java needs the emulator'struststore.p12, which replaces the JVM's default trust store. - Setting
AWS_CONFIG_FILEreplaces your own config for that shell.
Terraform is the unresolved piece. The AWS provider reads AWS_ENDPOINT_URL for all services and AWS_ENDPOINT_URL_<SERVICE> for individual ones, but HashiCorp calls custom-endpoint support best effort and runs its integration tests only against default AWS endpoints.[11] AWS, for its part, says infrastructure-as-code support varies by service and publishes no Terraform walkthrough on the pages we read.[5] We did not run Terraform against the emulator. Export the variables above, run plan and apply on one small stack, and report failures as coverage gaps.
What we ran: real output from version 1.0.385
We built the Dockerfile above with the aarch64 package on an Apple silicon Mac with Docker Desktop, started it with telemetry off, and used AWS CLI 1.46.3 (v1, installed with pip). The README names CLI 2.35.0 or later only for the agent-skill route, not for the manual path.[8] Trimmed output from one run on one machine, on November 16, 2026:
$ aws-emulator -v
Version: 1.0.385
Release date: 2026.11.14
Commit: 813af480bf7f16d5418b64e4f5644a74a7da11c5
$ aws sts get-caller-identity
{
"UserId": "AIDAH5I7GEMO7ADXNFAZU",
"Account": "000000000000",
"Arn": "arn:aws:iam::000000000000:user/emulator"
}
$ aws s3 mb s3://local-getting-started
make_bucket: local-getting-started
$ aws s3 ls s3://local-getting-started/
2026-11-16 15:46:44 24 hello.txt
$ aws dynamodb create-table --table-name ab ...
An error occurred (ValidationException) when calling the CreateTable operation: 1 validation error detected: Value 'ab' at 'tableName' failed to satisfy constraint: Member must have length greater than or equal to 3
$ aws dynamodb create-table --table-name demo ... # valid call
$ aws dynamodb put-item --table-name demo ... # issued immediately
An error occurred (ResourceNotFoundException) when calling the PutItem operation: Requested resource not foundThree things stand out. The two-character table name drew the same error text AWS prints in its documentation example.[4] A call signed with a made-up access key was rejected too: STS answered InvalidClientTokenId and DynamoDB answered UnrecognizedClientException. AWS's command reference lists AccessDenied for keys the emulator does not accept and InvalidClientTokenId for unsigned requests, so the error code you see can differ from ours.[16] And the table sat in CREATING for a moment: in our run the first put-item failed, and within a few seconds the table was ACTIVE and put-item and get-item worked. That suggests the emulator models asynchronous table creation, which is good for realism and bad for tests that assume instant tables. We saw it once and AWS's pages we read do not describe it, so treat it as an observation, not a guarantee. Poll describe-table before writing.
Documented limits and coverage gaps
AWS lists the limits itself:[4]
- No policy evaluation. IAM and resource-based policies are not evaluated the way AWS does, so a request AWS would deny can succeed here.
- One account, one Region. The emulator accepts any Region and account ID but does not keep resources separate by either. To test two Regions, run two emulators on two ports.
- Verified in one Region. AWS checks behavior in
us-west-2only, except global services, which it checks inus-east-1. - Memory only. Resources are deleted on stop, and capacity depends on your machine.
- Not load tested. AWS has not tested long-running use or load. Start it per test run, or set
--idle-timeoutso it stops itself.
Embedded mode is Rust-only and compiles the emulator into your test binary, so your project's first cargo test builds the emulator's service crates. The README says to budget that first build and target/ on the same order as building from source, which it says needs at least 100 GB of free disk, and it recommends caching target/ in CI.[8]
For per-service coverage, AWS publishes a score for every release as "k of n" passing fidelity tests, for example 40 of 50, and the v1.0.385 release carries a scores.json.gz asset.[5][9] We did not unpack it, so this post gives no per-service pass rates; read the scores for the services you call. Scores can drop when tests are added, because a new test can expose an old difference.[5] Known gaps live in the repository's issues/things-that-do-not-work folder. The 1.0.385 notes list dozens of per-issue fixes, several titled "stub" (ssm-getopssummary-stub, kafka-updaterebalancing-stub), which suggests some operations were placeholders until then.[8][9]
AWS Emulator vs LocalStack, Moto and SAM CLI
These tools overlap less than the "local AWS" label suggests. The table sticks to each project's own pages.
| Item | AWS Emulator | LocalStack | Moto | SAM CLI (local) |
|---|---|---|---|---|
| What it is | Standalone Rust emulator serving an AWS API endpoint[4] | Docker-based emulator, container on port 4566[13] | Python library that mocks AWS in your tests[14] | Runs a Lambda function locally with an event[15] |
| Install | RPM or Debian package, or Docker image you build[7] | lstk start, Docker Compose or docker run[13] | pip install 'moto[ec2,s3,all]'[14] | Part of the SAM CLI; sam local invoke[15] |
| License and price | CC0 (the vendor/ directory is Apache 2.0), no service fee[1][8] | Hobby plan is free but its terms prohibit commercial use; Base, Ultimate and Enterprise cover commercial use[12] | Apache-2.0[14] | Not covered by this comparison |
| Account or token | No AWS account; telemetry on by default[1][8] | Auth token required for LocalStack for AWS, including in CI[12][13] | Not stated in its README | Not stated on the page we read |
| How you connect | Endpoint URL via env vars; Rust embedded mode[6] | Endpoint URL to the container[11] | @mock_aws decorator, in process[14] | Event file or stdin to the function[15] |
| Coverage claim | APIs with a published AWS model; fidelity scores per release[5] | Plan-dependent; Hobby is described as comparable to the old Community edition[12] | Listed in its implementation coverage file[14] | Lambda functions, not whole-AWS emulation |
The LocalStack row carries the news. LocalStack's pricing page says LocalStack for AWS is now an account-based product on a single image, and that the legacy Community emulator will no longer receive product updates, including CVE patches.[12] The Hobby plan is free but its terms prohibit commercial use.[12] A commercial team that relied on the old Community image now chooses between a paid LocalStack plan and AWS Emulator, which has no service fee. LocalStack says CI use is available on every plan, subject to its fair-use policy and the plan's terms, and that commercial CI needs a paid plan.[12] Its paid plans add entitlements such as Cloud Pods, ephemeral environments and an AWS replicator.[12]
Moto mocks inside your Python process, and sam local invoke runs one Lambda function against an event file; AWS's docs warn that it runs function code in your local environment.[15] In our view neither replaces a network-level emulator for a multi-service integration test.
How far to trust code that no human reviewed
AWS's launch post says it plainly: "Our team hasn't written or reviewed any of the code."[3] What AWS offers instead of review is structure. Three teams of agents do bounded jobs: one writes fidelity tests from the public API models and verifies each against real AWS before submitting, one replays those tests against the emulator and files issues for the failures, grouping failures that may share a root cause, and one fixes a single issue per agent.[3] Every fix passes a merge gate covering the build, a standards review, a security review and a check that fidelity did not regress.[3] A separate security agent reviews changes adversarially during the fix and again in the release pipeline.[2] AWS cites tens of thousands of fidelity tests and thousands of issues fixed per day.[3]
The agent counts are worded two ways in the same post. Its summary says "thousands of autonomous agents" wrote the code, while the body says thousands of issues are fixed every day as hundreds of agents work concurrently, and the post does not reconcile the two.[3] AWS names Kiro for the original weekend prototype, which produced a passable SQS in about 15 minutes.[3] The pages we read do not say which models run the production agent teams; AWS says the agents are built and maintained using Amazon Bedrock AgentCore Runtime Instances, AWS CodePipeline and AWS CodeCommit.[2]
What that buys you: the ground truth is AWS itself, not the agents. A fidelity test only counts once it passes against real AWS, and the emulator must reproduce the status code, the body, and the exact error code and message.[2] For the behavior those tests cover, that is a stronger check than a reviewer reading a diff, in our view. The boundary, as we read AWS's fidelity page: behavior no fidelity test covers is not verified against AWS.[5] The repository takes issues, not pull requests.[8]
Our recommendation: run it like any third-party binary you pull into CI. Treat the build you test against as pinned: tag the image you build, record the output of aws-emulator -v in your job log (the install URL we used points at LTS/latest, and AWS says the emulator updates many times a day[4]), bind it to loopback, cap its memory, and run the published fidelity_tests_runner against that build for the services you use.[5] If agents in your pipeline call the emulator, isolate them as well; our sandbox comparison for coding agents covers the options. Keep real AWS credentials out of test jobs, and never use the emulator to judge whether your policies are safe. AWS says the same.[2]
Who should adopt it now, and who should wait
Adopt now if your integration tests are mostly create, put, get and delete calls against S3, DynamoDB, SQS and similar services, and the published fidelity scores for those services cover the calls you make. Adopt now if you want a no-account, no-token CI dependency, or a commercial team has been choosing between a paid LocalStack plan and Moto alone. Coding agents that need a safe place to create and tear down resources are AWS's stated use case.[1]
Wait if you need IAM behavior to match AWS, multi-account or cross-Region tests, state that survives a restart, or a shared long-lived dev environment. Wait if your stack leans on Terraform, CloudFormation or the CDK until one real stack has run through it, since AWS says that support varies by service. The public repository's first commit is dated October 21, 2026, and by November 16 it listed 30 releases, which argues for trying it now and against making it your only test layer.[8]
Sources
- AWS Emulator is now available for building and testing AWS applications locally, AWS What's New, November 11, 2026 (accessed November 16, 2026)
- Test your applications against AWS locally with AWS Emulator, AWS News Blog (accessed November 16, 2026)
- How we built the agents that built AWS Emulator, Amazon News (accessed November 16, 2026)
- What is AWS Emulator?, AWS docs (accessed November 16, 2026)
- Fidelity in AWS Emulator, AWS docs (accessed November 16, 2026)
- Pointing your AWS SDK at AWS Emulator, AWS docs (accessed November 16, 2026)
- Getting started with Docker, AWS docs (accessed November 16, 2026)
- aws/aws-emulator README, GitHub (accessed November 16, 2026)
- aws-emulator release v1.0.385, GitHub (accessed November 16, 2026)
- AWS Emulator and the engineer's job when agents write the code, All Things Distributed, November 11, 2026 (accessed November 16, 2026)
- Custom Service Endpoint Configuration, HashiCorp (accessed November 16, 2026)
- Pricing and plan FAQ, LocalStack (accessed November 16, 2026)
- Installation, LocalStack documentation (accessed November 16, 2026)
- getmoto/moto README, GitHub (accessed November 16, 2026)
- Locally invoke Lambda Event Functions with AWS SAM, AWS docs (accessed November 16, 2026)
- AWS Emulator command reference, AWS docs (accessed November 16, 2026)
Written by
WOWHOW
The WOWHOW team brings 14+ years of production engineering experience. Every tool and product in the catalog is built, tested, and curated in-house.
Monday memo · free
One insight, every Monday. 7am IST.
1 field report, 3 links, 1 tool we actually use. No fluff, no spam.
Beyond the writing
Need production-ready templates?
Free browser tools with no signup, plus premium dev templates and starter kits.
Comments · 0
Beta: comments are stored locally on your device and not visible to other readers.
No comments yet. Be the first to share your thoughts.