AWS Emulator Is Live: Free Local AWS Built Entirely by AI Agents

On November 11, 2026, Amazon Web Services did something it had refused to do for a decade: it shipped its own local copy of AWS. AWS Emulator is a free program that runs the AWS APIs on your laptop, answers the same calls the real cloud would, and costs nothing to use. You do not need an AWS account, and you do not need a credit card. The twist is who built it. According to AWS, every line of the emulator was written and tested by AI agents, and no engineer on the team wrote or reviewed the code.

That makes this launch two stories at once. The first is practical: developers and coding agents can now test AWS work locally, without deploying anything or watching a bill. The second is a proof point for agent-built software, delivered by the company that sells the cloud itself. Both stories come with limits that matter, and AWS is unusually open about them. This article covers what the emulator does, what it costs, how to run it, and where it will mislead you if you trust it too far.

What AWS Emulator actually is

AWS Emulator is a local program that serves an AWS API endpoint on your own machine. You install it, start it, and point the AWS CLI or an AWS SDK at its local address instead of the real cloud. Your application code stays unchanged. A test that creates a DynamoDB table, writes an item, and reads it back is the same test you would run against AWS, except it runs on your laptop and touches nothing billable.

The emulator is written in Rust, which AWS says keeps CPU and memory use low on a laptop. It serves HTTPS on 127.0.0.1:9297, so only your own computer can reach it. When it starts, it generates its own credentials, a config file, and a certificate, and writes them to ~/.aws/emulator/9297/. The access keys it issues start with EMULATOR, so you cannot mistake them for real AWS keys, and it rejects requests signed with any other keys. It uses a single account, 000000000000.

Coverage is the headline number. AWS says the emulator is generated from more than 400 Smithy API models covering more than 200 AWS services. Smithy is the same interface language the official AWS SDKs are built from, so requests and error responses have the same shape as production. That is the design bet: because the emulator is generated from the same models as the SDKs, a call that works locally should behave the same way in the cloud, at least for the operations the emulator has implemented.

There is also an embedded mode for tests. Instead of running a separate server, you add the emulator as a development dependency in a Rust project and run it inside the test process, with one isolated instance per test. Each instance keeps its own state, so tests do not share buckets, tables, or queues, and you can run many of them in parallel. Embedded mode is available for the AWS SDK for Rust.

What it costs: nothing, with one honest caveat

AWS Emulator has no additional service fee. That is the exact wording on the AWS News Blog, repeated twice in the announcement: you pay only for AWS resources when you deploy on AWS. There is no account to create, no free-tier clock to watch, and no per-request charge while you test. The software itself is dedicated to the public domain under the CC0 1.0 license, which means there are effectively no licensing restrictions on using, modifying, or redistributing it.

The caveat is the word "additional." The emulator is free, but the cloud it imitates is not. The moment your code leaves the laptop and provisions real resources, normal AWS billing applies. That is the whole point of the tool: it moves the trial-and-error loop off the meter, not the deployment itself. A coding agent that creates resources, checks the result, and iterates can now do dozens of rounds locally before a single real API call is made.

The comparison that matters most is LocalStack, the third-party tool that has been the default local AWS for years. In February 2026, LocalStack retired its open-source Community Edition, folding it into a single account-based image. Its pricing page now lists a Hobby plan that is free for non-commercial use, and a Base plan at $29 per license per month for commercial development, with 55+ emulated services and a personal sandbox per developer. At November 13, 2026 exchange rates, that $29 is about £21.90 or CA$41.30, as an approximation. AWS Emulator undercuts that on price and on coverage breadth, and it carries no commercial-use restriction. The trade is maturity: LocalStack has years of production use behind it, while AWS Emulator is two days old and still filling in gaps.

There is also a cost that does not show up on any price page: disk space. Building the emulator from source needs at least 100 GB of free disk, because the workspace holds one Rust crate per AWS service. Most users will never pay that cost, since they install a prebuilt package instead, but anyone using embedded mode compiles the emulator into their test binary and should budget the same order of build time and disk. Pinning a release and caching the build directory keeps that cost from repeating on every run.

How to run it

On Linux, you install an RPM or Debian package and run aws-emulator. The AWS News Blog walks through the Amazon Linux 2023 install, where the package adds the command to /usr/bin/ and aws-emulator -v confirms the version. On macOS and Windows, you build a Docker image from a short Dockerfile in the documentation and run the emulator in a container. AWS does not publish a ready-made image, which is worth knowing before you start.

Once the emulator is running, you point your tools at it with environment variables. The blog's example sets AWS_ENDPOINT_URL to https://127.0.0.1:9297, points the shared credentials and config files at the ones the emulator generated, and unsets any variables that could supply real AWS credentials. That last step matters: if a real key is still in the environment, a command meant for the emulator could reach the real cloud instead.

There is also a shortcut for agent-driven setups. If you use an AI coding agent, you can install the aws-emulator skill and ask the agent to set up the emulator for you. That path needs AWS CLI version 2.35.0 or later. It is a small detail, but it shows who AWS built this for: not just developers typing commands, but coding agents that iterate on AWS work by themselves. AWS names Kiro and Claude Code in the announcement as the kind of tools the emulator is meant to serve.

To check that your shell is talking to the emulator, the blog suggests the health endpoint at https://127.0.0.1:9297/__admin/health and the aws sts get-caller-identity command, which should report the single fake account. From there, ordinary commands work as usual: create a bucket, copy in an object, list it. The emulator answers with the same shapes as AWS, including the same error codes for invalid calls.

Built entirely by agents

The most unusual fact about AWS Emulator is its authorship. AWS says the emulator is built and maintained by agents, using Amazon Bedrock AgentCore runtime instances, AWS CodePipeline, and AWS CodeCommit, so it stays current as the API models change. Senior Principal Engineer Matthew Goldberg, who started the project, has said the emulator was written entirely by autonomous agents and that the team has not written or reviewed any of the code. The project began as an experiment: Goldberg prompted the Kiro coding agent to reproduce Amazon SQS from its public Smithy model, then scaled the approach to the whole API surface.

The workflow runs in three agent teams. One group looks for gaps, both by comparing emulator responses against real AWS and by statically comparing the emulator's code against the published Smithy models, and files an issue for each gap it finds. Another group picks up an issue, writes tests, implements the behavior, and reviews the change. A third layer, an independent security agent, reviews changes adversarially while the fix is being made and again in the release pipeline before anything ships. When a change is ready, a CodePipeline run executes the fidelity tests before the change is published to the public GitHub repository. The post adds one more guardrail: deterministic checks that stop agents from touching code they are not supposed to.

The idea started small. Goldberg began with SQS alone, and one prompt to Kiro returned a passable first SQS emulator in about 15 minutes. An internal version came together over a weekend and started gaining adoption within a month. Swaminathan Sivasubramanian, the guest author of the launch essay, draws the same lesson from his own experiment: rebuilding a replication engine that took four months the first time took about two hours once the agent had a spec and a test environment.

The pace is visible in the repository itself. The repo was created in September 2026, and by launch week it held close to 3,000 stars; by November 13 it had passed 6,600 stars with 245 forks, according to the live GitHub API. Simon Willison counted 29,684 commits in the project's first three weeks. New releases land daily: version 1.0.343 was already published on November 13, two days after the announcement. The commit history and the issue backlog are public, including a directory of behaviors that do not work yet.

None of this proves the code is good. It proves the process is transparent. Anyone can read the commit history, run the fidelity tests, and see exactly which operations are missing. That transparency is doing real work here, because the "written by agents" claim invites a question AWS cannot answer with marketing: is agent-written infrastructure code safe to run? The answer AWS offers is the review pipeline, not a promise.

How close is it to real AWS?

An emulator is only useful if a test that passes against it would also pass against AWS, so AWS measures that directly with fidelity tests. A fidelity test is a short program that uses an AWS SDK to run a workflow, such as storing an object and then reading and deleting it, and asserts how AWS behaves. Each test is 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, expressed as k of n. For example, 40 of 50 means 40 of that service's 50 fidelity tests pass. The test set is public in a separate 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. AWS warns that a score is a snapshot of a product that is improving, and that when new tests are added, a score can go down even while the emulator gets better.

What the launch coverage does not provide is a single overall fidelity number, and that absence is worth stating plainly. No source quoted a per-service score at launch, and the per-service scores vary. If the emulator does not implement an operation yet, it returns HTTP 501 (Not Implemented), so your tests fail right away instead of silently succeeding. That is a deliberate design choice, and a good one: a loud failure beats a quiet lie. Individual gaps are tracked in the repository's issues directory, under issues/things-that-do-not-work/, with fixed items moved to issues/things-that-now-work/.

The limits that matter

AWS is unusually direct about what the emulator cannot do, and the limits are not footnotes. 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. That single fact rules out the most dangerous use case: 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 behavior. It accepts any Region and account ID you configure, but it does not keep resources separate by them. Anything that depends on multi-account architecture, cross-Region replication, or Region-specific behavior will not be tested faithfully.

Third, telemetry is on by default. The emulator collects and reports anonymous usage and error data to AWS. According to the README, the records never include request or response contents, code, credentials, or personal data, and AWS says it does not share telemetry with third parties. You can turn it off with aws-emulator --telemetry off, the EMULATOR_TELEMETRY=off environment variable, or a config file setting. If you run the emulator in CI, decide on telemetry before your first pipeline run, not after.

Fourth, the emulator is for building and testing, not for production workloads. AWS states this in the README and the announcement alike. It is also not tested for long-running use or load testing, according to launch coverage. Treat it as a test harness, not a private cloud.

Who should use it, and who should skip it

The clearest fit is a developer or team whose coding agent writes AWS code. The agent can create resources, check the result, and iterate locally without waiting on a deployment or spending real money. The same loop helps any team with a slow or expensive test suite: integration tests that once needed a sandbox account and cleanup scripts can now run on a laptop or in CI with no account at all. It also fits the other end of AWS's agent push: AWS Infinity, the company's runtime for running tens of thousands of agents on minimal hardware, shows the same bet that agents are the next big AWS workload, and the emulator is how those agents get tested before they touch real infrastructure.

It also fits anyone learning AWS. A student can create buckets, tables, and queues, make mistakes, and delete everything by stopping a process, with no bill and no account to secure. That is a real improvement over the usual advice to new learners, which is to watch the free tier and set a billing alarm.

Skip it if your tests depend on IAM behavior, cross-account access, or cross-Region features. Skip it if you need a production stand-in, a load-testing target, or a security audit. And skip the embedded Rust mode unless you are already working in Rust: the 100 GB build cost is a poor trade for a quick experiment when the prebuilt package or Docker path will do.

Common mistakes to avoid

The first mistake is leaving real credentials in the environment. The emulator generates its own keys for a reason. Unset AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_SESSION_TOKEN before pointing tools at the local endpoint, or a command can escape to the real cloud. The News Blog's setup example includes exactly those unset commands, and they are not optional.

The second mistake is reading a green test suite as proof of production readiness. A test that passes against the emulator proves the code works against the emulator's current fidelity level, not against AWS. Check the per-service fidelity score for the services you use, and run the same suite against a real account before you ship.

The third mistake is treating the 501 response as a bug. It is the emulator telling you, honestly, that an operation is not implemented yet. Check the public backlog before working around it: the operation may already be on the agents' list, and a newer release may have it.

The fourth mistake is forgetting telemetry. It is on by default and sends data to AWS. That is acceptable for many teams and unacceptable for some. Make the choice deliberately, and record it in your setup docs so the next person on the team does not have to guess.

Is AWS Emulator really free?

Yes. AWS says the emulator has no additional service fee, and its source is dedicated to the public domain under CC0 1.0. You pay only for AWS resources when you deploy on AWS. There is no account, no subscription, and no per-request charge while you test.

Do I need an AWS account to use it?

No. The emulator runs on your machine, generates its own credentials, and uses a single fake account, 000000000000. You can test AWS code without ever creating an AWS account.

Which AWS services does it cover?

More than 200 services, generated from over 400 Smithy API models, according to AWS. Coverage varies by service and operation, and AWS publishes a per-service fidelity score with each release, so check the score for the services you use.

Can I use it to test my IAM policies?

No. The emulator does not evaluate IAM policies the way AWS does, so a request AWS would deny might succeed locally. AWS says explicitly not to use it to test whether an application is secure.

How is it different from LocalStack?

LocalStack is the established third-party local AWS, with a free Hobby plan for non-commercial use and paid plans from $29 per license per month. AWS Emulator is official, free with no commercial-use restriction, covers more services, and is built and maintained by AI agents. LocalStack has years of maturity behind it; AWS Emulator launched on November 11, 2026.

Does it send data back to AWS?

By default, yes. The emulator collects anonymous usage and error data, but not request or response contents, code, credentials, or personal data, according to its README. You can turn telemetry off with a command-line flag, an environment variable, or a config file setting.

AWS Emulator is a small download with a large implication. AWS has handed developers a free, official, public-domain copy of its own API surface, and it had AI agents build it. The tool is useful today for local development and agent-driven testing, and limited in exactly the places AWS says it is. Use it to move the trial-and-error loop off the meter, check the fidelity scores for the services you depend on, and never let a green local test stand in for a real security review. The emulator will keep improving daily, but the discipline around it is yours to supply.

Sources: AWS News Blog — Test your applications against AWS locally with AWS Emulator (November 11, 2026, updated November 12); All Things Distributed — AWS Emulator and the engineer's job when agents write the code (November 11, 2026); AWS Emulator on GitHub; AWS Emulator User Guide; LocalStack pricing; Kevin Hermes — The Cloud Now Fits On Your Hard Drive; Sam Codeman — AWS Emulator: 100 GB embedded builds, no fidelity scores. Exchange rates: 1 USD = 0.7551 GBP and 1.4243 CAD on November 13, 2026, verified at publication; GBP and CAD figures are approximations.