The Prompt is the Platform - Dominik Tornow, Resonate HQ

Key Concepts

• Durable Execution: A paradigm ensuring that software processes can survive infrastructure failures, restarts, and network partitions without losing state.
• Agentic Engineering: The practice of using AI agents to design, specify, and implement software systems.
• Abstract vs. Concrete Specification: The distinction between a platform-agnostic protocol (abstract) and a target-specific implementation plan (concrete).
• Deterministic Simulation: A testing environment that mimics distributed system behaviors (like stale reads or network failures) in a repeatable, inspectable way.
• Optimistic Concurrency: A concurrency control method where operations assume no conflict but verify versioning before committing changes.
• "Forbidden Fruit": Metadata available only in simulation (e.g., knowing a read was stale) that helps agents debug algorithms, even though the production code cannot rely on it.

---

1. The Shift: From Implementation to Specification

Dominic Turno, CEO of Resonate, argues that the future of software engineering lies in bespoke implementations generated on demand.

• The Core Theory: General-purpose libraries and frameworks will be replaced by minimal, infrastructure-specific implementations derived from a single, reusable specification.
• Value Migration: The product is no longer the code (the implementation) but the protocol (the specification). By treating the prompt as a platform, developers can synthesize trusted servers tailored to specific infrastructure (e.g., NATS.io, Postgres) rather than forcing a "one-size-fits-all" server.

2. The Methodology: A Four-Step Framework

To bridge the gap between abstract requirements and production-ready code, Resonate utilizes a structured, agent-driven process:

1. Abstract Specification: Defines the protocol without assuming database schemas, consistency models, or specific infrastructure primitives.
2. Simulated Implementation: The agent builds a prototype in a deterministic simulation environment to discover the correct algorithm under partial order and failure.
3. Concrete Specification: The agent, guided by the human, writes down target-specific decisions (e.g., SQL queries, transaction boundaries, indices).
4. Concrete Implementation: The agent generates the final production code based on the verified concrete specification.

3. The Role of Deterministic Simulation

A major challenge in distributed systems is handling "legal" but inconvenient behaviors, such as stale reads in a key-value store.

• The Problem: If an agent is asked to build a system directly from an abstract spec, it often fails to handle edge cases like concurrency errors or network failures.
• The Solution: Resonate uses a Python-based deterministic simulator that mimics the target platform (e.g., NATS.io).
• Feedback Loops: The simulator provides "Forbidden Fruit"—data that the production code cannot see (e.g., "You performed a stale read; here is the actual latest value"). This allows the agent to understand the cause of a failure rather than just observing that a test failed.

4. Minimalism as a Design Philosophy

Turno emphasizes that simplicity is the "finish line," not the starting point.

• Protocol Reduction: Resonate spent three years stripping away abstractions, resulting in a protocol centered on only two objects: Durable Promises and Durable Tasks.
• Target Primitives: When building on NATS.io, the design question is: "How can we express the Resonate protocol using only NATS primitives (queues, key-value stores, scheduled messages)?"

5. Key Arguments and Perspectives

• Agents as Drivers: Humans remain essential for design, but the agent acts as the driver. By moving agents "upstream" into the design phase (via simulation), they become architects rather than just coders.
• Verification vs. Specification: While much of the industry focuses on verifying AI-generated code, Turno argues that focusing on the specification is more critical. If the specification is correct and the implementation is derived from it, the system is inherently more robust.
• Quote: "The prompt is a platform and the specification is a product."

6. Synthesis and Conclusion

The future of durable execution is not in building monolithic servers, but in synthesizing bespoke implementations from a core, minimal protocol. By utilizing deterministic simulation, developers can empower AI agents to navigate the complexities of distributed systems, allowing them to design, debug, and implement production-grade software that is perfectly tuned to the underlying infrastructure. The ultimate takeaway is that by shifting focus from code to specification, we can achieve higher reliability and better integration with existing technology stacks.