AI coding agents are about to do something nobody in software expected: retire an entire platform. Not because the platform is broken, but because it's no longer necessary. By 2026, according to Dominic Turno — founder and CEO of Resonate — the first software platform will be quietly made obsolete by agents that can generate bespoke implementations on demand. This isn't about a new library or framework replacing an old one. It's a fundamental shift in where reuse lives, and it changes everything about how we think about software products.
How Will AI Coding Agents Replace Software Platforms?
The core argument is surprisingly clean. Today, software teams reuse implementations — a library, a framework, a platform like Resonate. In the near future, teams will reuse specifications instead. From a single abstract specification, an agent can generate multiple bespoke implementations, each one tailor-made for the infrastructure already in place.
Think about what that means practically. Instead of adopting a general-purpose platform with its own dependencies and constraints, you ask an agent to synthesize a trusted, target-specific implementation from a proven spec. The platform as a product disappears. The specification becomes the product.
Turno puts it plainly: "The prompt is a platform." This isn't a metaphor. It's a business model, a technical strategy, and a prediction about where the entire software industry is heading — all at once.
What Is Agentic Engineering and Why Does It Matter?
Most conversations about agentic engineering focus on verification: how do we know the agent's output is correct? Turno flips the question. His focus is on specification — and more specifically, on how agents can participate in designing systems, not just building or checking them.
This is a meaningful distinction. When an agent only implements, a human still has to do the hard design work. But when an agent can engage with the design process itself — exploring algorithms, testing edge cases, discovering failure modes — you get something qualitatively different. You get a collaborator, not just a code generator.
\p>The challenge is giving the agent the right environment to do that upstream work. And that's exactly what Resonate has been building toward.What Is a Durable Execution Platform?
Resonate is a durable execution platform — infrastructure designed to ensure that long-running workflows survive failures. Process crashes, network drops, partial outages: durable execution means your application keeps its promises even when the world gets messy.
Resonate has a server implementation and SDKs for TypeScript, Python, Rust, Go, and Java. But under Turno's new vision, those implementations are no longer the core product. The core product is the protocol — the abstract specification that defines what durable execution means, independent of any specific database, queue, or consistency model.
Resonate is now partnering with infrastructure providers to bring durable execution natively to existing technology stacks. One key partner is Synadia, the company behind NATS.io — an open-source messaging system built for modern distributed systems. The Resonate-on-NATS integration became the test case for their entire agentic engineering methodology.
How Do You Go From Abstract Spec to Production Code with AI?
The first attempt was direct and it failed. The team gave the agent an abstract specification and asked it to generate a concrete Rust implementation on top of PostgreSQL. The agent produced something that worked on the happy path and passed basic tests — but broke under concurrency, process failure, and network failure. It was a prototype, not a production system.
The gap between abstract specification and concrete implementation was simply too large for the agent to cross in one jump. So the team inserted an intermediary artifact: the concrete specification.
- Abstract specification — platform-agnostic, no assumptions about schema, consistency model, or data primitives
- Concrete specification — target-specific decisions made explicit: data schema, indices, SQL queries, transaction boundaries
- Concrete implementation — production code derived from the concrete spec
With that intermediary in place, the agent was able to produce a production-quality system. But there was still a problem: the human was doing all the design work. The agent was building and implementing, but the decisions were still human-driven. That's not good enough if the specification is supposed to be a reusable, scalable product.
Why Deterministic Simulation Testing Is Key for AI Agents
To let agents participate in design — not just implementation — Turno's team gave the agent a deterministic simulation environment. The insight here is subtle but powerful: agents thrive on immediate, unambiguous feedback. Not just "this went wrong" but "here's exactly why, here's the stale value that was returned, here's the invariant that broke."
They built a simulation of NATS.io's key-value store in Python. In the real NATS key-value store, reads can be stale — you might read an old version of a value even though a newer one exists. That's not a bug; it's a valid behavior under the platform's consistency model. But it means your implementation has to be correct even when the platform behaves legally but inconveniently.
The simulated store mimics this exactly. On a get, it sometimes returns the latest version and sometimes — controlled by a deterministic random generator — returns an older version. On an update, it enforces optimistic concurrency: the write only succeeds if the version you read is still the latest. If not, it raises an error.
This gives the agent a store that behaves like the real platform in the ways that matter for correctness, but with three critical advantages:
- Deterministic — failures can be reproduced exactly
- Repeatable — the agent can run the same scenario multiple times
- Inspectable — every read emits a trace event revealing whether it was fresh or stale, and what the hidden latest value was
How Do You Handle Stale Reads in Distributed Systems?
This is where the concept of "forbidden fruit" becomes central. In production, when you read from the key-value store, you only get the value at the version you observed. You don't get to know if that read was stale. You don't get to see the latest value you missed. Real code cannot depend on that hidden information — and it shouldn't.
But in simulation, you can record it. Every get emits a trace event. If the read is fresh, the trace says so. If the read is stale, the trace records what you got and what the latest hidden value actually was. The algorithm can't use this information — but the agent can use it to understand why its algorithm was wrong.
Instead of just knowing "the invariant failed," the agent learns: "the invariant failed because the algorithm made a decision from a stale view of the world." Cause and effect become visible. The agent can repair the algorithm against the exact trace that broke it.
With this environment in place, the full agentic engineering process became:
- Abstract specification — platform-agnostic protocol definition
- Simulation implementation — agent builds an executable design in the simulator
- Concrete specification — agent derives target-specific decisions from verified simulation
- Concrete implementation — agent builds production code from concrete spec
What Does 'The Prompt Is a Platform' Actually Mean?
It means the locus of value in software is shifting. For decades, value lived in implementations — the code, the infrastructure, the running system. As implementations become generatable by agents, that value migrates upstream to specifications and protocols.
For a company like Resonate, this reframes the entire product. The SDKs and servers are no longer the thing. The protocol — refined over three years of asking "what can we take away, what abstraction can we erase, what property can we remove" — is the thing. It's small, it's minimal, it centers around just two objects: a durable promise and a durable task. That simplicity isn't a starting point. It's the finish line after years of deliberate subtraction.
And from that minimal, abstract spec, agents can now design and build target-specific platforms on demand. Resonate on PostgreSQL. Resonate on NATS. Resonate on whatever infrastructure a customer already runs. The specification is the product. The prompt is the platform. The 2026 retirement of the first unnecessary platform has already begun.
