AI Engineer World's Fair 2026

The Prompt is the Platform

Loading slides…

Read the talk

The Prompt Is the Platform

Generating infrastructure from a specification requires more than passing basic tests: agents need a way to explore distributed algorithms, reproduce failures, and turn tested designs into concrete implementations.

From a talk by Dominik Tornow

Before you start: Familiarity with key-value stores, versioned writes, and basic concurrency will help you follow the simulation example.

What happens when the implementation becomes unnecessary?

What would make a software platform unnecessary even if it worked well? Dominik Tornow opens with a prediction: in 2026, coding agents will retire the first platform by making its implementation unnecessary. This is a forecast about how software gets built, not a report of a platform already displaced. Tornow introduces himself as founder and CEO of Resonate, a durable execution platform whose technical values are minimalism and simplicity.

The proposed change is from adopting a general-purpose implementation to generating a bespoke extension of infrastructure already in place. Instead of installing another library, framework, or platform, a team could ask an agent to implement the required behavior on its existing stack. Reuse moves upstream: the reusable artifact becomes the specification, from which many target-specific implementations can be derived. In that sense, the prompt becomes the platform.

0:020:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:02 · section reference included

A protocol that can produce many servers

For Resonate, this possibility changes where the product's value lives. Tornow describes an existing server and SDK implementations for TypeScript, Python, Rust, Go, and Java. If agents can generate implementations, owning those implementations is no longer the whole proposition. The durable asset becomes the specification that connects one protocol to multiple servers.

A specification box branches to three implementation boxes; the speaker inset partly covers the lowest box.Open full source frame
One specification connects to three implementations.

The general-purpose Resonate Server remains a reference implementation. Other implementations, built with infrastructure partners, can provide durable execution directly on customers' existing infrastructure with minimal additional dependencies. The engineering question therefore changes from whether a server can be built to whether trusted servers can be synthesized repeatedly from the same specification.

Verification asks whether the generated result is correct. There is an earlier question too: how can the agent help specify the system it will build? The case study is Resonate's partnership with Synadia, the company behind NATS, an open-source messaging system for distributed applications. Bringing Resonate to that infrastructure provides a concrete test of the path from specification to implementation.

1:331:47
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:33 · section reference included

Keep the reusable specification abstract

The familiar agentic coding workflow has three parts: a specification, an agent, and an implementation. For many applications, that is enough. But generating several implementations for different infrastructure targets introduces another requirement: the shared specification must survive a change of target.

Three boxes labeled Spec, Agent, and Impl connected from left to right by arrows.Open full source frame
Spec → Agent → Impl.

That rules out embedding a concrete database schema or index layout in the reusable specification. It also rules out assuming relational tables and transactions, a key-value store, or a weakly or strongly consistent storage substrate. Those are implementation decisions. The specification describes the required behavior; the implementation must realize it using the target's actual capabilities. Abstract does not mean that correctness is optional—it means the contract cannot depend on one convenient way of achieving it.

3:413:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:53 · section reference included

The first attempt exposed a design gap

The initial request was direct: build a Resonate server in Rust on top of Postgres, following the abstract specification. The agent produced a system that worked on the happy path and passed basic tests. But it broke under concurrency, process failure, and network failure. The distance from the abstract contract to a correct concrete implementation was too large; the result was a prototype rather than a production system.

The next attempt inserted a concrete specification between the abstract specification and the code. A human drove an interactive design process with the agent, making the Postgres decisions explicit: the schema, indices, SQL queries, and transaction boundaries. Tornow reports that, once those decisions were written down, the agent could implement a production system.

This solved the implementation problem while exposing a limitation in the workflow. The agent helped build the system, but the human still supplied its design. If specifications are themselves reusable products, helping only after the design decisions have been made leaves a substantial part of the work untouched.

5:045:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:04 · section reference included

Design in simulation before building for production

For NATS, the team changed the agent's first assignment. Rather than immediately requesting a production system, they asked what the agent needed to design the system first and build it second. They supplied a deterministic simulation environment and requested a simulated implementation.

The simulated implementation is executable design. Its purpose is to discover algorithms that work under partial order and partial failure: operations need not unfold in one convenient sequence, and parts of the system can fail independently. Once the algorithms have been explored and tested in simulation, the agent can describe the target-specific design and then implement it. The sequence becomes:

  1. Start with the abstract specification.
  2. Build a simulated implementation to explore the algorithm.
  3. Derive a concrete specification from the tested design.
  4. Build the concrete implementation from that specification.

Humans remain involved, but the agent now drives part of the design process instead of merely translating a human design into code.

6:547:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:54 · section reference included

A small protocol still has a large behavior space

Minimalism and simplicity make this approach more tractable, but they are the result of design work, not an initial condition. Tornow reports three years spent making the protocol smaller and simpler. When a problem appeared, the recurring questions were what abstraction could be erased, what property could be removed, and what relationship could be broken. The resulting protocol centers on two objects: a Durable Promise and a Durable Task. Even with that small conceptual surface, concurrency and distribution produce a complex space of possible states and behaviors.

For the NATS design, Tornow identifies three available building blocks: queues, a key-value store, and delayed or scheduled messages. These belong to the target infrastructure, not to the Resonate protocol. The task is to express the behavior of Durable Promises and Durable Tasks using those primitives, while preserving correctness when the primitives behave in inconvenient but permitted ways.

8:298:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:29 · section reference included

A legal read can describe an outdated world

Consider a key whose values progress from foo to bar to baz. In the demonstration's numbering, the latest value is baz at version 2. A fresh read returns that pair. A stale read instead returns foo at version 0, even though the current value remains baz.

ReadReturned valueReturned versionCurrent value
Freshbaz2baz
Stalefoo0baz

Under the target behavior modeled in the talk, the stale result is neither corruption nor a store bug. These zero-based versions are illustrative simulator labels: actual NATS revisions are bucket-wide sequence numbers, with the first stored write starting at 1. The example should not be read as a guarantee that every production read path may return any arbitrary historical value.

Correctness must cover legal target behavior, not only convenient behavior. A simulator therefore needs to expose fresh reads, stale reads, and their associated versions. But receiving a version does not itself reveal whether the read is fresh: the client does not know the current version merely from seeing an observed one.

The conflict becomes visible when the client attempts a write. Having read version 0, it requests an update conditional on version 0 still being current. The key has already advanced, so the update fails. That failed write establishes that the world the client observed is no longer current. Designing an algorithm that remains correct through such observations and failures is difficult for humans and agents alike.

9:5410:06
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:54 · section reference included

Make the failure repeatable and inspectable

The agent needs immediate, unambiguous feedback that explains a failure's cause: which stale value was returned, which logic it triggered, which write failed, and which invariant broke. To provide that feedback, the team built a deterministic simulation environment in Python, modeling the parts of NATS on which its implementation depended.

The simulated key-value store retains a full version history for each key. On get, a deterministic random generator controls whether the returned entry is current or older. On update, the store enforces optimistic concurrency: the write succeeds only when the supplied version is still current; otherwise it raises. Keeping full history is a simulation choice—production NATS retains a configured, bounded history.

The essential behavior fits in a small Python model:

python

from random import Random


class KVStore:
    def __init__(self, seed: int):
        self.rng = Random(seed)
        self.history: dict[str, list[str]] = {}

    def create(self, key: str, value: str) -> int:
        if key in self.history:
            raise KeyError(key)
        self.history[key] = [value]
        return 0

    def get(self, key: str) -> tuple[str, int]:
        versions = self.history[key]
        index = self.rng.randrange(len(versions))
        return versions[index], index

    def update(self, key: str, value: str, version: int) -> int:
        versions = self.history[key]
        if version != len(versions) - 1:
            raise KeyError("version conflict")
        versions.append(value)
        return len(versions) - 1


store = KVStore(seed=7)
version = store.create("example", "foo")
version = store.update("example", "bar", version)
version = store.update("example", "baz", version)
observed_value, observed_version = store.get("example")

Here get can select any retained entry, including the latest. An update carrying version 0 would fail once baz occupies version 2; the failed update would leave the history unchanged.

Python KVStore class showing initialization, get, create, and update methods, including random version selection and a KeyError on an update index mismatch.Open full source frame
Python key-value store simulation with version history and an update index check.

The model reproduces the target behaviors that matter to this correctness problem while making their execution deterministic, repeatable, and inspectable. With the same inputs and random choices, the failing execution can be reproduced. The agent can then repair its algorithm against that particular trace instead of trying to infer what happened from an intermittent failure.

12:1112:27
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:11 · section reference included

Let the debugger see what the algorithm cannot

Deterministic simulation can do more than inject stale reads. It can expose facts that the real platform hides. Tornow calls this the “forbidden fruit”: in production, a read provides the observed value and version, but not a freshness label or the latest value the client missed. The algorithm cannot depend on information unavailable through the real interface.

The simulator can nevertheless record that information for diagnosis. Every simulated get emits a trace event identifying whether the read was fresh or stale and recording both the observed value and the latest value. The runtime algorithm and the agent inspecting its trace have different information privileges. The extra facts help the agent understand a failure without becoming inputs to the algorithm it is designing.

The displayed KVStoreGet trace makes the distinction concrete. For the promise identified by foo-1, the result says pending. That is what the algorithm receives. The trace also labels the read STALE and records that the latest state of the same promise is settled.

InformationAlgorithm receives itDiagnostic trace records it
Observed state: pendingYesYes
Read type: STALENoYes
Latest state: settledNoYes

The trace exposes a disagreement between an observation and current state; it does not turn the stale observation into a fresh read.

JSON trace for KVStoreGet on foo-1, with type STALE, result status pending, and latest status settled.Open full source frame
A stale read returns pending while the latest value is settled.

That difference makes a failure actionable. Instead of learning only that an invariant failed, the agent can identify a decision made from a stale view of the promise. It can use the hidden state to explain why its algorithm was wrong, while repairing the algorithm using only information that production code can actually obtain. Cause and effect become visible without granting the implementation unrealistic powers.

13:5314:02
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:53 · section reference included

From a tested algorithm to a reusable product

Tornow reports that this process closed the design gap. The agent first built a proof of concept inside the deterministic simulator and tested it through fuzzing. It then derived a concrete specification from that simulated design. He describes the algorithm as correct at this point; fuzz testing supplies evidence from the executions it explores, rather than an exhaustive proof of every possible execution.

From the concrete specification, the agent derived an implementation. The additional simulation stage changed its role: it could participate in discovering the design, not merely implementing decisions already made by a human. Humans remained involved, but the agent drove the progression from an abstract contract through executable design to a concrete specification and implementation. That is the practical basis for the closing product thesis: the prompt is the platform, and the specification is the product.

16:1616:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:16 · section reference included

Resources

Updates since the talk

  • A Go implementation of Resonate using NATS JetStream for transport and storage, with build instructions and deterministic testing endpoints. Production use requires a commercial license.

  • A guide to the protocol's abstract machine, atomic transitions, implementation boundaries, and server implementations on different storage systems.

  • Current provider compatibility, licensing, test coverage, and deployment limitations for NATS and other infrastructure targets.

Transcript download
Full transcript

Loading transcript…