What AWS released
On 11 November 2026 AWS made AWS Emulator generally available. It's a local program that runs on your own machine. The AWS CLI, the AWS SDKs and coding agents connect to it over HTTPS and use the same API calls they'd make against the real cloud. AWS charges no service fee for it. The source is on GitHub under the CC0 public domain dedication, apart from vendored code in vendor/, which keeps its Apache 2.0 licence.
The tool is useful, but the way it was built is the bigger story for agent builders. Matthew Goldberg, a senior principal engineer at AWS, wrote that his team hasn't written or reviewed any of the code. Agents wrote all of it, and agents keep maintaining it.
How the emulator works
The emulator is written in Rust to keep CPU and memory use low on a laptop. It builds its service APIs from the public AWS API models, which are the same Smithy definitions (machine-readable descriptions of every operation, input and error) that generate the AWS SDKs. According to the AWS News Blog, using those models means request and error shapes match what the real services return. Each start-up creates fresh credentials, a config file and a certificate in ~/.aws/emulator/9297/. The emulator then listens on https://127.0.0.1:9297 as a single account, 000000000000.
To point existing tooling at the emulator, you change environment variables and leave your application code alone. Here's a shortened version of the setup from the announcement:
aws-emulator
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
aws sts get-caller-identityThe full list in the post also sets the region, turns off EC2 metadata lookups and unsets any existing AWS credentials, so a stray profile can't send test traffic to a real account. The emulator rejects any request that isn't signed with Signature Version 4 using the keys it generated, and those access key IDs start with EMULATOR. A health endpoint at /__admin/health lets a CI script wait until the emulator is ready before tests run.
On Linux you install the emulator from RPM or Debian packages. On macOS and Windows you build a Docker image from a short Dockerfile in the docs, because AWS doesn't publish a ready-made image. The repository README also lists an embedded mode for Rust: the emulator runs inside the test process, and each instance gets its own state, so parallel tests don't collide. Building from source needs Linux and at least 100 GB of free disk.
For coding agents, the README gives a skill install command that needs AWS CLI 2.35.0 or later:
aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1The AWS post shows Kiro creating a DynamoDB table, writing an item and reading it back against the emulator. The post also names Claude Code as an agent that can use the same local loop.
How agents built it
Goldberg's account on About Amazon says the project began as a weekend experiment, inspired by Anthropic's earlier demonstration of agents building a C compiler. The method depends on having a precise spec and a reference implementation. The AWS API models served as the spec and the real AWS cloud served as the reference. Goldberg asked Kiro to write tests based on the AWS CLI, iterate until those tests passed against real AWS, and then build an in-memory implementation that passed them too. Kiro produced a first version of Amazon SQS in about 15 minutes, and the rest of the services followed that weekend.
The production setup now splits the work between agent roles. Test-writing agents create fidelity tests from the API models and check each one against real AWS. Issue-finding agents replay those tests against the emulator and file the failures, grouped by likely root cause. Fixer agents each take one issue and submit a change. A merge gate checks the build, coding standards, security and fidelity regressions, and sends failed changes back for rework. Goldberg writes that hundreds of agents work concurrently and fix thousands of issues a day. The AWS News Blog adds that the agents run on Amazon Bedrock AgentCore Runtime with CodePipeline and CodeCommit, and that a separate security agent reviews changes adversarially both during development and in the release pipeline.
The public repository shows the pace. When we looked on 14 November, the main branch had 31,637 commits, and the releases page listed v1.0.322 on 11 November and v1.0.351 two days later. The README states plainly that the repository doesn't take pull requests. Outside contributors can file bugs and fidelity gaps as GitHub issues, and agents act on them.
Limits and costs
AWS measures fidelity with tests that run a workflow through an SDK. A test passes only when every status code, body and error message matches real AWS. AWS says it publishes scores as "k of n" with each release, and the full suite is public in the aws-emulator-evaluation-suite repository. The release notes we read listed fixes and gave no scores, so we can't quote a current fidelity number. Operations that aren't implemented yet return HTTP 501, so a test hits a clear failure instead of a false success.
The bigger gap is IAM. The emulator doesn't evaluate IAM or resource policies, so a request that AWS would deny can succeed locally. The AWS post says: "Don't use the emulator to test whether your application is secure." Analysts quoted by InfoWorld noted other gaps. IDC's Devin Pratt said the emulator doesn't simulate throttling, outages or per-Region availability, and doesn't sandbox the code it runs. A process with real credentials in its environment could still reach live resources. The emulator also sends anonymous usage data by default. You can turn telemetry off with --telemetry off or EMULATOR_TELEMETRY=off.
What this means for builders here
For New Zealand teams, per-Region availability is the gap to watch. AWS opened the Asia Pacific (New Zealand) Region, ap-southeast-6, in Auckland on 1 September 2025, and services have reached it gradually since then. The emulator acts as one account with no cross-Region behaviour, and its examples use us-east-1. A workflow that passes locally tells you nothing about whether a service or API operation is offered in Auckland yet. Teams deploying to ap-southeast-6 still need at least one integration run in that Region.
The most practical use is giving a coding agent somewhere disposable to work. An agent writing Terraform-adjacent glue code or a Lambda handler can create buckets, tables and queues, inspect the results and retry within seconds, without touching a shared dev account or adding to the bill. Unit tests in CI can run against the emulator, and IAM, quotas and Region checks can stay in a smaller suite that runs on real AWS before release.
The build process is worth studying even if you never run the emulator. AWS paired a machine-readable spec with a live reference system, had agents generate tests checked against that reference, and put a hard merge gate in front of every change. Any team with an API spec and a working system to compare against could set up a smaller version of that loop. If you try either the emulator or the method, you can share what you learn with other members on our projects page.
Sources
- Test your applications against AWS locally with AWS Emulator (AWS News Blog)
- How autonomous AI agents built AWS Emulator (About Amazon)
- aws/aws-emulator (GitHub)
- aws/aws-emulator releases (GitHub)
- AWS unveils local emulator service to help enterprises accelerate app development and testing (InfoWorld)
- Now open: AWS Asia Pacific (New Zealand) Region (AWS News Blog)
Build with people working on the same things
Join the Auckland Society for AI: NZ$599 a year with a ForgeBox and the members' projects area. Our Auckland meetups are open to everyone.