AWS Emulator: a free local AWS that agents wrote and maintain
AWS released a CC0-licensed Rust emulator of 200+ services on 11 November 2026, built and updated by agents. How to run it, what it will not test, and what its published fidelity scores show.
AWS released AWS Emulator on 11 November 2026: a local program that answers the APIs of more than 200 AWS services on your own machine, so code and coding agents can create buckets, tables and queues without an AWS account or a deployment. It is free, written in Rust, and its source is on GitHub under the CC0 1.0 public domain dedication. The unusual part is who wrote it. “The emulator was written entirely by autonomous agents,” Matt Goldberg, the AWS senior principal engineer behind it, wrote in the launch story. “Our team hasn’t written or reviewed any of the code.”
For builders, the useful fact is narrower than the headline. AWS Emulator is a fast, local stand-in for the control-plane behaviour of AWS APIs, and AWS publishes how often it matches real AWS, service by service, with every release. It is explicitly not a way to test permissions, multi-account setups or long-running systems. By GenAI Brief’s count of those published scores, the emulator passed 56.5 per cent of its fidelity test units at launch and 69.8 per cent six days later, with wide variation between services.
AWS published four launch pieces on the same day: an AWS News Blog walkthrough, Goldberg’s account on About Amazon, a guest post by Swami Sivasubramanian on Werner Vogels’s All Things Distributed, and an AWS Insights essay by Matt Wood, AWS’s Chief AI and Technology Officer. This article draws on those, the user guide, the two GitHub repositories and the release assets. GenAI Brief did not install or run the emulator; the fidelity figures below are our tally of AWS’s own score files.
What AWS Emulator is
The user guide describes it as “a local emulator of the AWS APIs” for testing “on your own machine, on a development server, or in continuous integration (CI)”. It has no graphical interface. You start it, set environment variables so the AWS CLI or an AWS SDK sends requests to its endpoint instead of to AWS, and run your code unchanged.
It supports the APIs of services that have a model in the public AWS API models repository, the Smithy definitions the AWS SDKs are generated from. AWS’s launch pieces give the scale slightly differently: Sivasubramanian says it is built from “more than 400 API models covering more than 200 AWS services”, and Goldberg says the initial repository was an empty web server “that could handle requests for the 438 AWS API Models”. On 18 November the repository’s services/ directory held 436 per-service crates by our count.
Where an operation is implemented, AWS says it “aims for full fidelity: the same results as AWS for valid calls, and the same errors for invalid ones.” Where it is not, the emulator returns HTTP 501 with the error code NotImplemented, so a test that depends on it fails immediately rather than passing on a fake response. The user guide’s own example is a DynamoDB CreateTable call with the two-character name ab, which the emulator rejects with the same ValidationException message AWS returns. Resources persist for the life of the process: create a bucket, list buckets later, and it is there.
AWS positions it for three uses: local testing including cross-service calls, integration tests in CI pipelines without AWS resources, and “prototyping with AI coding agents”. Wood’s essay makes the agent case directly: “A coding agent can build a lot of software around an incorrect assumption. The sooner it can test that assumption, the sooner it can correct its work.”
What it costs and how it is licensed
AWS says the emulator “has no additional service fee”. The README says the software is under CC0 1.0 Universal “except the code in the vendor/ directory, which is under the Apache License 2.0”. CC0 waives copyright as far as the law allows, so the emulator can be forked, embedded in commercial tools or modified without attribution. Goldberg says the decision to release it as a public dedication was motivated by “the insights we’ve gained from this history”, meaning the commit and issue record of how the agents built it.
The repository does not take contributions. Its contributing guide says: “We don’t accept pull requests: AI agents keep the emulator up to date with AWS, with regular updates.” Users file issues instead, choosing between a “Behavior differs from AWS” form and a feature request form. The separate fidelity test repository is read-only and accepts neither issues nor pull requests.
How to run it
There are four documented ways in, and the right one depends mostly on your operating system.
| Path | Platforms | What you get | Notes from the documentation |
|---|---|---|---|
| Linux package | x86_64 or aarch64, glibc 2.17 or later (Amazon Linux 2 and 2023 named) | aws-emulator command in /usr/bin/, HTTPS on 127.0.0.1:9297 | RPM or Debian packages, signed; GPG verification steps documented |
| Docker | Windows, macOS, Linux | Same process in a container | No prebuilt image; build from AWS’s Dockerfile; publish the port on 127.0.0.1 only |
| Embedded mode | Rust tests with the AWS SDK for Rust | One isolated emulator per test, in process | Add the aws-emulator-embedded crate from GitHub, pinned to a release commit |
| AI coding agent skill | Any machine with AWS CLI 2.35.0 or later | Agent installs, starts and connects the emulator | aws agent-toolkit add-skill --skill-name aws-emulator --region us-east-1 |
Source: AWS Emulator User Guide, read 18 November 2026.
On Linux, the getting started guide installs the latest release with one command, for example sudo dnf install -y against the x86_64 RPM on downloads.aws.com. Started with aws-emulator, it serves HTTPS on 127.0.0.1:9297 with a self-signed certificate. AWS says it uses about 160 MiB of memory when idle and grows as tests create resources, and shows how to cap it at 2 GiB with a systemd scope.
On macOS and Windows the Docker guide is the only route. It warns against the short port syntax: “Use -p 127.0.0.1:9297:9297, not -p 9297:9297. The short form opens the emulator to your whole network.”
Pointing your code at it
When it starts, the emulator generates its own access key, a config file and a certificate under ~/.aws/emulator/9297/. The SDK guide then has you export eight variables in the shell that runs your code:
export AWS_ENDPOINT_URL=https://127.0.0.1:9297
export AWS_SHARED_CREDENTIALS_FILE=~/.aws/emulator/9297/emulator_credentials
export AWS_CONFIG_FILE=~/.aws/emulator/9297/config
export AWS_CA_BUNDLE=~/.aws/emulator/9297/ca.pem
export AWS_EC2_METADATA_DISABLED=true
export AWS_DISABLE_HOST_PREFIX_INJECTION=true
export AWS_REGION=us-east-1
export AWS_DEFAULT_REGION=us-east-1
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_PROFILE
Three details in that guide are easy to get wrong:
- Real credentials. “If
AWS_ENDPOINT_URLisn’t set in the shell that runs your tests, your code calls AWS with whatever credentials it finds.” AWS’s advice is to set the variables in the same script that runs the tests. A quick check:aws sts get-caller-identityshould return the emulator’s single account,000000000000. The News Blog adds that emulator access key IDs start withEMULATOR. - Host names. Some SDK calls add a prefix to the endpoint host, such as
data-for Cloud MapDiscoverInstances, which turns127.0.0.1into a host that does not exist. HenceAWS_DISABLE_HOST_PREFIX_INJECTION, which AWS warns breaks those operations on real AWS if left set. S3 Control requests always put the account ID in the host name, so, the guide says, they “don’t reach the emulator”. Usinglocalhostinstead of127.0.0.1makes several SDKs put S3 bucket names in the host name, which the emulator rejects. - Certificates. The CLI, Boto3 and the Go SDK read
AWS_CA_BUNDLE. Node.js needsNODE_EXTRA_CA_CERTS, Java a trust store passed throughJAVA_TOOL_OPTIONS, Rust and .NETSSL_CERT_FILE. Most of these replace the default trust store, so a process that must reach both the emulator and real AWS needs a combined bundle.
A health endpoint, /__admin/health on the same port, returns ok, and the guide gives a 30-second wait loop for CI scripts.
Embedded mode
For Rust projects, embedded mode compiles the emulator into the test binary. Each AwsEmulatorEmbedded instance has its own state, so tests can run in parallel without sharing buckets or tables, and the SDK is wired to the emulator’s HTTP client with no endpoint or certificate. Authentication is off by default in this mode. The cost is build size: the README says building from source needs “at least 100 GB of free disk for target/” because there is one crate per AWS service, and recommends caching target/ in CI and pinning a release commit.
What it will not do
AWS’s limitations list is unusually specific, and most of it follows from the design: an in-memory, single-process stand-in checked against one Region.
| Limitation | What AWS’s documentation says |
|---|---|
| Security policies | Does not evaluate IAM policies and resource-based policies the way AWS does. “The emulator never denies a request signed with its own key.” Does not check KMS key policies or S3 bucket policies. |
| Accounts and Regions | Accepts any Region and account ID but does not keep resources separate by either. Run one emulator per Region, each on its own port. |
| Verification Region | Behaviour checked against AWS in US West (Oregon) only, or US East (N. Virginia) for global services. Regional differences are not reflected. |
| Persistence | All resources in memory; deleted when the emulator stops. |
| Duration and load | Not tested for long-running use or load testing; AWS suggests --idle-timeout. |
| Fidelity | Varies by service and feature; closest for control-plane APIs. Data-plane behaviour and CloudFormation, Terraform and CDK support vary by service. |
| Executed code | Function code the emulator runs “with your user’s permissions and can read and change your files”. |
| Security fixes | Published only in the latest release; older releases get none. |
Source: AWS Emulator User Guide, “What is AWS Emulator?”, “Security” and “Versions and compatibility” pages, read 18 November 2026.
The security page states the consequence plainly: “Don’t use AWS Emulator to test whether your application is secure. Passing tests in the emulator don’t show that your permissions are correct or safe.” A request AWS would deny may succeed, and one AWS would allow may fail. For teams that use local tests as evidence in a review, that sentence should be in the review template.
The page also lists what AWS built in to protect the developer’s machine. The emulator listens only on 127.0.0.1 by default, rejects unsigned requests (except operations AWS itself serves unsigned) and requests signed with keys other than the ones it generated for that run or created through its own IAM or STS, writes its credentials file readable only by the user, and deletes its files on a clean stop. Some resources, such as databases, get their own port, and those ports “don’t check request signatures”. Starting with --auth off turns signature checks off entirely.
Telemetry is on by default
The emulator reports usage to AWS unless told not to. The telemetry page says records include random installation and run IDs, operating system and CPU type, SDK and version, Region, per-operation call counts and outcome categories, response-time minimum, maximum and total, peak memory (as a range) and throughput, and “which AI coding assistant drives the emulator, if any.” AWS says it never collects request or response contents, resource names, ARNs, credentials, code, raw error messages or account IDs, does not share the data with third parties, and keeps it for up to 90 days. It can be turned off per run with --telemetry off, per shell with EMULATOR_TELEMETRY=off, or per machine in ~/.aws/emulator/config.toml. The README asks anyone who embeds the emulator in a tool for others to tell their users about it.
What “built by agents” is documented to mean
AWS’s claim has two parts, and the documents support both with different levels of detail. The first is that no human wrote or reviewed the emulator’s code. The second is that humans built everything around the code that decides whether it is correct.
Where it started
Goldberg says the idea came from Anthropic’s demonstration that agents could build a C compiler, which suggested that “if given a well-defined spec and a reference implementation, agents can autonomously build a solution that faithfully implements the specification.” AWS had both: the API models as the spec, the AWS cloud as the reference. He gave Kiro, AWS’s coding agent, a three-step prompt: write tests based on the AWS CLI, iterate on them until they pass against real AWS, then build an in-memory implementation that passes the same tests. “Kiro came back after 15 minutes with a passable first version of an Amazon Simple Queue Service (Amazon SQS).” He then “had Kiro build me the rest of AWS over the weekend”, with gaps, and his team started using it the following Monday. Sivasubramanian adds that an internal version “started gaining adoption within a month”.
Three teams and a merge gate
The production system divides the work into three bounded jobs, which Goldberg says is because agents “have more success on bounded tasks”:
| Team | Job | Output |
|---|---|---|
| Test writers | Devise real-world scenarios from the public API models and verify each against real AWS | Fidelity tests, “tens of thousands” across AWS, replayable without calling AWS |
| Issue finders | Replay the tests against the emulator, reason about failures, group shared root causes | Issues in issues/things-that-do-not-work/ |
| Fixers | Take one issue each, root-cause it, edit until fixed | Changes submitted to the merge gate |
Source: Goldberg, About Amazon, 11 November 2026.
The merge gate is the control AWS leans on most. It blocks code that does not compile and includes “agents that review against coding standards, verify the code is secure, and ensure that the change did not regress fidelity.” Failed checks send the change back for rework. Goldberg says “thousands of issues fixed every day as hundreds of agents concurrently work on the codebase”, and that “without this merge gate, we wouldn’t trust what our agents are building.” Sivasubramanian describes the same guardrails as fidelity tests verified against real AWS, “a merge gate with multiple security agents that each review a change for different ways to attack it alongside a general code reviewer”, and “deterministic checks that stop agents from touching code they are not supposed to.”
The repository’s AGENTS.md shows what those deterministic boundaries look like in practice: agents work in one crate per service, the vendor/ framework is “agent-immutable”, generated router files are re-rendered and not to be edited, and Smithy @auth traits must be left as shipped so that an operation is unsigned “only when the model makes it so.”
The News Blog fills in the infrastructure. AWS says the agents run on Amazon Bedrock AgentCore Runtime Instances, with AWS CodePipeline and AWS CodeCommit as the pipeline and primary repository. One group finds gaps “both by comparing emulator responses against real AWS and by statically comparing the emulator’s code against the published Smithy models”. A push triggers a pipeline that runs the fidelity tests before anything reaches GitHub, and “an independent security agent reviews changes adversarially, both while the fix is being made and again in the release pipeline”. Goldberg says code is published to GitHub “only at the end of the release process”.
What the human work actually was
Neither account claims humans were absent. Sivasubramanian’s framing is that “the engineer’s job is to give them room to work on their own and to build the specs, tests, and merge gates that decide when that work is correct.” He illustrates it with his own experience rebuilding the replication engine of Alf, an early Amazon Paxos-based lock service: he supervised Kiro “for four nights before I saw that it had no way to check its results. Once it had a spec and a test environment, the rebuild took about two hours.”
Goldberg also records a failure mode the guardrails had to correct. In an earlier version, the agents “decided to build their own Python interpreter to support AWS Lambda functions”; the team has “since given them guidance to reuse existing libraries”.
What the documents do not include is any independent audit of the code. “No human reviewed it” is AWS’s statement about its process; the evidence that the process works is the fidelity record and the issue history, both public. Goldberg says later posts will cover the multi-agent architecture, how fidelity is measured and how the quality and security bar is enforced.
What the fidelity scores show
AWS’s fidelity page defines a fidelity test as “a short program that uses an AWS SDK to run a workflow against an AWS service and assert how AWS behaves”. The emulator passes only “when its behavior matches AWS for every call in the workflow, including the status code, the resources that it creates, and other side effects”, and for errors, only if it returns the same error. The public evaluation suite holds the tests as Python Boto3 programs, says each was “verified against at least two sandboxed AWS accounts”, and ships a runner that only accepts a loopback endpoint.
Each GitHub release carries a scores.json.gz file. GenAI Brief downloaded two: v1.0.322, scored at 00:09 UTC on 11 November, the last release before launch, and v1.0.492, scored at 13:50 UTC on 17 November. Each file lists test units with an outcome of pass, fail or skipped and the services they touch. Our counts:
| Release (scored) | Units | Passed | Failed | Skipped | Pass rate |
|---|---|---|---|---|---|
| v1.0.322 (11 Nov 2026) | 42,937 | 24,243 | 18,614 | 80 | 56.5% |
| v1.0.492 (17 Nov 2026) | 46,026 | 32,139 | 13,800 | 87 | 69.8% |
GenAI Brief tally of AWS’s published scores.json files. The files label units “behavioral” (62.8% passing in v1.0.322, 75.9% in v1.0.492) or “wire” (36.8% and 51.3%); AWS’s documentation does not define the “wire” label.
AWS’s own scoring is per service, not overall, and the fidelity page warns: “Compare scores only when they use the same version of the fidelity tests.” The two files do not state which test version they used, and the unit count grew by 3,089 between them, so the comparison is indicative rather than like for like. It still shows a direction: 7,896 more passing units and 4,814 fewer failing ones in six days, consistent with AWS’s description of updates “many times a day”. The GitHub releases list shows tags from v1.0.250 on 7 November to v1.0.492 on 17 November.
Per service, the spread is wide. These counts use only units that touch a single service:
| Service | Pass rate at v1.0.322 | Pass rate at v1.0.492 | Units at v1.0.492 |
|---|---|---|---|
| Amazon SNS | 73.9% | 94.6% | 296 |
| AWS KMS | 93.9% | 90.7% | 335 |
| AWS Secrets Manager | 79.0% | 89.8% | 236 |
| Amazon EventBridge | 83.2% | 89.0% | 308 |
| Amazon S3 | 79.1% | 88.0% | 1,295 |
| Amazon Cognito user pools | 72.3% | 85.3% | 856 |
| AWS IAM | 70.5% | 85.0% | 727 |
| Amazon API Gateway | 74.2% | 83.4% | 823 |
| Amazon SQS | 89.8% | 82.5% | 359 |
| AWS Step Functions | 73.3% | 79.9% | 626 |
| Amazon DynamoDB | 77.3% | 75.4% | 2,100 |
| Amazon ECS | 58.7% | 71.0% | 639 |
| AWS Lambda | 46.4% | 60.5% | 810 |
| Amazon RDS | 46.4% | 59.7% | 516 |
| Amazon EC2 | 41.5% | 59.0% | 1,816 |
| AWS CloudFormation | 15.8% | 17.8% | 2,639 |
GenAI Brief tally of single-service units in AWS’s scores files. The falls for KMS and DynamoDB come with new tests in the file, which AWS says can expose existing gaps. SQS is different: matching unit IDs across the two files, 18 SQS units that passed at v1.0.322 failed at v1.0.492 (301 across all services), although AWS says passing tests “don’t regress”. AWS also says it can rebuild or update a test within a version; the files do not say which applies.
Two readings follow. The core building blocks of a typical serverless application, S3, SNS, EventBridge, Secrets Manager and KMS, pass roughly nine in ten of their tests, and IAM’s 85 per cent measures its API behaviour in those tests, not policy evaluation, which AWS says the emulator does not perform the way AWS does. Infrastructure as code is the weak spot: under one CloudFormation test in five passes, which matches AWS’s statement that CloudFormation, Terraform and CDK support “varies by service”. A team whose test setup creates its environment from a CloudFormation template should expect trouble before its application code runs.
The project check page gives the procedure for a specific application: list the operations it calls, find their tests in manifest.jsonl in the evaluation suite, check the scores for those services, and for operations no test covers, run your own tests against both the emulator and AWS. The aws-emulator agent skill automates that check. AWS’s caution applies: “If no fidelity test covers a behavior, the emulator might already handle it correctly, but no fidelity test confirms it yet.”
Where it fits, and for whom
Developers already have local AWS stand-ins. InfoQ names LocalStack, Floci and moto, and concludes that AWS Emulator “is not a drop-in replacement for every workflow those tools cover, especially permission testing and infrastructure-as-code pipelines.” What AWS Emulator adds is provenance and transparency: it is generated from the same models as the SDKs, its gaps are published as tests and issues, and its licence imposes no conditions.
For agent builders, Wood’s essay names a less obvious use. Local environments make it cheaper to evaluate and train agents across many tasks, including with reinforcement learning. He also names the risk: “If the emulator accepts behavior that AWS rejects, training can reinforce a mistake. An agent might also discover a shortcut that succeeds only because of an emulator defect.” The per-service scores are therefore not just a developer convenience; they are the boundary of what such an environment can safely reward. Teams sandboxing agents more broadly may find our coverage of OpenShell’s deny-by-default agent runtime useful as a complement, since the emulator isolates AWS calls, not the agent’s own process.
Some scenarios, read against the documentation:
- A team testing a Lambda that writes to DynamoDB and publishes to SNS. A good fit for the data paths, with SNS and DynamoDB scores high. Lambda passed six in ten tests on 17 November, so the function invocation path needs its own verification, and the function code runs with the developer’s permissions.
- A platform team validating an IAM permission boundary. Not a fit. AWS says so explicitly.
- A CI pipeline that deploys a CDK stack and runs integration tests. Likely to stall at the stack, given CloudFormation’s score. Create resources with SDK calls in test setup instead, or keep that stage on a real sandbox account.
- A coding agent iterating on SQS-consumer logic. The use AWS designed for. Wood’s example is an agent discovering, locally, that it mishandles a conditional-write rejection on a duplicate message.
For context on how AWS is positioning agent tooling more broadly, our report on AgentCore’s web search API covers another part of Amazon Bedrock AgentCore, the platform whose Runtime the emulator’s own agents run on.
What to do
- Pin a version. Updates arrive many times a day, and AWS’s versioning page says a fix that brings a response closer to AWS can break tests that relied on the old one. Install a specific package version from
versions.json, upgrade deliberately, and remember that only the latest release gets security fixes. - Check your services before you adopt it. Read the scores for the release you pin, and look up your operations in the evaluation suite’s manifest.
- Make the endpoint impossible to miss. Set the variables in the test script itself, unset real credentials, and assert
000000000000fromsts get-caller-identitybefore the suite runs. - Keep security testing on AWS. Treat a green emulator run as evidence about behaviour, never about permissions.
- Decide on telemetry. It is on by default, including a field for which coding assistant is driving it.
- Keep real tests on real AWS for the APIs that matter most, as AWS itself recommends.
AWS Emulator is the most concrete public example so far of a large vendor shipping software it says no human wrote, and it comes with the evidence to judge the claim: every test, every score and every open gap is in public. On that evidence it is a good local mock of the common control-plane paths and a poor one for infrastructure as code. Whether “no human reviewed it” becomes a selling point or a liability will depend on the scores, not the slogan.
Sources
- Test your applications against AWS locally with AWS Emulator AWS News Blog
- AWS Emulator: a local emulator built 100% by autonomous AI agents Amazon
- AWS Emulator and the engineer's job when agents write the code All Things Distributed
- Better feedback for building with agents AWS Insights
- aws-emulator repository Amazon Web Services on GitHub
- aws-emulator releases and fidelity scores Amazon Web Services on GitHub
- aws-emulator-evaluation-suite repository Amazon Web Services on GitHub
- What is AWS Emulator? AWS Emulator User Guide
- Fidelity in AWS Emulator AWS Emulator User Guide
- Security in AWS Emulator AWS Emulator User Guide
- Getting started on Linux AWS Emulator User Guide
- Getting started with Docker AWS Emulator User Guide
- Pointing your AWS SDK at AWS Emulator AWS Emulator User Guide
- Getting started with embedded mode AWS Emulator User Guide
- Versions and compatibility in AWS Emulator AWS Emulator User Guide
- Telemetry in AWS Emulator AWS Emulator User Guide
- Getting started with an AI coding agent AWS Emulator User Guide
- AWS API models Amazon Web Services on GitHub
- AWS Open-Sources Emulator for Local Testing of 200+ Services by Coding Agents InfoQ
- AWS gives developers a free local stand-in for its cloud, built from scratch by AI agents GeekWire
Frequently asked questions
Is AWS Emulator free?
Yes. AWS says it has no additional service fee and that you pay only for AWS resources when you deploy on AWS. The source code is dedicated to the public domain under CC0 1.0, except the vendored framework code in the vendor/ directory, which is under the Apache License 2.0.
Can I run AWS Emulator on a Mac or Windows machine?
Only in Docker. The emulator runs natively only on Linux, from RPM or Debian packages for x86_64 or aarch64. AWS does not publish a prebuilt image; its documentation gives a short Dockerfile that installs the Linux package, and tells you to publish the port on 127.0.0.1 only.
Can I use AWS Emulator to test IAM policies?
No. AWS says not to use it to test security. It does not evaluate IAM policies, resource-based policies, KMS key policies or S3 bucket policies the way AWS does, never denies a request signed with its own key, and does not support cross-account or cross-Region calls. A request AWS denies might succeed in the emulator.
What does 'built by agents' mean for AWS Emulator?
AWS says its team has not written or reviewed any of the emulator's code. Agents write fidelity tests from AWS's public API models and verify them against real AWS, other agents replay them to find gaps, and others fix each gap. Humans built the specifications, test machinery, merge gate and release pipeline around that work.
How closely does AWS Emulator match real AWS?
It varies by service. AWS publishes per-service fidelity scores with each release. GenAI Brief's count of the scores file for v1.0.492, scored on 17 November 2026, found 69.8% of test units passing overall, about 75 to 95% for core services such as S3, DynamoDB, SQS, SNS and KMS, and 17.8% for CloudFormation.
How is AWS Emulator different from LocalStack or moto?
AWS says it is generated from AWS's own API models, ships official per-service fidelity scores and is in the public domain. InfoQ notes it is not a drop-in replacement for every workflow existing tools cover, especially permission testing and infrastructure-as-code pipelines, where AWS's own documentation says fidelity varies.
Does AWS Emulator send my data to AWS?
AWS says it does not send requests, responses or resource data to AWS. It does send anonymous usage telemetry by default, such as per-operation call counts and error categories, which AWS says it keeps for up to 90 days. Telemetry can be turned off with --telemetry off, the EMULATOR_TELEMETRY variable or a config file.


