AWS Emulator vs LocalStack vs Floci vs Kumo

AWS shipped its own local emulator on 11 November 2026, so pointing a coding agent at a fake AWS is now a four-way choice. Everyone compares service counts, and service count is the wrong number: an agent cannot tell a gap in the emulator from a bug in your code, so a missing API becomes an edit to code that already worked, and the suite goes green anyway. The number to choose on is whether the project publishes what it gets wrong — per-service fidelity scores and a tracked gap list — and exactly one of these four does. Here is where each of the others still wins: ecosystem, no feature gates, and a 17 MB image that cold-starts in about a tenth of a second.

By Agentic AI Wiki 11 min read

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.

ProjectLanguage / licenceStarsDistinguishing 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
Four local AWS emulators across four axes A matrix with four projects as rows and four axes as columns. AWS Emulator is the only one that publishes per-service fidelity scores and a tracked gap list, and it has the broadest surface but the heaviest build. LocalStack has the most mature ecosystem but gates some APIs behind its paid tier. Floci matches LocalStack's interface with no feature gates. Kumo has the smallest surface and by far the lightest footprint. Where each one leans hardest PUBLISHED GAPS BREADTH CI FOOTPRINT ECOSYSTEM AWS Emulator Scored per release 436 crates Heavy build Days old LocalStack Not published Pro tier gated One container Mature Floci Not published No feature gates One container Growing fast Kumo Not published 83 services ~17 MB, ~0.12 s Small Leads this axis Adequate Trails this axis
Nobody leads on more than two axes, and the first column has only one entry in it.

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:

How an unpublished emulator gap turns into a change in your own code A four-step chain with a return arrow. An agent calls an API the emulator does not implement; the emulator answers with a stub or the wrong error code; the agent concludes its own code is wrong; the agent edits working code until the stub accepts it. The return arrow closes the loop, labelled green suite, broken code. The loop a missing feature starts Agent calls an API the emulator lacks A stub answers or the wrong error code Agent concludes its own code is wrong Agent edits working code green suite, broken code The agent cannot tell a gap in the emulator from a bug in your code. Nothing in the loop reports an error. Which is why the published gap list, not the service count, is the number to choose on.
No step in this loop reports an error, which is exactly why it costs you a day.

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

SituationPickBecause
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:

Project sources: