update
Towards Agentic Full-Stack Emulation: Why WonderTwin AI is Joining LocalStack
LocalStack grounded cloud infrastructure. WonderTwin AI is joining to ground the other half of the dependency graph: the applications your code calls out to.
I see the software market like a movie of cells interacting under a microscope: Dividing, drifting, reacting to everything around them. It just used to run slower.
Agentic development is what sped up the movie, and infrastructure was only ever half the frame: Today, LocalStack has application emulators. The vision we’re moving towards is full-stack emulation, and today I’m excited to share that my startup, WonderTwin AI, is joining LocalStack to bring the application emulation piece of that vision to life.
Individually, most software products change at a pace that looks perfectly reasonable: A release here, a deprecation there, nothing dramatic. Add every product, every API, every service that every company depends on together, and the picture stops looking like a release train and starts looking like that movie, sped up: Constant motion, signals firing, everything reacting to everything else. That aggregate motion has always been the real size of the software market. Companies just never had to engage with most of it, because they deliberately limited how many dependencies they touched, for entirely rational change-management reasons.
Agentic development promised teams they could finally move as fast as their agents can work. In practice, that promise breaks the moment an agent hits a dependency nobody’s modeled: Agents don’t wait for a quarterly review of new dependencies, they reach for whatever gets the job done, continuously, and they can only move as fast as their slowest, least-understood dependency lets them. By grounded, I mean modeled on how a dependency actually behaves, not just how its interface is shaped: Its rate limits, its edge cases, its failure modes. Without that grounding, speed just means finding out how a dependency really behaves in production, after an agent has already shipped against a guess.
LocalStack has spent years solving exactly this problem for one branch of the dependency graph: public cloud infrastructure. From day one, LocalStack’s mission has been to give developers and AI agents a more effective development experience that removes the complexity and risks associated with testing against a shared, remote, unpredictable AWS or Snowflake. By simulating the actual behavior and not a stub, local cloud development goes beyond just providing a local endpoint to perform traditional cloud development and provides unique advantages that were never possible when building against the cloud. LocalStack has increasingly described itself as a local cloud development sandbox for AI agents as much as for people, because agents need the same grounded infrastructure humans do, just faster and at greater volume. That covers everything your code deploys to. It never covered everything your code calls out to.
Application dependencies are the other branch, and starting today, they’re a first-class emulation target inside LocalStack, not an afterthought. Every piece of software also calls out to other applications: Payment processors, communication platforms, commerce systems, developer tools, the long list of services no engineering team builds in-house. Those dependencies have been stuck with the exact compromise cloud infrastructure used to have: hosted sandboxes shared across a whole org, or mocks maintained by hand that describe the shape of a response and nothing about whether the real service would behave that way under real conditions. Agents accelerate through that gap exactly the way they accelerate through infrastructure gaps, except with no grounding on the other side to catch them.
Agentic full-stack emulation is what closes that gap completely: Every dependency your code or your agents touch, cloud infrastructure and third-party application alike, running locally as a real, stateful model of how that dependency actually behaves, not a static description of its interface. And because the software market itself never stops moving, that model can’t be static either. It has to be continuously recalibrated against the real service, the same way the market it’s modeling never stops changing. Ground half the graph and agents still find the other half by breaking it in production. Ground all of it, continuously, and speed stops being a risk and becomes what agentic development actually promised: Agents that move fast and don’t need to guess.
LocalStack customers already report roughly 10x productivity gains from grounding just the infrastructure layer this way. That number is a preview, not a ceiling. It’s what happens when you ground one branch of the dependency graph. Agentic full-stack emulation is what happens when you ground all of it.
We’re re-tooling the original WonderTwin fleet of application emulators to meet the needs of the LocalStack community and customer base: Every LocalStack customer can already use application emulation alongside cloud emulation, in the same platform, the same workflow. That catalog will keep growing the way LocalStack has always grown its cloud coverage: Driven by what real teams need next, not by chasing a number.
Joining forces wasn’t the only way to build toward full-stack emulation, but it was the strongest path we found to completeness, and I’m glad to be building the rest of it here.
We’re already working with early customers to build the emulators they need most. If you want to help shape what gets emulated next, as a design partner or simply as part of the community, reach out.
Tela Andrews, Founder, WonderTwin AI, and Application Emulator Lead, LocalStack