top of page

AWS launches AWS Emulator, a free local cloud emulator written by AI agents

Nov 12
7 min read
AWS Emulator, a free local cloud emulator written by AI agents. Data Studios original cover

Amazon Web Services has released AWS Emulator, a local emulator of the AWS APIs that developers can run on a laptop, a development server or a CI pipeline to build and test AWS applications without sending a single request to the real cloud. The binary became available for download on November 11, 2026, together with its full source code, and AWS describes it as free to use: no AWS account is required and there is no additional service fee.


The release stands out for the way the software was produced. In the announcement published on Amazon's news site, Matthew Goldberg, a Senior Principal Engineer at AWS, writes that the emulator was "written entirely by autonomous agents" and that the team behind it has neither written nor reviewed any of its code. Agents generated the request-handling web server for 438 AWS API models, wrote tens of thousands of fidelity tests checked against real AWS, and, according to the post, fix thousands of issues every day while hundreds of agents work on the codebase at the same time.


The code is published under the CC0 1.0 public-domain dedication, with the exception of a vendor directory that keeps the Apache License 2.0. The public repository on GitHub already counted close to 30,000 commits on its main branch on November 12, and the project shipped release v1.0.322 on November 11 after several releases a day earlier in the week.


··········


⁣⁣⁣⁣⁣⁣⁣⁣⁣⁣⁣⁣

AWS EMULATOR: WHAT THE LOCAL AWS API EMULATOR DOES.


AWS Emulator answers AWS API calls on the developer's own machine, so that application code, infrastructure scripts and test suites can exercise services such as queues, storage or databases locally. The README positions it strictly as a building and testing tool. It has no graphical interface, and AWS states that it is not intended for production workloads or for security testing.


In server mode the emulator listens for HTTPS traffic on 127.0.0.1:9297 with a self-signed certificate, and developers point the AWS CLI or an AWS SDK at that endpoint through environment variables described in a separate guide. In embedded mode, available for Rust projects, the emulator runs inside the test process itself: there is no endpoint, no certificate and no environment variable to configure, because the test passes the emulator's HTTP client directly to the SDK client, and each test gets its own isolated instance.


AWS has not published a single list of supported services. The repository holds one Rust crate per service, and the README sends readers to per-release fidelity scores and to an issues folder for known gaps. Release notes from the first weeks contain fixes touching Amazon S3, DynamoDB, Lambda, EC2, CloudFormation, IAM, Cognito, Bedrock, Glue, Route 53, CloudWatch, EKS, ECS, RDS and Systems Manager, which shows how broad the surface already is, although a fix title is no guarantee that every operation of a service behaves like the real one.


··········


HOW AI AGENTS BUILT AWS EMULATOR WITHOUT HUMAN CODE REVIEW.


The project started as a weekend experiment. Goldberg describes giving Kiro, the AWS agentic coding tool, a prompt that asked it to write CLI-based tests, iterate until they passed against real AWS, and then build an in-memory implementation that passed the same tests. Kiro produced a first version for Amazon Simple Queue Service (SQS) in about 15 minutes, and the post credits earlier Anthropic research, in which agents built a C compiler, as the inspiration for the approach.


The production setup that followed splits the work among three teams of agents sharing an AWS CodeCommit repository, each with a narrow job and a gate before anything is merged.


........


Agent team

Task

Output

Test writers

Create fidelity tests from AWS API models and verify them against real AWS

Tests that describe real AWS behavior

Issue finders

Replay the tests against the emulator

Filed failures

Fixers

Take one issue each and fix it

Changes that must pass the merge gate

Merge gate

Build, code review, security and fidelity regression checks

Code accepted into the repository


........


The account is candid about the limits of the early output. Initial versions had obvious gaps, and turning the experiment into a usable product took far longer than a weekend. At one point the agents wrote their own Python interpreter to support Lambda functions, after which the team instructed them to reuse existing libraries instead of rebuilding them. Code reaches GitHub only at the end of the release process, and every filed issue is kept in the repository, in a folder of things that now work and a folder of things that still do not.


The team's role, as the post describes it, is to define the process, the tests and the gates, while the agents write and repair the code. AWS says it plans follow-up posts on the architecture, on how fidelity is measured, and on quality and security.


··········


HOW TO INSTALL AND RUN AWS EMULATOR ON LINUX, MACOS AND WINDOWS.


The README documents four ways to start, and the right one depends on the operating system and on whether the emulator should run as a separate server or inside the tests.


........


Method

Platforms

How it runs

AI coding agent skill

Any machine with AWS CLI 2.35.0 or later

Skill added to the agent toolkit

Server mode, packages

Linux

RPM or Debian package, then the aws-emulator command

Server mode, container

macOS and Windows

Container built from a short Dockerfile

Embedded mode

Rust projects

In-process dev-dependency, one instance per test

Build from source

Linux x86_64 and aarch64

Cargo build of the router crate


........


For coding agents, the README gives a single AWS CLI command that adds the emulator as a skill, and for source builds it lists two Cargo commands:


aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1
cargo build -p aws-emulator-router
cargo run   -p aws-emulator-router

Building from source is heavy. AWS lists a Rust toolchain, a C compiler, a multi-core machine and at least 100 GB of free disk space for the build directory as prerequisites, and the embedded mode carries the same build cost because it compiles the emulator into the test binary. Teams that only want a local endpoint will find the Linux packages or the container route much lighter.


Telemetry is switched on by default. It can be turned off with the command-line flag --telemetry off, with the EMULATOR_TELEMETRY environment variable set to off, false or 0, with a telemetry section containing enabled = false in the config.toml file under the .aws/emulator folder of the user's home directory, or with the Telemetry::Off option in embedded mode. Companies with strict policies on outbound data from developer machines should set one of these before rolling the tool out.


··········


[[ADPLUS_300x250_1]]

AWS EMULATOR FIDELITY TESTS AND THE EVALUATION SUITE.


The value of any local emulator depends on how closely it reproduces the real service, including error codes and edge cases. AWS publishes its fidelity tests in a separate repository, the AWS Emulator Evaluation Suite, also under CC0 1.0. Each test is a boto3 program that drives a workflow, then asserts the resulting resource state and, where relevant, the exact error code and message. According to the README, every test was verified against at least two sandboxed AWS accounts, and behavior that no test covers is explicitly described as not verified.


The suite ships with a command-line runner that returns three verdicts: passed, failed (which includes timeouts) and error, with a standard timeout of 60 seconds and 600 seconds for longer tests. The runner accepts only loopback endpoints, signs requests with the emulator's keys and strips AWS credentials, profiles and proxy settings from the environment, which reduces the risk of a test accidentally touching a real account. It does not restrict network access for tools or containers that a test starts.


AWS says fidelity scores are published per release. On the release pages reviewed on November 12, the latest builds did not display numeric scores, and several earlier builds stated that scores were not available. Until per-service numbers appear, the issues folders in the main repository are the most concrete record of which operations work and which do not.


··········


⁣⁣⁣⁣⁣⁣⁣⁣⁣⁣⁣⁤

WHAT AWS EMULATOR CHANGES FOR DEVELOPERS AND CI PIPELINES.


For developers, the immediate gain is a free local target for integration tests that does not require AWS credentials, does not create billable resources and does not depend on network access to AWS. Test suites that today spin up real queues, tables or buckets in a sandbox account, or that rely on hand-written mocks, can run against a local endpoint that aims to match real behavior, including error responses. The embedded Rust mode, with one isolated emulator per test, is designed for parallel test runs that do not interfere with each other.


The tool also arrives with a specific contribution model. The main repository does not accept pull requests, and the evaluation suite accepts neither issues nor pull requests. Users can file bug reports and fidelity gaps on GitHub, and AWS asks for the service, the operation, the SDK and its version, the request that was sent and the way the response differed from AWS. Fixes are then made by the agents. Teams that hit a gap therefore cannot patch it upstream themselves, although the CC0 license leaves them free to fork and modify the code.


Readers following AWS's agent tooling will recognize the context. The emulator was started with Kiro, whose team bots AWS recently made generally available, as covered in our report on Kiro Crew bots reaching general availability, and it continues AWS's work on infrastructure for agents described in our article on AWS Infinity, the open-source Rust runtime for idle AI agents.


··········


AWS EMULATOR: CONFIRMED FACTS AND OPEN QUESTIONS.


The confirmed facts are clear. AWS Emulator is free, needs no AWS account, serves AWS APIs locally over HTTPS on port 9297 or inside Rust tests, is released under CC0 1.0 with source on GitHub, and was built by agents working through a test-driven pipeline in which humans set the rules but did not write or review the code. AWS reports 438 API models, tens of thousands of fidelity tests and hundreds of concurrent agents behind it.


Several points remain open. AWS has not published a complete service list or per-service fidelity scores yet, the README does not say whether emulator state can persist between runs, the environment variables for server mode sit in a separate guide, and the security and quality posts promised by the team have not appeared. The absence of human code review is also new territory for a developer tool from a major cloud provider, and the published test suite is currently the main evidence of how closely the emulator matches AWS. For teams that need local AWS testing, the practical step is to run their own integration tests against it, check the things-that-do-not-work folder for the services they depend on, and disable telemetry where policy requires it.


··········


FOLLOW US FOR MORE.


·····


DATA STUDIOS


·····


datastudios.org


bottom of page