Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

An AWS Nobody Wrote a Line Of: AWS Emulator Runs 200+ Services Locally, Written Entirely by Agents

On November 11, AWS released AWS Emulator, a local emulator covering 438 API models and more than 200 AWS services, free, with no account and no network needed. The headline is who built it: AWS says autonomous agents wrote every line, with humans building the guardrails instead — fidelity tests, a merge gate and adversarial security review. The honest limits matter just as much: it does not evaluate IAM policies, so a request AWS would deny may succeed locally.

A real photo: an AWS data center aisle at night, rows of server racks with blue lights, two workers in high-visibility vests, the AWS logo on the building.

An AWS that no human wrote a line of

On November 11, AWS released AWS Emulator, a local emulator for AWS that runs on your own machine: the AWS CLI, the SDKs and coding agents talk to it over a local HTTPS endpoint using exactly the same AWS APIs they would use in the cloud, and the responses come back in the same shape as real AWS. There is no additional service fee, no AWS account required, no network connection needed, and the source is public on GitHub. On its own, that is not exactly new — LocalStack and Moto have simulated AWS locally for years. What makes this story worth a full article is something AWS said on the same day, in its own words. The person who said it is Matthew Goldberg, a Senior Principal Engineer at AWS, and his post on About Amazon is titled "AWS Emulator: a local emulator built 100% by autonomous AI agents". In the body he writes: "The emulator was written entirely by autonomous agents. Our team hasn't written or reviewed any of the code."

First, the product itself, and then what that sentence really means. AWS Emulator is written in Rust, chosen to stay light on CPU and memory on a laptop. When it starts, it serves HTTPS on 127.0.0.1:9297, so only your own computer can reach it, and it generates its own credentials, a config file and a certificate, written to ~/.aws/emulator/9297/. You set a few environment variables — above all AWS_ENDPOINT_URL pointing at the local port — and clear any variables that could supply real AWS credentials, and your application code stays unchanged. A unit test that creates a DynamoDB table, writes an item and reads it back is the same test, and it runs on your machine without a deployment. A coding agent can create resources, check the result and iterate again without waiting on a deployment in a Region. Access keys are regenerated each time the emulator starts, and their IDs start with EMULATOR, so you cannot mistake them for real AWS keys; the emulator rejects requests signed with any other keys.

Coverage works like this: the emulator is generated from the AWS API models that AWS publishes — the same models behind the AWS SDKs — and it currently covers 438 API models across more than 200 AWS services. Read that number carefully: it counts services that have an API model, not operations that are all implemented. An operation it does not implement yet returns HTTP 501 (Not Implemented), so your tests fail right away instead of quietly returning a fake success. That design deserves credit: the worst flaw in an emulator is not missing a feature but pretending to support it. State lives in memory until you stop the emulator; it acts as a single account, 000000000000, with no cross-account or cross-Region behaviour.

How it was built: three teams of agents

Goldberg's post describes the building process in detail, because the building process is half the product. It started as a weekend experiment. Earlier this year, researchers at Anthropic demonstrated that a team of Claude agents could autonomously build a C compiler, and that was the lightbulb moment: if agents can build a solution from a written spec and a reference implementation, AWS has both — the AWS API Models are the spec, and the actual AWS cloud is the reference implementation. To test the hypothesis, he gave Amazon's Kiro coding agent the simplest prompt he could think of: first, write tests based on the AWS Command Line Interface; second, iterate on those tests until they pass against real AWS; third, build an in-memory implementation that those same tests pass against. Kiro came back after 15 minutes with a passable first version of Amazon Simple Queue Service. He refined the prompt and had Kiro build the rest of AWS over the weekend. It did — with gaps, but compelling enough that his team started using it to test their software that Monday.

Turning a weekend experiment into a product customers can rely on took guardrails, not more hand-written code. AWS Emulator is now built and maintained by three teams of agents, all running on Amazon Bedrock AgentCore runtime instances. Team one writes tests: it devises real-world AWS scenarios from the public API models — creating an SQS queue, sending a message, receiving it, acknowledging it and deleting the queue, for example — verifies each one against real AWS, and saves it as a fidelity test. There are now tens of thousands of them. Team two finds gaps: it replays those tests against the emulator and files what fails as issues, into a folder in the repository called things-that-do-not-work; the fixed ones go into things-that-now-work. Team three fixes issues: each agent picks up one issue, root-causes it, edits the code, and then passes the change through a merge gate covering build, coding standards, security and fidelity regression. Anything that fails goes back for rework; everything that passes merges to mainline. Once merged, changes flow through a CodePipeline run that re-runs the fidelity tests before publication to the public GitHub repository. Goldberg writes that they have seen thousands of issues fixed every day, with hundreds of agents working on the codebase concurrently.

The most interesting role in this flow is an independent security agent. It reviews changes adversarially while a fix is being made, and again in the release pipeline as a final check before anything ships. The logic is straightforward: if humans no longer review code line by line, some mechanism has to review it for them. Goldberg is candid about it: without the merge gate, they would not trust what the agents are building. His team's work has shifted from writing code to optimising that gate. That sentence may be the most useful lesson in the whole announcement for people who vibe-code, and we will come back to it.

Fidelity: the emulator's only hard currency

Whether an emulator is any good has exactly one test: do the tests that pass against it also pass against real AWS? AWS has turned that test into a public score. Each fidelity test is a short program that uses an AWS SDK to run a workflow, verified against real AWS first. It passes only if the emulator matches AWS on the response to every call — including the status code, the body and the exact error code and message — and on the resources and data the workflow creates. With each release, AWS publishes how many fidelity tests pass for each service, written as k of n: 40 of 50 means 40 of the service's 50 fidelity tests pass. The test set itself is public in the aws-emulator-evaluation-suite repository on GitHub, including the tests that do not pass yet, so you can see what was verified and run the tests yourself. Read a score as a snapshot: AWS itself warns that when it adds fidelity tests, a score can go down even while the emulator gets better.

This public scoreboard is the biggest difference between AWS Emulator and earlier local simulators. It does not promise to "be like AWS"; it tells you, service by service, how close it is, and lets you decide whether to trust it. Before testing S3 and DynamoDB against it, check those services' fidelity scores; for services with low scores, go back to real AWS. That is an unusually honest product stance, and it is also the usage pattern vibe coders should learn: the emulator is not a replacement for the real cloud, it is a cheap filter in front of it. The filter catches the cheap mistakes — a misspelled field name, a wrong table shape, a missing step in a flow. The things it cannot catch are listed separately below.

Process diagram: how three teams of agents build AWS Emulator. Team one writes fidelity tests from the API models and verifies them against real AWS; team two replays the tests and files failures as issues; team three fixes issues and passes them through a merge gate. 438 API models, more than 200 services, first SQS version in 15 minutes.

What it cannot do: the honest limits first

AWS states the limits unusually bluntly in this announcement, which is rare and welcome. First, it does not evaluate IAM policies and resource-based policies the way AWS does. A request that AWS would deny might succeed in the emulator. AWS's own words: do not use the emulator to test whether your application is secure. Test your security settings and your whole application on AWS before you go to production. Second, each emulator acts as a single account, with no cross-account or cross-Region behaviour. Third, how closely it matches AWS varies by service and feature; check the fidelity scores in the documentation before trusting a service. Fourth, an independent analyst added to press coverage that it does not yet simulate throttling, outages or differences in which services and features are available by Region, and that it does not sandbox the code it runs. Of these limits, the first is the one that matters most: if your tests go green locally, you have proved the logic is right and proved nothing at all about permissions. Confusing those two things is the easiest way to get hurt using this tool.

Two more details belong in the notes. By default the emulator sends anonymous usage and error data, and you can turn it off — if you care, switch it off right after installing. Embedded mode, which runs an emulator instance directly inside your test process with its own state so tests can run in parallel without sharing buckets, tables or queues, is currently available for the AWS SDK for Rust only. Other languages use the standalone process plus environment variables for now. Both points describe the launch-day state, and AWS says it will keep updating; how fast that happens depends on those three agent teams.

"No human wrote a line of code": can that claim be trusted?

Now back to the sentence that grabs the attention. Goldberg's exact words are: "The emulator was written entirely by autonomous agents. Our team hasn't written or reviewed any of the code." On the same day, Swami Sivasubramanian, AWS Vice President for agentic AI and emerging technology, published a companion piece on All Things Distributed titled "AWS Emulator and the engineer's job when agents write the code". His account matches Goldberg's: all of the emulator's code was written and tested by agents, built from more than 400 API models covering more than 200 AWS services. The code is released under CC0, a Creative Commons dedication to the public domain, with the full commit history public and every issue the agents have filed visible in the repository.

Can it be believed? Start with the part that can: the commit history is public, and anyone can go to GitHub and count. AWS would not put "no human reviewed a single line" in an official post if the repository were full of human commits; the claim would be dismantled within days. Now the discount: "no human wrote code" does not mean "no human did any work". The human work moved somewhere else — writing the test suite, defining the fidelity standard, building the merge gate, tuning the security agent, setting rules for the agents (one early version, for example, decided on its own to build a Python interpreter to support Lambda functions; the team later gave it explicit guidance to reuse existing libraries instead). Goldberg tells that anecdote himself, and it explains the point better than any slogan: agents do not lack execution, they lack judgement, and judgement is still supplied by humans.

There is also a more practical question: what guarantees the quality of agent-written code? AWS's answer is three layers — fidelity tests, the merge gate and the security agent. The tests are verified against real AWS as the ground truth, the gate is automated, and the security review is itself done by agents. Humans sit only on the outermost layer: setting the standard, watching the scores, fixing the guardrails. Whether that holds up over time will show in the trajectory of the fidelity scores and the speed at which public issues are cleared — both of which are public and anyone can keep watching. That is the smartest part of this launch: it does not ask you to "believe in AI"; it hands you evidence you can keep checking.

What it means for vibe coders

The direct benefit first: in an agent loop, the slowest and most expensive step is often not writing code but verifying it. Until now, once an agent wrote code that calls AWS, you waited for a deployment, waited for a real call, watched the bill creep up, and worried about what the agent had created in a real account that you could not delete. That loop can now move onto your own machine: write, run, read the result, revise, run again, for no money, without touching a real account and without a network connection. For vibe coding, this change is structural: agents have been writing code faster than humans can verify it for a while, and verification is the bottleneck. AWS Emulator brings the cost of verification down, which is what finally lets an agent be trusted to try things on its own.

The deeper point is that this product is itself a public validation of the vibe coding method. Its construction process is almost identical to a vibe coder's workflow: give the agent a clear spec and a reference answer to check against, let it write, test and revise, and keep humans on standard-setting and acceptance. The difference is scale: AWS turned that loop into three teams, tens of thousands of tests and an automated merge gate. Goldberg opens his post with a childhood story about drawing: sent to kindergarten a year early, unable to hold a crayon properly, he ruined the class's dinosaur painting and his classmates shouted at him; this year he has lost his temper at his AI agents more times than he cares to admit. But the problem, he says, was never malintent — it was a lack of competence. Agents, like his younger self, need a colouring book: a clearly defined area to fill in, knowing the larger picture will come together. That is an accurate and honest metaphor: agents do not need fewer humans, they need humans to manage them differently.

Swami's post says the same thing more bluntly: when agents can write code, the engineer's job becomes building "the machine that lets agents write good code" — writing fidelity tests, setting merge standards, building security review. In other words, once vibe coding reaches a certain scale, the competition is not about whose prompt is cleverer but about whose acceptance system is stronger. That judgement is worth sitting with for anyone who has already shipped a project with agents: does your project have an acceptance gate that does not depend on you watching? If not, the faster your agents write, the more verification debt you accumulate.

How to use it: a pragmatic starting point

If you want to try it now, here is a sensible order. First, install it and run the official getting-started example: an RPM or Debian package on Linux, or Docker on macOS and Windows using the short Dockerfile in the documentation (note that AWS does not publish a ready-made image; you build it yourself). After starting it, set the environment variables from the official documentation, then create a bucket with aws s3 mb, copy in a small file and list it, to confirm your shell is really talking to your laptop. The documentation has a thoughtful touch here: the emulator's access key IDs start with EMULATOR, so they are recognisable at a glance. Second, move your most stable existing DynamoDB or S3 test scenarios over and get them passing locally. Third, check the fidelity scores for the services you use; for low-scoring services, do not force it — leave those tests for a staging environment on real AWS. Fourth, and most important: keep IAM-related tests on real AWS forever. All green locally says nothing about permissions.

Some projects benefit immediately: early-stage vibe projects where the cloud bill is still sensitive, and local loops save a lot of trial-and-error cost; CI pipelines running integration tests without opening a real account and provisioning real resources for every pull request; teaching and demos, where you no longer need to hand every student an AWS account. And some scenarios are not a fit yet: testing IAM policies, cross-account or cross-Region behaviour; load-testing throttling and failure recovery; or using the emulator as a production environment — AWS is explicit that production workloads are out of scope.

Open questions and what to watch

Several things were still unanswered on launch day. First, the per-service fidelity scores were not listed item by item in the announcement; AWS points you to the documentation. That means early users will have very different experiences depending on which services they use — some will feel it is uncannily accurate, others will find it still far off. Second, embedded mode currently supports Rust only; developers in other languages use the standalone process. Third, AWS says it will share more at its upcoming re:Invent conference, which may bring more coverage and score updates. Fourth, and most worth watching: can this "agents building software" machine sustain itself — do fidelity scores rise or fall, does the backlog of public issues grow or shrink, and how does community participation evolve?

A final judgement. AWS Emulator has two identities: a tool and a piece of evidence. As a tool, it solves the most concrete pain of the agent era — verification that is too slow, too expensive and too risky. As evidence, it proves that the agent-built software path can reach "good enough to hand to customers", provided the acceptance system is strong enough. Of the two, the second matters more. Tools iterate and scores move up and down, but once a company of AWS's scale has publicly validated the division of labour — humans behind the guardrails, agents in front — it is hard to go back. The question vibe coders should ask themselves has changed too: no longer "can an agent write this code", but "is my acceptance system strong enough that I can afford not to read this code?" AWS Emulator's answer is: yes — but you have to build the acceptance system yourself.

Views 16Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality