AWS agents built and now maintain a public cloud emulator
AWS released an open-source emulator for its cloud services that was entirely generated and is maintained by autonomous coding agents, with no human-written code.
Amazon Web Services launched AWS Emulator on November 11, 2026, a local testing tool for its cloud platform. The project is notable not just for its utility, but because the code was written and is continuously maintained by autonomous software agents rather than human engineers.
What happened
The emulator allows developers and other AI agents to test applications against AWS services locally, without needing live credentials or network access. While similar tools like LocalStack have existed for years, AWS identified a persistent problem: emulators often fall out of sync with the actual cloud environment, leading to distrust among users and even internal teams. To solve this, AWS leveraged its own agentic coding tool, Kiro, to build a solution that could automatically stay current with API changes.
The project began as an experiment by Matt Goldberg, a senior principal engineer on the AWS Developer Tools team. Inspired by earlier work where agents built a C compiler, Goldberg tasked Kiro with creating an emulator for Amazon Simple Queue Service (SQS). The agent produced a working version in fifteen minutes. Encouraged by this speed, the team expanded the scope, having the agent build out support for the rest of AWS over a single weekend. Although that initial version had gaps, it was functional enough for internal testing by the following Monday.
AWS has released the emulator under the Creative Commons Zero license, placing it in the public domain. This decision stems from legal uncertainty regarding copyright ownership of code generated entirely by artificial intelligence. By waiving copyright, AWS avoids asserting rights that may not legally exist. The company also stated it will not accept human pull requests for the codebase, as the maintenance workflow is designed exclusively for autonomous agents.
How it works
The system relies on three distinct teams of agents working in a loop. The first team analyzes public Smithy models, which AWS uses to define its APIs, and generates test scenarios. These scenarios are run against real AWS services to establish the ground truth for how each API should behave. This step ensures that if documentation is inaccurate, the actual cloud behavior serves as the reference point.
The second team runs these same scenarios against the emulator code. It identifies discrepancies between the emulator’s output and the real AWS response. When failures occur, this team groups them by common causes and files issues in the repository. The third team then addresses these issues by modifying the code. Before any changes are merged, they must pass automated builds, tests, and security reviews conducted by other agents.
Human engineers do not write or edit the emulator code. Instead, they focus on improving the agent orchestration system. If a bug appears in the emulator, the team traces it back to a flaw in the agent’s instructions or logic and fixes the agent itself. For example, early versions of the agents attempted to write their own Python interpreter to support Lambda functions, a redundant effort that the humans corrected by updating the agents’ constraints to reuse existing libraries.
Key details
- The emulator supports 438 public AWS API models covering more than 200 services.
- It is written in Rust and runs locally on Linux, macOS, and Windows without an internet connection.
- No large language model calls are made during the emulator’s runtime; it is a static binary.
- AWS expects the gap between a new service launch and emulator support to shrink to days.
- The project does not accept human pull requests; contributions are limited to reporting issues.
- AWS publishes the benchmark suite used to test the emulator so users can verify its accuracy independently.
Why it matters
For software builders, this project demonstrates a mature workflow for autonomous code generation. It moves beyond simple code completion to full lifecycle management, including testing, debugging, and maintenance. The bounded nature of the problem—emulating defined API models—made it an ideal test case for agentic systems. It shows that agents can handle complex, multi-service interactions when guided by clear sources of truth and rigorous validation loops.
The decision to reject human pull requests highlights a shift in how open source projects might operate in an AI-native future. By treating the agent fleet as the sole maintainer, AWS ensures that the code remains consistent with its generation logic. This approach reduces the risk of human-introduced inconsistencies but requires robust tooling to manage the agents themselves. It also raises practical questions about community contribution models when the primary authors are non-human.
Additionally, the emulator provides a safer environment for testing AI agents that need to interact with AWS. Developers can let their own coding agents test against the emulator without exposing live AWS credentials. This sandboxing capability addresses significant security concerns that have hindered the adoption of autonomous tools in production environments.
What you can do
- Download the AWS Emulator from its public repository to test local development workflows.
- Run the published benchmark suite to verify the emulator’s accuracy for your specific use cases.
- Report issues or missing API behaviors through the project’s issue tracker instead of submitting code patches.
- Use the emulator to sandbox your own AI agents before granting them access to live AWS accounts.
- Study the agent orchestration patterns described by AWS to improve your own agentic coding pipelines.
- Monitor the project’s evolution to see how quickly it adapts to new AWS service launches.



