Source: André Lindenberg's LinkedIn post (2026-11-13) on aws/aws-emulator.
TL;DR
AWS has released AWS Emulator, a local program that serves the AWS APIs so code and coding agents can test against it with no AWS account and no calls to AWS. The post's point is the build method, not the product: more than 30,000 commits were made by agents, and the test suite was first corrected until real AWS passed it, then the emulator was built until it passed the same tests. Real AWS is the test oracle. As Lindenberg puts it, "A replica earns trust when the real service grades its tests." Fidelity gaps are published, per service and per behavior.
What it is
Interface. A single HTTPS endpoint (127.0.0.1:9297, self-signed cert). Point the AWS CLI or any SDK at it with environment variables. No GUI.
Two modes. Server mode (Linux packages, or Docker on macOS and Windows) for any language; embedded mode for Rust tests, one isolated in-process emulator per test, wired straight into the SDK's HTTP client.
Structure. A Rust workspace with one crate per AWS service. Each crate has the service's Smithy model (which drives the wire protocol through code generation in
build.rs), a router with refusal overrides, in-memory state, and one file per operation. A router binary mounts every service on one endpoint.Agent-first install. The recommended path is
aws agent-toolkit add-skill --skill-name aws-emulator, then asking the coding agent to set it up.Scope. Building and testing only; AWS says not for production or security testing.
License and status. CC0-1.0, with vendored framework crates under Apache-2.0. Created 2026-09-11, about 8.2k stars by 2026-11-15. The repo does not take PRs; reports go to GitHub Issues.
Telemetry is on by default (usage only, not request contents), with off switches by flag, env var, config file or embedded option.
The method: real AWS as the oracle
The usual way to build a fake is to write the fake and tests together, which lets the two agree with each other and both be wrong. The described process breaks that loop in two phases:
Calibrate the tests. Agents run the test suite against real AWS and fix the tests (not the service) until real AWS passes. Now each test encodes observed AWS behavior, not someone's reading of the docs.
Build to the tests. Agents then implement the emulator until it passes those calibrated tests. The tests are frozen in this phase; the emulator is the thing that changes.
The Smithy models pin the wire format mechanically, so agent effort goes into semantics: state, errors, pagination, eventual-consistency quirks.
Fidelity is treated as data. Each release publishes a fidelity score per service, and known gaps are files in the repo (issues/things-that-do-not-work/), moving to issues/things-that-now-work/ when fixed. A user can check whether their project should work before adopting it.
Why it matters for staff engineers
A reusable pattern for agent-built software. Whenever a reference implementation exists (a production service, a legacy system, a spec with a conformance suite), let it grade the tests before agents write code. This is the cleanest answer yet to "who checks the agent's tests?"
Scale signal. 30k agent commits across hundreds of service crates is only reviewable because the oracle is external and mechanical. Human review shifts from reading diffs to reviewing the oracle and the gap list.
Local, account-free cloud for agents. Agents can create and destroy resources freely, with no credentials, cost or blast radius. That makes sandboxed agent dev loops and CI much simpler than mocking or shared sandboxes.
Competitive pressure on LocalStack and Moto, now with a first-party, published fidelity number.
Tradeoffs and failure modes
Oracle drift. Tests are calibrated against AWS at a point in time. When AWS changes behavior (a commenter raised this), the emulator stays green while real AWS moves. You need scheduled re-grading against real AWS, not just one calibration.
Test tampering in phase 2. Another commenter asked whether the repo records which tests changed after AWS graded them; in his harness a run only counted if test files matched a hash manifest. The post doesn't say how the freeze was enforced. Without a hash or ownership boundary, an agent can "pass" by editing a test.
Coverage is the ceiling. The emulator is exactly as faithful as the calibrated suite. Untested behaviors (IAM edge cases, throttling, cross-service consistency, timing) can be arbitrarily wrong. The fidelity score measures pass rate on the suite, not unknown unknowns.
Commit count is activity, not quality (a third commenter's point). The signal that matters is the oracle and the gap list.
False confidence. Green locally is weaker evidence than green on AWS. Keep a smaller suite running against real AWS in CI for the paths you depend on.
Build cost. About 100 GB of
target/and long cold builds from source or in embedded mode. Cachetarget/, shareCARGO_TARGET_DIR, pin to a release.Not for security. IAM and policy evaluation fidelity should not be trusted.
Closed contribution. No PRs, so fixes depend on AWS's agent pipeline and issue triage.
Telemetry on by default. Turn it off in CI, and tell users if you embed it in a tool.
Review checklist
Adopting the emulator:
Check the release's fidelity score and
things-that-do-not-work/for every service and operation you use.Keep a smoke suite against real AWS on a schedule, so drift shows up.
Use embedded mode for Rust unit tests with per-test isolation; server mode elsewhere.
Set
EMULATOR_TELEMETRY=offin CI.Never use it to validate IAM or security behavior.
Applying the method to your own agent-built replica or migration:
Is there an external oracle (the real system), and did it grade the tests before implementation started?
Are tests frozen during implementation, with a hash manifest or ownership check that fails the run if they change?
Is every test change after calibration logged and re-graded against the oracle?
Is there a published, per-component gap list?
Is re-calibration against the oracle scheduled?
Related entries
R020: the model proposes, the harness enforces. The emulator is that principle at scale, with real AWS as the enforcer.
R058: protect the oracle. Commit the failing test first, then block test-file edits during the fix.
R024: InfraRSI locks a contract and hashes frozen files before any agent edit, the same guard the emulator's phase 2 needs.
R038: AlphaProof Code, another agent-built artifact trusted because of an external checker (a prover).
R029: synthetic enterprise tenants, the other way to give agents a safe environment to test against.
R064, R066: accept changes only when a measurement says so, and control false acceptances.