What it is
Multi-step work expressed as ad-hoc conversation — "now do X, now do Y, now do Z" — is inherently fragile: it cannot be replayed from a checkpoint, it has no schema to validate, it accumulates context silently until something breaks, and its state is invisible to anyone who wasn't present for the conversation. A recipe encodes the same work as a declarative specification: each step is named, its inputs and outputs are defined, its dependencies are explicit, and its execution can be resumed after interruption. Recipes are checkpointed, auditable, and version-controlled. They transform a one-time conversation into a reproducible workflow that a different agent, on a different day, can execute with the same result.
A chat is a convenient way for a human to express intent, but it is a poor representation of long-running work — it is a trace of what happened once, not a structure you can replay, inspect, or recover from. The recipe in its mature form is a workflow graph, and the graph is the operating system the work runs on. Its nodes are discrete work units — plan, implement, review, test, deploy, ask-human, inspect-logs — each with its own context and success condition. Its edges are the conditions to advance, retry, branch, escalate, or stop. Around the nodes sit the durable artifacts that carry state between them, the models assigned to roles, the deterministic tools that check the model's work, and the humans who own the consequential decisions. Seeing the work this way is what lets you reason about it as a system rather than re-deriving it from a transcript every time.
The opposing anti-pattern is the giant prompt as operating system: cramming all of that structure into one enormous instruction block. A giant prompt can work temporarily, but it hides the phases, makes evaluation hard because there is no boundary to evaluate at, and turns context into a junk drawer where every concern competes for the model's attention at once. The fix is to move repeated behavior out of the prompt and into named skills, scripts, files, or graph nodes — give each phase a name, a boundary, and an artifact, and the prompt stops being the whole machine and becomes one node in it.
When to reach for it
- Any multi-step workflow that will run more than once — encode it as a recipe the first time, not after the third failure.
- When a workflow involves more than two sequential steps with handoffs between agents — conversation becomes a liability at this scale.
- When you need recoverability: a recipe that checkpoints between steps can resume after interruption; a conversation cannot.
- When a workflow must be auditable — a recipe YAML is a version-controlled artifact; a chat history is not.
- When onboarding another agent or person to execute a workflow — a recipe is the specification; a conversation recap is a reconstruction from memory.
When NOT to
- Truly one-off, exploratory, and immediately disposable interactions where the overhead of authoring a recipe exceeds the value of the work — quick questions, single-turn queries, throwaway experiments.
- Work that is inherently interactive and responsive, where the next step cannot be known until the previous result is seen and human judgment is required at every branch — in those cases, the recipe is the human-in-the-loop checkpoint design, not the full specification.
- Steps so trivially atomic that a recipe adds no structural value over a single function call.
Exemplars
- Anthropic — https://www.anthropic.com/research/building-effective-agents — Building Effective Agents: recommends structured workflow specifications over ad-hoc agent conversation for complex multi-step tasks
- Amplifier — https://github.com/microsoft/amplifier — the Amplifier recipe system (YAML-declared steps, staged execution, approval gates, and automatic checkpointing) is the canonical implementation of this pattern: conversation-time instructions become recipe-time specifications
- Cornelia Davis / Temporal.io — https://temporal.io/blog/durable-execution-meets-ai-why-temporal-is-the-perfect-foundation-for-ai — durable execution platform that implements recipe semantics natively: workflow state is recorded as an event history, and execution resumes from the last completed step after interruption without re-invoking prior activities
- Dex Horthy, "12-Factor Agents" (humanlayer, 2025) — https://github.com/humanlayer/12-factor-agents — Factor 8 ("Own your control flow") argues against purely conversational agent loops in favor of structured execution graphs with defined interruption points that developers, not chat history, control