Developer tools#Open-source alternatives#Cloud
AWS Emulator: AWS's own local emulator for its APIs
AWS open-sourced a local AWS API emulator on Nov 11: Rust, one HTTPS endpoint on 127.0.0.1:9297, 436 service crates, CC0-1.0.
Project facts
GitHub Ecosystem- License
- CC0-1.0
- Language
- Rust
- Stars
- 8,855
- Data checked
- 2026-11-17
Snapshot figures reflect the check date and may change over time.
Testing code that talks to AWS has usually meant one of two things: run integration tests against a real account, or install someone else’s emulator. On November 11, 2026, AWS offered a third. AWS Emulator is a local program that serves the AWS APIs on your machine, with no AWS account involved. It is written in Rust and listens for HTTPS on 127.0.0.1:9297; you point the AWS CLI or any SDK at it by setting a few environment variables and run your code unchanged. As of November 17, 2026, aws/aws-emulator has 8,855 stars.

Key points
- Ownership and license: the repo sits in the official
awsorganization (owner type Organization), was created on 2026-09-11 and was announced publicly on 2026-11-11. The code is CC0-1.0;vendor/is Apache-2.0. - Coverage: 436 crates named
service-*underservices/, one per AWS service, with the wire protocol driven by a Smithy model in each directory. An operation that isn’t implemented returns HTTP 501 withNotImplementedrather than pretending to succeed. - Fidelity data: every release ships a
scores.json.gz. I downloaded the one attached to v1.0.481 and counted 30,570 passing units out of 43,548, about 70.2%; wire-level units pass 50.1%, behavioral units 76.8%.
| Item | Value (checked 2026-11-17) |
|---|---|
| Stars / forks | 8,855 / 391 |
| Endpoint | HTTPS on 127.0.0.1:9297, self-signed cert |
| Idle memory | about 160 MiB (AWS docs) |
| Releases | 32; latest v1.0.481 on November 16, 22:13 UTC |
Core features
- One process, every service: a router crate mounts all services on a single HTTPS endpoint. If the port is taken,
-ppicks another and-p 0lets the OS choose; readendpoint_urlfrom the startup log instead of hard-coding 9297. - Errors match too: valid calls return what AWS returns, invalid ones the same error code and message. AWS’s own example is a DynamoDB table name shorter than three characters, rejected with the same
ValidationExceptionyou’d see in the cloud. - Embedded mode: a Rust test adds
aws-emulator-embeddedas a dev-dependency and compiles the emulator into the test binary, one isolated instance per test, with no endpoint or certificate to manage. - In-memory state, isolated by port: resources live in memory and the process keeps its files under
~/.aws/emulator/<port>/. Ctrl+C clears everything; several emulators can run side by side. - A skill for coding agents:
aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1installs a skill that lets an agent install, start and connect the emulator, then check whether your project works on it.
Emulation limits
The README and the user guide are unusually direct about what the emulator doesn’t do, which is the part worth reading before wiring it into CI.
- No IAM evaluation: it doesn’t evaluate identity or resource policies the way AWS does, and the docs say not to use it for security testing.
- One Region, one account: any Region and account ID is accepted, but resources aren’t partitioned by either. Behavior is checked against
us-west-2(andus-east-1for global services); need two Regions, run two emulators. - Control plane beats data plane: control-plane APIs match most closely. Data-plane behavior, and support for CloudFormation, Terraform and the CDK, varies by service.
- Built for test runs: AWS says not to use it for production and hasn’t tested long-running use or load. Start it for a run, stop it after, or set
--idle-timeout. - Platform limits: Linux gets RPM and Debian packages; macOS and Windows run it in Docker; building from source works on Linux x86_64 and aarch64 only, and
target/needs about 100 GB.
Who writes the code
This is the part that drew the argument, so it’s worth separating what can be checked from what can’t. The README states: “We don’t accept pull requests: AI agents keep the emulator up to date with AWS, with regular updates.” The user guide adds “updates many times a day”, and the cadence matches: eleven releases between November 14 and November 16, nine of them on November 14 alone.
The commit history supports the claim without proving every line. Of the last 100 commits, 62 are authored by IssueFixerAgent, 37 by IssueFinderAgent and one by Scaffolder, with no human account in the list; the contributor count is zero, and GitHub’s card on the cover image says “0 Contributors.” Amazon’s announcement post goes further: “AWS Emulator is a local emulator of AWS services, 100% written by autonomous AI agents,” adding that “Our team hasn’t written or reviewed any of the code,” that the first SQS version took 15 minutes, that the rest was built over a weekend, and that the emulator covers 438 AWS API models.
TechRadar pulled those threads together on November 16, reporting that Kiro’s autonomous agents wrote the code, that the AWS team never reviewed it, that a working version came in 15 minutes, and that the team could use it the Monday after a weekend experiment. The same piece quotes the other half of AWS’s framing: “Turning that into a robust product took more than a weekend.” Werner Vogels wrote on November 11, the day of the launch, that “All of AWS Emulator’s code was written and tested by agents,” placing the engineer’s job in specs, tests and guardrails.
The verdict splits. Ownership, the README and docs wording, commit authorship and the zero contributor count are independently checkable. “100% written by agents” is AWS’s statement: from outside you can confirm that no human is credited and that AWS says so, not that every line came from a model. The Kiro detail and the weekend-to-Monday timeline come from what AWS told reporters; the repository holds no record of either. The Hacker News thread from November 11 (992 points, 266 comments) pressed on accuracy and long-term support; an AWS engineer replied that it is “a real product that we plan to maintain.”
Typical use cases
- Integration tests in CI: no AWS account or throwaway resources in the pipeline. Tests hit the local endpoint; Rust projects can use embedded mode for one isolated instance per test, in parallel.
- Closing the loop for coding agents: an agent writes code, runs it, and fixes what fails without leaving the machine. AWS lists “Prototyping with AI coding agents” as a use case, and it is the argument behind Vogels’ post.
- Offline work and demos: SDK call chains still run on a plane or behind a locked-down network, and showing the shape of S3 or SQS calls costs nothing once the process stops.
Quick start
The Linux install commands come from the AWS user guide:
curl -fsSLo aws-emulator.deb \
https://downloads.aws.com/aws-emulator/packages/aws-emulator/LTS/latest/aws-emulator_amd64.deb
sudo apt-get install -y ./aws-emulator.deb
aws-emulator # HTTPS on 127.0.0.1:9297, runs in the foreground
aws-emulator -v # confirm the version
On RPM systems, swap the first command for sudo dnf install -y https://downloads.aws.com/.../aws-emulator-x86_64.rpm. macOS and Windows go through Docker per the docs; from a checkout it’s cargo run -p aws-emulator-router. In a second terminal, point the SDK at the emulator:
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
aws s3api create-bucket --bucket amzn-s3-demo-bucket
Before wiring it into CI, run AWS’s check-project flow over your codebase: it maps the services and operations you actually call against the published fidelity data, which is cheaper than discovering the gaps as red builds.
Summary
AWS Emulator is for teams that want AWS calls running locally or in CI without an account and a bill. It is not for IAM policy semantics, cross-Region isolation, or a long-running environment under load: AWS says the last two haven’t been tested. The weakness is fidelity — about 70% of scored units pass in v1.0.481, wire-level units only half, and the control plane is ahead of the data plane. Telemetry is on by default and has to be turned off.
License and language: CC0-1.0 (vendor/ is Apache-2.0), Rust, 8,855 stars and 32 releases as of 2026-11-17. The floci entry covers a different route: MIT, Java, one docker compose up that brings S3/SQS-shaped services up on 4566 and can stand in for LocalStack. AWS Emulator’s edge is official API models, matching errors and a daily update cadence; the price is platform coverage and fidelity that aren’t finished. To operate a real account rather than test locally, the AWS MCP Server is the other direction — don’t mix the two up.