NEWS

AWS launches local emulator of its own cloud, written entirely by AI agents

AWS launches local emulator of its own cloud, written entirely by AI agents
Image: Redação iMasters
News
Reading
7 min
Tables
1
Code
1
In short

AWS Emulator reproduces more than 200 AWS services in a Rust binary that runs on your machine, and AWS says no line of the code was written by a human. One week after launch, the first independent tests show where fidelity is high and where it still falls short.

What AWS released

AWS launched AWS Emulator, a free, local implementation of more than 200 of its services, released into the public domain under a CC0 license. The tool draws attention for a detail in the launch post, signed by Daniel Abib: "thousands of autonomous AI agents wrote every line of code" of the project. It runs as a single Rust binary, generated from 438 of AWS's own public API models, and listens on port 9297.

The week following the launch brought the first fidelity numbers measured by third parties and a divided reaction among those who tested the tool. The angle that matters to developers: can you trust a test infrastructure that no human reviewed line by line?

How to get it running

Pointing an existing SDK, CLI, or code agent to the emulator is a matter of environment variables. After that, according to the launch post, "your tests, CLI scripts, and code agents keep working the way they already work":

bash
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_EC2_METADATA_DISABLED=true
export AWS_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE

The same shell works for an agent. In the launch post, Kiro receives the request to create a DynamoDB table, write an item, and read it back, and issues the usual CLI commands against the local endpoint: aws dynamodb create-table, aws dynamodb put-item, and aws dynamodb get-item, with no real credentials involved.

Why this matters for those who use code agents

Matt Wood, chief AI and technology officer at AWS, argues that this fast verification cycle matters because an agent keeps working while a check is slow: "A coding agent can build a lot of software on top of an incorrect assumption." But he also names the problem that an imperfect emulator introduces:

An agent learns from the environment it experiences. If the emulator accepts a behavior that AWS rejects, the training can reinforce the error. The agent can also discover a shortcut that only works because of a flaw in the emulator.

That's why every release publishes, service by service, how many tests pass against real AWS, including the tests that fail. Abib's proposal is that the reader treat each number "as a snapshot of a product that is improving," not as a promise of full parity.

How the code was written without a human

Senior principal engineer Matthew Goldberg says the project started from a three-line prompt given to Kiro, designed to be as simple as possible, "with no expectation that it would work": write tests based on the AWS CLI, iterate until they pass against real AWS, and from there, build an in-memory implementation that passes the same tests. In 15 minutes, Kiro returned a usable first version of Amazon SQS.

It clearly had gaps, but it was convincing enough that my team started using it to test our software the following Monday.

The production version is maintained by three teams of agents: one manages the test suite, another finds problems in the emulator, and a third fixes those problems. Each fix passes through a gate that compiles the change and runs automated reviews of code style, security, and fidelity regression before merging.

If any of these checks fails, the change goes back to the agent to redo; if all pass, it's merged into the main branch. We see thousands of issues fixed every day, with hundreds of agents working on the code at the same time. Without this merge gate, we wouldn't trust what our agents are building.

In a guest post on Werner Vogels's blog, Swami Sivasubramanian describes rebuilding with Kiro a replication engine that had taken his team four months of manual work:

I supervised the agent for four nights until I realized it had no way to check its own results. As soon as it got a specification and a test environment, the rebuild took about two hours.

For him, the engineer's job becomes building the specifications, the tests, and the merge gates that decide when that code is correct, not writing the implementation.

What real fidelity shows

The first independent test came from Kento Ikeda, an AWS Community Builder, who ran version 1.0.322 in GitHub Actions the day after launch. The numbers vary considerably by service:

ServiceService-level fidelityFidelity on operations used
DynamoDB~60-70%80-100%
S3~60-70%80-100%
SQS~60-70%80-100%
CloudFormation~20%not measured

Ikeda noted that the emulator reproduces even the exact text of AWS errors, but found a behavioral difference: a new DynamoDB table stayed in the CREATING state for three seconds and rejected writes until it left that state, something real AWS doesn't do the same way.

Having been generated from API models only means that the format of requests and responses matches AWS's.

His conclusion is that the tool occupies a layer between a mock and a real sandbox, and doesn't replace either one.

What the emulator explicitly doesn't do

The harshest line in the launch post is about security: AWS asks that the emulator not be used to test whether an application is secure, because it doesn't evaluate IAM policies or resource-based policies the same way real AWS does, which means a request denied on AWS can pass through fine on the emulator. The recommendation is to keep real credentials out of the test job environment and to validate the entire application's security on AWS before going to production.

Other documented limitations: operations not yet implemented return HTTP 501, telemetry comes on by default, and the emulator doesn't simulate throttling, service outages, or regional differences. The repository also doesn't accept external pull requests, which keeps the fix flow entirely within AWS's agent process.

Community reception

On Hacker News, a reader quoted the security page itself, which says the emulator "never denies a request signed with its own key," and asked why IAM was left out. Another comment, identified as coming from an AWS employee, answered the question of whether the project was just an exercise or something actually maintained:

It's a real product that we plan to maintain.

(original, en) It's a real product that we plan to maintain. (autor) comment attributed to an AWS employee on Hacker News

A third comment counted "29,684 commits in a repository less than a month old" and said that "doesn't inspire confidence." On r/aws, the top-voted comment turned the company's own line about agents fixing code without human review against AWS, calling it a terrible idea for a tool used precisely to test before going to production.

The timing of the launch also weighs on the reception: LocalStack's free Hobby plan now requires an account and bans commercial use, with paid plans starting at $39 a month, and some commenters had already migrated to Floci. One of these users summed up the scene: "in the wake of the Localstack changes, the landscape was already full of low-quality, low-trust code anyway. I don't think this is worse, for now."

What changes for those who test locally

For those who already use LocalStack, moto.py, or manual mocks to test AWS integration without spinning up real resources, AWS Emulator arrives as a free option with no commercial-use limit, maintained by the very owner of the API it imitates. This reduces a class of divergence that hand-built mocks always had: the request and response format comes directly from AWS's public API models, not from a third-party reimplementation.

But Ikeda's numbers make clear that "running without error" and "behaving like real AWS" are different things, especially outside the more mature services like DynamoDB, S3, and SQS. For a CI pipeline that tests application logic, the three-second difference in a table's CREATING state can be exactly the kind of detail that snags a test and never shows up in production. It's worth treating the emulator as a third layer of testing, not as a substitute for the real sandbox before deployment, and never as an environment for validating IAM or security policy.

AWS confirms it will share more details about the project at re:Invent, in December, which should bring new fidelity numbers and, possibly, an answer to the most repeated question in the comments: how far this agents-only maintenance model can scale without a human reviewing the merge.

Translated from the Brazilian Portuguese original · Read the original