AWS Emulator: 200+ Local AWS Services Written by AI Agents
AWS has released AWS Emulator, a local emulator of the AWS APIs that runs on a laptop, a development server or a CI pipeline, and the most remarkable thing about it is not the feature list. Every line of code in it was written by autonomous AI agents. AWS's own engineering team wrote and reviewed none of it.
What the AWS Emulator is
The tool itself is straightforward to describe. You point the AWS CLI or any SDK at it with environment variables, and your code talks to an AWS-shaped API on your own machine. No AWS account is needed, there is no service fee, and responses come back in milliseconds. Resources live in memory and vanish when the emulator stops. For the operations it supports, the AWS Emulator returns the same result as AWS for valid calls and the same errors for invalid ones; operations it does not yet support return a 501 Not Implemented. The source is published on GitHub under the CC0 1.0 public domain dedication.
The release is two stories at once: a useful free tool for developers, and a demonstration that thousands of autonomous agents can build and maintain production software under the right guardrails. This article draws on AWS's announcement, the engineering post on About Amazon, and the published fidelity scores that accompany each release.
How thousands of agents built AWS Emulator without human review
The project began as a weekend experiment with a deliberately simple prompt to Kiro: write tests based on the AWS CLI, iterate until they pass against real AWS, then build an in-memory implementation those same tests pass against. Fifteen minutes later, Kiro returned a passable first version of Amazon SQS. The author refined the prompt, had Kiro build the rest of AWS over a weekend, and his team started using the result to test their software that Monday.
Turning that into something shippable took the real work: guardrails. AWS describes the production system as three teams of agents working against bounded tasks, and the division of labour is the core of how AWS Emulator gets built.
The first team writes tests. Its agents derive real-world AWS scenarios from the publicly released AWS API models, the same Smithy models behind the AWS SDKs, and verify each one against real AWS before submitting it. The result is tens of thousands of fidelity tests covering the whole platform, replayable without calling AWS again. These tests are the system's most fundamental guardrail, because they give every other agent an unambiguous goal to meet.
The second team finds issues. Its agents replay the fidelity tests against the emulator and file failures into a things-that-do-not-work folder, reasoning about root causes and grouping failures that share one. At the start, the emulator was an empty web server that could parse requests for all 438 AWS API models but did nothing; the first issues simply said build a first version of Amazon SQS.
The third team fixes. Each fixer agent takes one issue, checks out the code, root-causes it, and edits until it is addressed. Every patch then passes a merge gate covering build, code review against standards, security review by multiple adversarial agents, and fidelity regression. Fail any check and the change goes back for rework; pass them all and it merges to mainline. AWS reports thousands of issues fixed per day by hundreds of concurrent agents, and says plainly that without this gate it would not trust what the agents build.
The release pipeline runs on AWS Developer Tools with CodeCommit as the agents' repository. Code reaches GitHub only at the end, and the repository is a readable record of the whole process: fixed issues live in issues/things-that-now-work, the backlog in issues/things-that-do-not-work. Among the artefacts of earlier versions, the agents once built their own Python interpreter to support Lambda functions, which AWS has since guided them away from in favour of reusing existing libraries.
Why AWS built this with agents instead of engineers
The obvious question is why AWS would hand a product to agents at all, and the engineering post answers it with unusual directness. Emulating 200-plus services is enormous, repetitive work: thousands of operations, each needing faithful request parsing, validation errors, state handling and edge cases that only surface when a real client pokes them. Human teams have historically chipped away at that, which is why no existing emulator covers the full platform.
The agents attack it differently. Because the fidelity tests give an unambiguous pass or fail for every operation, the work parallelizes without coordination overhead. Hundreds of fixer agents each hold one issue, and none of them needs to know what the others are doing. The bottleneck is the merge gate, not the coding, which is why AWS reports optimizing the gate obsessively.
There is also a self-serving symmetry in the release. AWS Emulator exists so that developers' coding agents can test AWS code locally without accounts or spend, and the AWS Emulator itself was built by coding agents. The same loop that the tool serves, write, test against a reference, fix, is the loop that produced it. AWS's own team uses it daily to test their software, which is as close to a vote of confidence as an internal tool gets.
What the fidelity scores actually say
Unusually for a launch, AWS publishes a scores.json file with every release, and the numbers are honest about the gaps. The v1.0.322 release scored on 11 November passes 24,243 of 42,857 scored tests, which is 56.6 percent. At the step level, 49,810 of 68,007 individual steps pass, 73.2 percent. Cross-service workflows pass 41.9 percent of the time.
The per-service spread is wide and worth reading before you rely on anything. AWS KMS leads at 93.9 percent, with Amazon SQS at 89.8 percent and S3 at 79.1 percent. DynamoDB sits at 77.3 percent and SNS at 73.9 percent. On the weak end, Lambda is at 46.4 percent, EC2 at 41.5 percent, and CloudFormation is at 15.8 percent, passing only 414 of 2,612 tests. The fidelity documentation explains the pattern: control-plane APIs match AWS best, while data-plane behaviour and infrastructure-as-code support through CloudFormation, Terraform and CDK vary by service.
The DynamoDB example in the documentation shows what fidelity means in practice. A CreateTable call with a two-character name fails in the AWS Emulator with the same ValidationException text AWS itself returns. That is the bar: not just accepting valid calls, but rejecting invalid ones with identical errors, which is what makes a test loop trustworthy when your code exercises failure paths.
That profile tells you where the AWS Emulator is safe today. Testing application logic against SQS queues, KMS operations or DynamoDB tables is well covered. Testing a deployment template or a complex EC2 provisioning flow is not, yet. The release pace is fast, with 57 versions shipped between 8 and 11 November, and each release's fidelity report is public, so the sensible workflow is to check the score for the services your code actually touches before trusting the emulator with them.
How to run the AWS Emulator
There are four paths in, per the README, and each one suits a different workflow.
On Linux, install the RPM or Debian package and run aws-emulator. On macOS or Windows, build the container from AWS's Dockerfile, capped at 2 GiB of memory. In Rust, add it as a dev-dependency and get one isolated instance per test, which is a clean fit for unit tests that would otherwise fight over shared state. And for coding agents specifically, an AWS CLI 2.35.0 or later command adds the emulator as a skill: aws agent-toolkit add-skill –skill-name aws-emulator.
Each copy of the AWS Emulator you start gets its own port, keys and in-memory state, so agents, test suites and CI jobs never see each other's resources. That isolation matters more than it sounds, because the realistic use case is an agent that creates a DynamoDB table, tests against it offline, fixes its code and moves on, all without touching a shared environment. A source build serves HTTPS on 127.0.0.1:9297 with a self-signed certificate and needs a Rust toolchain, a C compiler and at least 100GB of disk.
The cost comparison with the incumbent tools is part of the pitch, and the AWS Emulator lands differently against each of them. LocalStack, the commercial incumbent, gates service coverage behind plans and requires an auth token. Moto is free and Apache-licensed but Python-oriented, with an in-process mock decorator rather than a standalone server. Floci is free and MIT-licensed. The AWS Emulator is free under CC0, covers 200-plus services from 438 API models, needs no vendor token, and is the only one of the four that publishes fidelity scores per release. For teams already living in AWS-shaped CI, that combination is competitive on its own.
What the AWS Emulator cannot do
The documentation is unusually direct about what the AWS Emulator cannot do, and the list deserves to be read in full rather than summarized away.
IAM is not evaluated like AWS. Identity and resource policies are accepted but not enforced with AWS's evaluation logic, so the AWS Emulator must not be used for security testing. A policy that leaks in production will look fine locally.
It runs with one region and one account, accepting any identifiers without isolating resources by them. Verification happened in us-west-2, with global services checked in us-east-1. State is in-memory and short-lived, untested for long runs or load tests, with an idle-timeout flag to stop it cleanly. And telemetry is on by default, disableable through a flag, an environment variable, config.toml or the embedded API, a detail enterprise buyers will want to handle in their base images.
None of these limits is hidden, which fits the AWS Emulator's whole posture: the fidelity scores, the failing tests and the open issue backlog are all public. The emulator is positioned as a fast, free test loop, not a shadow cloud, and the places it falls short of AWS are documented well enough to check against your own workload.
What it says about software built by agents
Beyond the tool itself, the release is a large-scale data point in the argument about how software gets built from here on. The AWS team's own account is candid about the failure modes: agents are not malicious, they are incompetent in ways that need containment, and the fix is what the author calls giving them a colouring book, a well-defined area to fill within a larger picture.
The colouring book here has three parts. A machine-checkable specification, the published API models. A reference implementation to test against, real AWS. And a merge gate that no human-written code ever passes through either, so that trust is placed in the verification process rather than in the author.
Under those conditions, thousands of agents produced a tool their own team uses daily, at a scale of daily fixes that would be difficult for a human team to match. The AWS Emulator team reports that the agents continue to improve it without their code review, release after release.
The honest caveats are in the same account. Early versions produced genuinely strange solutions, like the self-built Python interpreter, and it took iteration on the prompts and guardrails to steer agents toward conventional choices. The 56.6 percent fidelity score at launch is both the proof that the machine works and the proof that it is not finished. And the engineering lessons, the multi-agent workflow architecture, fidelity measurement, and the security bar, are promised as follow-up posts, which suggests AWS sees this as a repeatable pattern rather than a one-off experiment.
For developers, the practical takeaway is narrower and more immediate: a free, fast, AWS-shaped test loop that your coding agents can use without an account, with public scores telling you exactly how much to trust each service.
For context on where agentic development tooling is heading, our coverage of Git Forge rebuilding code review for agents, the Gemini Decisions API, and Rust debugging moving from print statements to AI agents sketches the same direction from different angles. The toolchain around agents is being rebuilt by the same forces the AWS Emulator itself now illustrates.
What the AWS Emulator says about software built by agents
The honest caveats are in the same account. Early versions of the AWS Emulator produced genuinely strange solutions, like the self-built Python interpreter, and it took iteration on the prompts and guardrails to steer agents toward conventional choices. The 56.6 percent fidelity score at launch is both the proof that the machine works and the proof that it is not finished. And the engineering lessons, the multi-agent workflow architecture, fidelity measurement, and the security bar, are promised as follow-up posts, which suggests AWS sees this as a repeatable pattern rather than a one-off experiment.
Questions readers are asking
What is the AWS Emulator?
A free local emulator of the AWS APIs, released 11 November 2026. It runs on Linux, in Docker on macOS or Windows, embedded in Rust tests, or as a skill for coding agents. Your existing SDK and CLI calls work unchanged, resources live in memory, and the source is public domain under CC0.
Was the AWS Emulator really written by AI?
Yes, and AWS is explicit that its team wrote and reviewed none of the code. Three teams of autonomous agents wrote the tests, found issues, and fixed them through an automated merge gate covering build, code review, security and fidelity. The full issue history is visible in the public repository.
How accurate is the AWS Emulator?
The v1.0.322 release passes 56.6 percent of 42,857 published fidelity tests, or 73.2 percent at the individual step level. Coverage varies widely by service: KMS at 93.9 percent and SQS at 89.8 percent, but Lambda at 46.4 percent, EC2 at 41.5 percent and CloudFormation at 15.8 percent. Each release publishes its own scores.
Can the AWS Emulator replace LocalStack or Moto?
For fast local and CI test loops against well-covered services, it is a strong free option with public fidelity scores, 200-plus services and no vendor token. It does not evaluate IAM policies, supports one region and one account, and is unsuitable for security testing or load testing, so it complements rather than fully replaces existing tooling today.
The bottom line
AWS Emulator is a genuinely useful release and a quietly historic one. The useful part: a free, public-domain, AWS-shaped API emulator covering 200-plus services, with published fidelity scores that tell you exactly where it is safe, and a coding-agent integration that puts a complete test loop in front of the tools developers already use. The historic part: it is the first piece of AWS infrastructure shipped entirely by autonomous agents under automated guardrails, with the whole construction process, including every failure, left visible in the repository.
The 56.6 percent fidelity score is the number to keep in view. It is low enough that nobody should mistake the emulator for the cloud, and high enough, growing fast enough, to show that the machine building it works. The colouring book approach, machine-checkable specs, a reference implementation and a trust-no-author merge gate, is the more transferable idea, and other infrastructure teams will copy it. The AWS Emulator will keep improving release by release; the method behind it is what the rest of the industry will be watching.
The bottom line lands on both halves of the release. As a tool, the AWS Emulator gives developers a free, fast, honestly-scored test loop today, with the caveat that its own scores say which services to trust. As a demonstration, it shows autonomous agents building production software at a scale humans did not review, under guardrails simple enough to describe and strict enough to trust. Both halves point the same direction: the AWS Emulator is the first of its kind, and it will not be the last.