AWS Emulator: Offline AWS for Agents, Built Behind Gates
AWS has released a free, offline emulator of its APIs for coding agents and CI, and says agents wrote all of its code behind engineer-designed gates. What the sandbox and the method change for European enterprise teams.
AI-drafted, machine-checked against our published editorial rules, and reviewed on publication. Corrections: [email protected] How we use AI
Article
AWS has released AWS Emulator, a free, offline copy of its APIs that coding agents and CI pipelines can test against without an AWS account. For a European enterprise team, the tool matters less than the method behind it: AWS says agents wrote and tested all of the code, behind gates its engineers designed. That moves the governance question from "did a human read every line?" to "what gates does the system run, and what do they check against?"
AWS published the repository and an explanatory guest post on 11 November 2026, and Simon Willison wrote it up the same day. Everything below about how the emulator was built is AWS's own account. Nobody has audited it independently.
What AWS shipped
AWS Emulator is a local stand-in for the AWS APIs. In a guest post on All Things Distributed, Swami Sivasubramanian describes it as a local copy of AWS for coding agents to test against, adding: "It runs free and offline on your own machine." According to the same post, "it is built from more than 400 API models covering more than 200 AWS services." Other write-ups give different service counts, so we use AWS's own figure.
The aws/aws-emulator repository on GitHub adds the practical details. "You don't need an AWS account" to run it. Agents can be given an aws-emulator skill through the AWS CLI with aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1. The repository also says plainly what the emulator is not: "AWS Emulator is for building and testing. Don't use it for production workloads or to test security." It accepts no outside contributions: "This repository does not take PRs." The repository also documents telemetry that is switched on by default. Any team working under GDPR should read that section and set the switch deliberately rather than leave the default in place.
On licensing, the All Things Distributed post says the code "is released under CC0, a Creative Commons dedication to the public domain." That is about as permissive as a licence gets, so legal review should be short.
Simon Willison adds two details. It is written in Rust "by a huge swarm of agents - 29,684 commits in the first three weeks of the project", and "it currently requires Docker to run on macOS or Windows." The repository has gained more commits since he counted. The repository gives no general-availability date, and we would not assume the tool is mature.
Why an offline AWS matters for agent work
The obvious use is a sandbox, and for agent work the obvious use is the right one.
A coding agent fixing an S3 integration or a Lambda handler runs many cycles of edit, run, read the error and edit again. Run those cycles against a real AWS account and three problems follow. The agent needs credentials that can create and delete real resources. Each cycle can cost money, and a looping agent can run up costs before anyone notices. And if the test fixtures hold anything resembling customer data, it is being sent to a cloud region on every iteration.
An offline emulator removes all three. With no AWS account involved, the agent has no live credentials to misuse. There is no service fee, so the cost of a run is the compute on the machine running it, and failed attempts cost very little. Nothing leaves the machine, which suits GDPR-conscious CI and development environments with restricted network access. The pattern is the one behind our air-gapped deployment work: let the system iterate where a mistake is cheap and contained.
This matters most where agents are given real autonomy over code. A team doing vibe coding or running agents unattended overnight should not be pointing them at a shared AWS account. Before AWS Emulator, the alternatives were third-party emulators, hand-written mocks, or accepting the risk.
How it was built: agents behind gates
This is the part worth reading slowly. According to Sivasubramanian's post, "All of AWS Emulator's code was written and tested by agents". The post does not say that no human reviewed anything, and we would not claim that. What it describes is a set of gates that do most of the work line-by-line review usually does.
Fidelity tests checked against reality. The agents work from tests of how AWS services behave. In the post's words: "The agents correct each test until it passes against real AWS, so the test records how AWS behaves." This turns the usual order around. The test is not written from a document describing intended behaviour and then trusted. It is fixed against the real system first, so it serves as a record of observed behaviour that the emulator must then reproduce.
An adversarial merge gate. Every change must pass automated checks before it merges, including, the post says, "several security agents doing adversarial reviews." Security review sits before merge and is run by agents whose job is to find problems, not by the same agent that wrote the change.
Deterministic scope limits. The post describes "deterministic checks that stop agents from touching code they are not supposed to". The important word is deterministic. Scope is enforced by checks that run the same way every time, not by asking an agent in a prompt to stay in its lane.
AWS is careful not to overclaim. The post says: "We are early in learning how engineers drive teams of agents to build reliable, high-quality software." Commit volume on the scale Willison counted is far beyond what human reviewers could read. That is why the gates exist, and also why they need to be good.
What a European enterprise team should copy
Using the emulator is one decision. Copying the method is a bigger one, and in our view the more valuable. Four parts carry over to any agent-built or agent-operated system, AWS or not.
Treat tests against reality as the spec. AWS's fidelity tests are worth something because they are checked against the real service, not because agents wrote them. The equivalent for an AI system is an evaluation set drawn from real cases, with expected outputs confirmed by someone who knows the domain. Our AI evals page covers how to build one. Without it, an agent passing its own tests proves very little.
Make security review adversarial, automated and before merge. One reviewer reading a diff after it ships is the weakest arrangement there is. Separate agents tasked with breaking the change, with the power to block it, give a stronger and repeatable control. Human security engineers remain essential, but their time goes into designing the attacks the gate runs. Our guide to AI agent security for enterprise sets out the threat model.
Limit scope deterministically, not with prompts. A prompt telling an agent not to touch the billing module is a request. A check that rejects any change outside an allowed path is a control. This is the distinction behind agent guardrails, and a control is far easier to evidence under the EU AI Act or a DORA review than a line in a prompt.
Ask vendors what their gates are. When a supplier says agents built part of what they deliver, the useful questions are concrete. What are the tests checked against? What blocks a merge? How is each agent's scope enforced? Can you show fidelity or evaluation results? These belong in procurement and security review next to the usual questionnaire.
A worked example (hypothetical)
Consider a hypothetical team at a European insurer building an agent that ingests claim documents into S3 and triggers a processing function. They use the emulator in CI. Every pull request the coding agent opens runs the integration suite against AWS Emulator, with synthetic claim data and no AWS credentials in the CI environment. A deterministic check rejects any change outside the ingestion module. A separate review agent tries to find injection paths in the document parser before merge.
Verification does not stop at the emulator. A nightly job runs the same suite against a staging account in an EU region, because emulator behaviour can differ from AWS. When the two disagree, the team records the difference, writes a test against real AWS for it, and treats a green emulator run as provisional for that service until the gap is understood. The business decision is that agent iteration happens offline, cheaply and without data leaving the building, while sign-off for release still depends on a run against real AWS.
Caveats
An emulator is not AWS. How faithfully it reproduces each service varies, and the repository is clear that it is for building and testing only. Check which behaviours your system depends on before trusting a green run, and keep a staging stage against real AWS before production.
Not for security testing. AWS says so directly. IAM policies, encryption behaviour and network controls need testing in a real account.
The process claims are AWS's own. The statement that agents wrote and tested all the code, and the description of the gates, come from AWS. They are credible and detailed, but they have not been independently verified.
Telemetry and maturity. Telemetry is on by default, and the repository gives no release or general-availability date. Treat it as a useful tool still taking shape, not as infrastructure to depend on.
For teams moving agent pilots towards production, the gates matter more than the emulator itself. Our page on going from AI pilot to production covers how we put this kind of testing and governance in place. If you want a second opinion on the gates around your own agents, get in touch.
- What it is
- A local copy of AWS for coding agents to test against that, according to AWS, runs free and offline and is built from more than 400 API models covering more than 200 AWS services.
- No account needed
- The aws/aws-emulator repository says no AWS account is needed, and an aws-emulator skill for coding agents can be installed through the AWS CLI.
- Built by agents
- AWS says all of the emulator's code was written and tested by agents, working from fidelity tests corrected until they pass against real AWS, behind a merge gate that includes adversarial security agents.
- Stated limits
- The repository says the emulator is for building and testing, not for production workloads or security testing, and it does not accept pull requests.
- Licence and runtime
- The code is released under CC0, per AWS. Simon Willison reports it is written in Rust, had 29,684 commits in its first three weeks, and currently needs Docker on macOS or Windows.
Questions about this project.
What is AWS Emulator?
AWS Emulator is a local, offline copy of AWS APIs that coding agents and test suites can run against. According to AWS, it is built from more than 400 API models covering more than 200 AWS services, runs free on your own machine and does not need an AWS account.
Can AWS Emulator be used for production or security testing?
No. The aws/aws-emulator repository states that it is for building and testing and should not be used for production workloads or to test security. IAM policies, encryption and network controls still need testing in a real AWS account.
Did agents really write all of AWS Emulator's code?
That is AWS's own claim, made in a guest post by Swami Sivasubramanian on All Things Distributed. The post describes fidelity tests checked against real AWS, a merge gate with adversarial security agents and deterministic checks on agent scope. It does not say no human reviewed anything, and the claims have not been independently audited.
What should an enterprise team copy from how it was built?
Four things carry over to any agent-built system: tests checked against the real system as the specification, automated adversarial security review before merge, scope limits enforced by deterministic checks rather than prompts, and asking suppliers to show their gates and evaluation results.