Pick a local AWS emulator on service count and you have optimised the one axis that cannot help you. An agent calling an API the emulator does not implement gets a stub or the wrong error code, concludes its own code is wrong, and edits working code until the stub accepts it — and the suite goes green. The only axis that protects you from that is whether the project tells you what it gets wrong, and as of November 2026 exactly one of these four publishes per-service fidelity scores and a tracked list of its own gaps.
At a glance
AWS entered this market on 11 November 2026, which is what makes it a decision again. Star counts below are a proxy for ecosystem, not for quality, and are as of 13 November 2026.
| Project | Language / licence | Stars | Distinguishing claim |
|---|---|---|---|
aws/aws-emulator |
Rust, CC0-1.0 | ~5.9k | Publishes fidelity scores per service, per release |
localstack/localstack |
Python, Apache-2.0 + EULA | ~65.1k | The incumbent; deepest tooling ecosystem |
floci-io/floci |
Java, MIT | ~31.6k | Drop-in LocalStack replacement, no feature gates |
sivchari/kumo |
Go, MIT | ~1.5k | Single binary; ~17 MB image, ~0.12 s cold start |
Why service count is the wrong number
Every comparison of these tools leads with how many AWS services each one covers. The figure is nearly useless, for two independent reasons.
The first is that it is not a comparable quantity. "Supports S3" can mean the twelve operations your code calls with correct error semantics, or it can mean PutObject and GetObject returning 200. Each project defines a service as supported by its own standard, and none of those standards is the other's. Summing incommensurable units gives you a number with a false precision.
The second reason is specific to agents, and it is the one that should drive the decision. A human developer who hits an unimplemented API usually works it out — they have the context to think "this emulator probably doesn't do that." An agent does not have that prior reliably available, and it is strongly disposed to assume the failure is its own. So the loop runs like this:
The damage is not the wasted iteration. It is that the agent's edit is plausible — it adds a retry, loosens an assertion, catches an exception that real AWS never throws — and that edit lands in your repository, passes review because it looks defensive, and is still there when the code meets real AWS. A missing feature in an emulator is not an absence; with an agent in the loop it is an active source of changes to working code. That is the same hazard argued in staging environments for agents, where mocking a tool deletes exactly the error shapes you needed to see.
So the axis that matters is legibility of the gap: can your agent, or your harness, find out that this behaviour is unverified before the agent starts theorising? That turns out to be a short conversation, because only one project currently answers it.
AWS Emulator — the only one that publishes what it gets wrong
AWS's entry is a Rust workspace with one crate per service; the manifest on main lists 436 service members as of 13 November 2026. Each crate carries the service's Smithy model, which the repository describes as the thing that drives the wire protocol, plus a build.rs that generates the service declaration from it — so the request and response shapes are generated from AWS's own published spec rather than inferred.
The distinguishing feature is not the breadth, though. It is that fidelity is measured and published. Fidelity scores ship with each release, gaps live in an issues/things-that-do-not-work/ directory, and fixed items move to issues/things-that-now-work/. The tests behind the scores are a separate CC0 repository whose README states that every fidelity test was verified against at least two sandboxed AWS accounts and that behaviour no fidelity test covers is not verified. That sentence is the product. We unpack how AWS got there — and why the process does not transfer without an oracle — in the oracle was the hard part.
The costs are real and mostly operational. Building from source wants at least 100 GB of free disk for target/, since a debug build compiles every service crate; prebuilt Linux packages avoid that, and Windows and macOS go through a container. It serves HTTPS on 127.0.0.1:9297 with a self-signed certificate, so your SDK configuration needs the CA it writes rather than a plain HTTP endpoint — a small but real difference from the :4566 HTTP convention the others share. Telemetry is on by default. And it is days old: no accumulated Terraform recipes, no years of Stack Overflow answers.
There is an official agent skill — aws agent-toolkit add-skill --skill-name aws-emulator, needing AWS CLI 2.35.0 or later. Convenient, and it is also an agent-authored artefact from a repository that accepts no pull requests, so treat it the way you would any third-party skill: read it before you install it. See vetting a third-party skill.
LocalStack — the incumbent, and the feature gate
LocalStack is the reason this category exists: a fully functional local AWS stack, running as a single container, Python, around 65,000 stars. If you have an existing local AWS workflow, it is probably this, and the ecosystem advantage is not close — Terraform and CDK integrations, Testcontainers support, and a decade of accumulated answers to the specific thing that just broke.
The thing to understand before you point an agent at it is the tier split. The community edition is Apache-2.0 with an end-user licence agreement on top, and LocalStack's own README states that the Pro version supports additional APIs. That is a legitimate business model and it has a specific consequence for agent workflows: a gated API and a missing API are indistinguishable to the agent. It hits the endpoint, does not get real behaviour, and starts the loop in the diagram above. If you run the community edition, enumerate which of your services are Pro-only and tell the agent in its instructions, because it will not discover the boundary — it will theorise around it.
Pick LocalStack when breadth of ecosystem integration matters more than knowing your gaps: an established repository with Terraform fixtures, a team already fluent in it, or a dependency on one of its many non-AWS conveniences.
Floci — the drop-in with no gates
Floci is the interesting middle option: MIT, Java, around 31,600 stars, and positioned explicitly against the tier split — "No account. No auth token. No feature gates. Just docker compose up." It serves on http://localhost:4566, the same port and protocol as LocalStack, and the README offers it as a drop-in replacement: swap the image and keep going. Any published AWS region works, in every partition, and credentials can be any non-empty values unless you explicitly enable stricter per-service auth checks.
One design note worth more attention than it gets: the README says Floci uses real Docker containers where in-process emulation would reduce fidelity — naming stateful databases, connection-heavy protocols and runtimes. That is the right trade for the cases where fidelity matters most and it means your CI footprint is not a single container but a container that starts containers. Budget for that in a constrained runner.
Floci is also one of a family rather than a single tool: floci-az for Azure on 4577, floci-gcp on 4588, floci-oci on 4599. If your agent's integration tests span clouds, that consistency is a genuine reason to pick it over anything AWS-only.
Pick Floci when you want the LocalStack interface and ecosystem assumptions without the paid boundary, or when you need more than one cloud faked the same way.
Kumo — the one that actually fits in CI
Kumo is the smallest and the most honest about scope: a lightweight AWS emulator in Go, MIT, around 1,500 stars, 83 services. Its README publishes a footprint table measured on an arm64 Docker host with 4 CPUs and 8 GiB — a container image around 17 MB compressed (about 72 MB on disk), a ~44 MB single binary, a cold start of about 0.12 s from docker run to first API response, ~9 MiB idle memory, and about 20 MiB after a thousand S3 objects, a thousand SQS messages and a thousand DynamoDB items.
Those numbers are what a per-test-case emulator looks like, and that unlocks a pattern the heavier options cannot support: a fresh, empty emulator for every test, with no cross-test state to reason about. For agent work this matters more than it sounds, because shared mutable fixture state is a reliable way to make an agent's debugging loop incoherent — it fixes the test, the previous test's leftovers change, and it starts again. Optional persistence via KUMO_DATA_DIR covers the local-development case where you do want state to survive a restart.
The limit is breadth. Eighty-three services is a real surface — S3, DynamoDB and Streams, SQS, SNS, Lambda, ECS, EKS, RDS, Redshift and more — and it is far from all of AWS. Pick Kumo when your service dependencies are in that set and you care about CI minutes, test isolation, or running an emulator on a developer laptop without noticing.
When to pick which
| Situation | Pick | Because |
|---|---|---|
| An agent writes and verifies the code unsupervised | AWS Emulator | Only source of a per-service, per-release statement of what is unverified |
| Existing Terraform / CDK local workflow | LocalStack | Ecosystem depth; the fixtures already exist |
| Hitting the Pro boundary, or multi-cloud fakes | Floci | Same interface, no feature gates, sibling emulators per cloud |
| Per-test isolation, tight CI budget | Kumo | ~17 MB and ~0.12 s makes a fresh instance per test viable |
| Anything touching authorization or security | None of them | Emulators relax auth by design; AWS's docs exclude security testing explicitly |
Whichever you choose, do two things. Write the known gaps into your agent's instructions, so the first unimplemented call produces a stop rather than a theory. And keep one real-AWS integration run before anything merges, because every option on this page is a way to spend less on that run, not a way to delete it.
FAQ
Is AWS Emulator going to kill LocalStack?
Not on this evidence. It arrives with a published fidelity story and a broad generated surface; LocalStack arrives with a decade of integrations, recipes and institutional knowledge. The pressure is most likely on the Pro tier's value proposition, which is also where Floci was already pushing.
Can I run two emulators side by side?
Technically yes — they are all endpoint-configured, and Kumo's footprint makes it cheap to add. It is rarely worth it: two fakes means two sets of gaps, and your agent now has two ways to be confidently wrong. Prefer one emulator plus a real-AWS run.
Does an emulator remove the need to test against real AWS?
No, and treating it that way is the main failure mode. Emulators relax authorization, skip cross-region behaviour and approximate error semantics. They are for the fast inner loop; a real integration run stays on the critical path to merge.
Should the agent be told which emulator it is talking to?
Yes, explicitly, along with the known gap list for your services. An agent that knows it is on an emulator can attribute a strange error correctly; one that thinks it is on AWS will attribute it to your code.
Why do the star counts differ so much from the service counts?
Because stars measure adoption and age, not coverage. Kumo has the fewest stars and a published footprint table no one else offers; AWS Emulator has a fraction of LocalStack's stars and more generated surface than any of them. Neither number should decide this for you.
Further reading
On this wiki:
- The oracle was the hard part — how AWS Emulator was built, and what does not transfer.
- Staging environments for agents — why mocking deletes the failures you needed.
- Sandboxing and execution — where the emulator sits in the agent's runtime.
- Third-party tool drift — what happens when the fake and the real thing diverge.
- Vetting a third-party skill — before you install the official one.