Imagine building an application that uses Amazon S3, DynamoDB, Lambda, and SQS. You write the code, configure your AWS credentials, deploy resources, run tests, discover a bug, make a change, and deploy again.
Even a small development cycle can involve several cloud operations, configuration steps, and waiting for deployments.
Now imagine doing most of that work locally, without an AWS account, without provisioning cloud resources, and without waiting for deployments.
That’s what AWS Emulator, released by Amazon Web Services on November 11, 2026, brings to developers.
But there’s another detail that makes this release particularly interesting: AWS says the emulator’s entire codebase was written by autonomous AI agents. Human engineers didn’t write or review the code. Instead, AWS built an automated system in which AI agents write tests, identify failures, implement fixes, and continuously maintain the project.
Thousands of AI agents building software that emulates one of the world’s largest cloud platforms. That’s an interesting engineering experiment, regardless of where you stand on AI-generated code.
For developers, it also introduces a practical way to test applications that depend on AWS services without constantly interacting with the actual cloud.
Let’s look at how it works, how AWS built it, and where it fits into an everyday development workflow.
What Is AWS Emulator?
License: CC0 1.0
GitHub: aws-emulator
AWS Emulator is a local environment that reproduces AWS API behavior on your own machine or inside a CI pipeline.
It allows applications to communicate with simulated AWS services through familiar AWS SDK and AWS CLI interfaces.
For example, suppose your Node.js application uploads files to Amazon S3.
Normally, your application communicates with AWS using an SDK:
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
const s3 = new S3Client({
region: "us-east-1",
});
await s3.send(
new PutObjectCommand({
Bucket: "my-bucket",
Key: "hello.txt",
Body: "Hello from Node.js",
})
);During local development, you can point your SDK at AWS Emulator instead of the actual AWS endpoint.
Your application continues using the AWS SDK. The emulator handles the request locally and returns a response.
This means you can develop and test cloud-dependent functionality without creating actual AWS resources for every test run.
The emulator also maintains resource state in memory. If your application creates an S3 bucket, subsequent requests can interact with that bucket during the emulator’s lifetime.
The important distinction is that your application uses the actual AWS API interfaces, while the service implementation runs locally.
AWS describes the project as a development and testing tool, with no additional service fee.
How AWS Emulator Works
The architecture is relatively straightforward from an application developer’s perspective.

Your application communicates with a local HTTPS endpoint. AWS Emulator receives the request, processes the supported API operation, maintains the relevant resource state, and returns a response.
The workflow looks like this:
Install and start AWS Emulator.
Configure your AWS SDK or CLI to use its local endpoint.
Execute your application or test suite.
Emulator processes supported AWS API requests.
Your application receives responses without contacting AWS.
There are a few implementation details worth understanding.
1. Existing AWS SDKs and CLI continue working
One of the most useful design decisions is compatibility with existing AWS development tools.
You don’t need to replace your AWS SDK with a special emulator SDK.
You configure your application’s AWS endpoint to point to the local emulator, and your existing SDK calls can continue working.
The same approach applies to the AWS CLI.
For example, your application can use the same S3, DynamoDB, or SQS operations it would use against AWS.
This reduces the amount of application-specific code required to switch between local testing and cloud execution.
2. Broad AWS service coverage
AWS Emulator is written in Rust and generates service implementations from publicly available AWS API models.
These models describe the APIs used by AWS services and are also used in the AWS SDK ecosystem.
The emulator uses those models as the foundation for implementing service APIs.
Some of the services developers can work with include:
Amazon S3
Amazon DynamoDB
AWS Lambda
Amazon SQS
AWS publishes fidelity reports showing how closely the emulator’s implemented operations match the actual AWS services.
One important detail: having an API model does not automatically mean every operation is fully implemented. Support improves over time, and unsupported operations return HTTP 501 (Not Implemented).
3. Isolated local environments
Consider a development team where multiple engineers run tests simultaneously.
Or imagine an AI coding agent creating resources while another agent runs integration tests.
Shared local state can quickly become a problem.
AWS Emulator addresses this by generating separate ports, credentials, and in-memory state for each running instance.
Each instance works independently.
For example:
Test suite A creates an S3 bucket.
Test suite B creates a DynamoDB table.
An AI coding agent runs its own integration tests.
These environments don’t share their emulator resources.
This makes parallel testing considerably easier to manage.
4. Local execution and CI integration
AWS Emulator can run on a developer’s machine or inside a continuous integration environment.
AWS provides Linux installation packages in RPM and Debian formats. On macOS and Windows, developers can run it through Docker.
This makes it possible to introduce local AWS API testing into existing development workflows without requiring every test to deploy resources to an AWS account.
AWS Emulator was built by autonomous AI agents
This is probably the most unusual part of the announcement.
AWS says its engineers used AI agents to build and maintain the emulator without manually writing or reviewing its code.
The project started as an experiment by Matthew Goldberg, a Senior Principal Engineer at AWS.
From a 15-minute experiment to a cloud emulator
Goldberg initially gave the Kiro coding agent a simple task: implement Amazon SQS.
The agent produced a working implementation in approximately 15 minutes.
That experiment grew into a much larger project over a weekend. The initial version eventually became the foundation for AWS Emulator.
The interesting engineering decision came next.
Instead of treating AI as an assistant that generates code for human engineers to review, the team designed an automated development process in which agents handle implementation, testing, and maintenance.
The three-team autonomous agent workflow

AWS describes three groups of autonomous agents working together.
Team 1: Test writers
These agents create tests based on real AWS behavior.
They execute workflows against actual AWS services and record the expected responses, including successful operations, error codes, and error messages.
Team 2: Issue finders
The second group executes those tests against AWS Emulator.
Whenever the emulator behaves differently from AWS, these agents identify the failure and create an issue describing the discrepancy.
Team 3: Fixers
The third group picks up those issues and writes code changes to address the failures.
The updated implementation goes through automated checks before it can be merged.
The workflow continuously repeats:

AWS runs hundreds of agents concurrently, with thousands of issues reportedly being fixed every day.
The agents run on Amazon Bedrock AgentCore.
How does AWS prevent bad AI-generated code from getting merged?
Allowing autonomous agents to modify a large codebase introduces an obvious concern: how do you maintain code quality without human review?
AWS uses automated merge checks.
Every change must pass checks covering:
Security requirements.
Successful compilation.
Coding standards.
If a change fails, it goes back to the agent for rework. Successful changes can be merged automatically.
There is an important distinction here. The absence of human code review doesn’t mean the absence of quality controls. AWS relies on automated verification and tests grounded in actual AWS behavior.
The project also publishes its source code, issues, and fidelity tests, allowing developers to inspect what the agents have implemented.
Understanding AWS Emulator’s service fidelity
If you have worked with mock servers, you probably know the problem.
A mock can return the response your test expects even when the real service would reject the request.
For example, your mock might accept an invalid DynamoDB request. Your test passes, but the application fails when it reaches AWS.
AWS Emulator approaches this differently.
It measures how closely its behavior matches the actual AWS APIs. AWS calls this measurement service fidelity.
How fidelity is measured
AWS creates test workflows using its SDKs and executes them against real AWS services.
The same workflows are then executed against AWS Emulator.
The results are compared, including:
HTTP status codes.
Error codes and messages.
Resource state after operations.
Other observable side effects.
AWS publishes the number of passing tests against the total number of tests for each service.
For example, a hypothetical score of 40/50 means the emulator passed 40 of the 50 published tests for that service. It does not mean that 80% of every possible service behavior is supported.
That distinction matters when evaluating whether the emulator can replace your existing integration testing setup.
What happens when an API isn’t supported?
AWS Emulator returns HTTP 501 with a NotImplemented error when an operation hasn't been implemented.
This is useful because unsupported functionality fails visibly instead of silently returning an invented successful response.
AWS also maintains separate lists of issues for functionality that doesn’t work yet and functionality that has been fixed.
You can inspect the evaluation suite here:
💡 Enjoying this article?
Every week day, I publish practical, production-ready deep dives covering Web development, System Design, Open source projects, Tech industry trends and AI Engineering and tools.
What developers can use AWS Emulator for
The emulator has several practical applications in everyday development.
1. Local development without AWS resources
Suppose you’re building a Node.js backend that uses S3 for file uploads and DynamoDB for metadata.
You can run your application against AWS Emulator, test the resource interactions, and iterate locally.
You don’t need to create cloud resources for every development change.
2. Integration testing
Unit tests often mock AWS SDK responses.
That works for testing individual application functions, but it doesn’t always catch API compatibility problems.
An emulator lets you exercise actual API operations and resource state transitions locally.
For example, you can test whether your application correctly creates a DynamoDB table before inserting records into it.
3. CI/CD pipelines
You can run AWS Emulator inside your CI environment.
When a developer opens a pull request, your pipeline can start an emulator instance, execute integration tests, and shut it down afterward.
This reduces dependence on shared development AWS accounts for supported operations.
4. AI-assisted software development
This is where the release becomes particularly relevant.
Coding agents frequently generate application code that interacts with cloud services.
Without a local execution environment, an agent may need to deploy code to discover whether an API call works.
With AWS Emulator, the agent can execute supported AWS operations locally and receive feedback much faster.
AWS also provides an aws-emulator skill for coding agents. It can help an agent install and configure the emulator and check whether a project uses supported operations.
For developers using tools such as Kiro, Cursor, or Claude Code, this creates another feedback loop during autonomous development.
AWS Emulator vs LocalStack vs Floci
AWS Emulator enters an existing category of local AWS development tools.
Two projects worth knowing are LocalStack and Floci.
LocalStack
A widely used local AWS cloud emulator with a broader ecosystem and established development workflows.
Floci
An open-source alternative for emulating AWS services locally.
AWS Emulator
AWS’s own emulator, built in Rust and maintained through an autonomous AI agent workflow.
The most interesting difference is how AWS Emulator approaches API fidelity and maintenance.
AWS builds its evaluation tests against real AWS behavior and publishes the results. Its agent workflow then uses those tests to identify and fix discrepancies.
However, choosing between these tools requires checking the services and operations your application actually uses.
A tool with broad service coverage can still have gaps in a particular API operation.
LocalStack, Floci, and AWS Emulator should be evaluated against your application’s integration tests rather than selected by service count alone.
Limitations developers should understand
AWS Emulator is useful, but there are some important restrictions before adopting it in a project.
1. It doesn’t test IAM security policies
AWS Emulator does not evaluate IAM policies and resource-based permissions in the same way as actual AWS.
It operates with a simplified account model. You should continue testing IAM permissions, access policies, and security configurations against real AWS.
Never use AWS Emulator to validate your application’s security permissions.
2. Resources exist only in memory
The emulator stores resources in memory.
When you stop the emulator, its resources disappear. Restarting it gives you a clean environment.
This makes it suitable for repeatable test runs, but unsuitable for workloads that require persistent storage.
3. AWS compatibility varies by service
AWS Emulator aims to reproduce AWS behavior, but fidelity varies across services and operations.
AWS currently has stronger fidelity for control-plane operations, such as creating, describing, updating, and deleting resources.
Data-plane operations, such as uploading and downloading S3 objects, have varying levels of support.
Support for infrastructure-as-code tools such as Terraform, AWS CloudFormation, and AWS CDK also varies.
4. Region and account behavior is simplified
The emulator does not maintain separate resources for different AWS accounts and Regions.
It accepts account and Region information in requests, but resources aren’t isolated according to those values.
If you need to test multiple Regions, AWS recommends running separate emulator instances.
5. It isn’t designed for production workloads
AWS Emulator runs on your local hardware and has no production scalability or availability guarantees.
AWS also states that it hasn’t been tested for long-running usage or load testing.
Use it for development, prototyping, and automated tests. Continue validating production behavior against actual AWS infrastructure.
How to get started with AWS Emulator
The official repository provides installation instructions for Linux, macOS, and Windows.

Official documentation and installation instructions:
For developers who want to inspect the implementation, the source code is available here:
The project uses the CC0 1.0 Universal public domain dedication, with third-party code in its vendor/ directory licensed separately under Apache 2.0.
My take: What this means for developers
There are two things worth paying attention to in this release.
The first is the developer experience.
Local cloud emulation has been useful for years. Developers want to test integrations without repeatedly provisioning cloud resources. AWS bringing its own emulator into the ecosystem gives developers another option, particularly when working with AWS SDKs and AI coding agents.
I would consider AWS Emulator for local integration testing, especially in projects that use common AWS services. I’d still run a smaller set of integration tests against actual AWS before releasing changes.
The second point is the engineering process behind it.
AWS has demonstrated a development workflow in which autonomous agents generate implementation code, create tests, identify failures, and fix issues. Human engineers establish the system and its constraints, while automated checks control what gets merged.
That approach raises interesting questions about how software teams will organize development work.
If AI agents can maintain a growing codebase against continuously verified behavioral tests, developers may spend more time designing the system, defining correctness, and building the feedback mechanisms that keep autonomous work under control.
There is still a lot to evaluate. The emulator’s fidelity, maintainability, and behavior across real applications will matter much more than the novelty of its development process.
For now, AWS Emulator is worth experimenting with, particularly if you build applications using AWS and AI coding tools.
The project is open source, free to use, and available for developers to inspect.
One thing I’d like to see is how its fidelity evolves as more developers test it against real-world application workflows.
Thank You for Reading!
I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.
