Prompt Workflow

The foundational step of breaking a complex objective into a sequence of simpler, atomic subtasks. This defines the logical steps the workflow must execute. For example, a 'write a market report' task decomposes into: 1) Research topic, 2) Outline structure, 3) Draft sections, 4) Add citations, 5) Proofread.

• Output: A defined sequence of subtasks or a Directed Acyclic Graph (DAG) of operations.
• Purpose: Enables modular prompt design and isolates failure points.

The individual prompts that execute each subtask, connected by control flow logic. This includes:

• Sequential Nodes: Linear prompts where output A is input to prompt B.
• Conditional Nodes (Routing Prompts): Branches execution based on the content of an intermediate output (e.g., classify sentiment, then route to appropriate response generator).
• Parallel Nodes: Executes multiple independent prompts simultaneously to improve latency.
• Looping Nodes: Repeats a prompt or node sequence until a condition is met (e.g., an iterative refinement loop).

The mechanism for passing information between prompts to maintain coherence and cumulative knowledge. This involves:

• Context Passing: Explicitly carrying forward relevant data like user intent, conversation history, or previous answers.
• Intermediate Representations: Using structured outputs (like JSON) from one prompt as clean, parseable input for the next.
• Stateful Prompting: Maintaining a session state or memory object that is updated at each step, preventing the model from "forgetting" earlier decisions.
• Context Window Optimization: Techniques like summarization to manage information within the model's fixed token limit.

The components that allow the workflow to interact with external systems, data sources, and functions. This transforms a language model into an actionable agent. Key patterns include:

• Tool-Use Chaining: Interleaving model reasoning with calls to calculators, code executors, or search APIs.
• ReAct Loop: A specific pattern (Reason + Act) that structures prompts to alternate between generating a reasoning trace and executing a tool call.
• Function Calling: Using model-generated structured requests (e.g., {"function": "get_weather", "location": "Boston"}) to trigger backend APIs.

The runtime system that executes the workflow definition, managing the flow of data and control between components. It handles:

• Execution Order: Running nodes sequentially, in parallel, or based on conditions.
• Data Marshaling: Formatting outputs from one step into the input template of the next.
• Error Handling & Fallbacks: Implementing fallback prompts or paths when a step fails or times out, mitigating error propagation.
• Observability: Emitting logs, traces, and metrics for each step (chain latency, token usage, success rates).

Checkpoints within the workflow that verify the correctness, format, or safety of intermediate outputs before proceeding. This is critical for production reliability.

• Verification Prompts: A dedicated step where the model critiques its own or a previous step's output for errors, hallucinations, or rule adherence.
• Schema Enforcement: Using structured output generation (JSON Schema, Pydantic) to guarantee parsable outputs.
• Programmatic Checks: Running code to validate syntax, run unit tests on generated code, or check data against a knowledge base.
• Human-in-the-Loop Gates: Pausing the automated chain for human review or approval at critical junctures.

The most fundamental pattern, executing prompts in a strict, predefined sequence. The output of each step serves as the primary input for the next. This is ideal for deterministic, multi-stage processes like data transformation or document summarization.

• Example: A three-stage chain for report generation: 1) Extract key facts, 2) Draft narrative, 3) Polish for tone.
• Key Characteristic: Simple to implement but lacks adaptability; errors propagate linearly.

A dynamic pattern where the execution path branches based on the content or classification of an intermediate output. A routing prompt analyzes the result and selects the appropriate downstream prompt.

• Use Case: A customer service bot that routes queries about "billing" to a financial extraction chain and "technical issues" to a troubleshooting chain.
• Implementation: Often modeled as a Directed Acyclic Graph (DAG), enabling intent-based routing and handling diverse input types within a single system.

A foundational pattern for tool-augmented reasoning, formalized as Reason + Act. The model interleaves internal reasoning traces with external actions (API calls, tool use) in a cyclical loop until a task is solved.

• Structure: 1) Thought: Model reasons about the current situation. 2) Action: Model decides to use a tool (e.g., search(query)). 3) Observation: Tool result is fed back. Loop repeats.
• Purpose: Enables models to interact with the external world, gather information, and perform complex, multi-step digital tasks.

A cyclic pattern where an initial output is repeatedly fed back into a refinement or correction prompt. This continues until a quality threshold is met or a maximum number of iterations is reached.

• Application: Improving code quality, polishing creative writing, or fixing structural errors in JSON output.
• Critical Component: A verification prompt is often used within the loop to evaluate the output and determine if another refinement cycle is needed. This pattern is central to self-correction methodologies.

A pattern that uses temporary supporting structures to guide a model through a complex task. It often employs least-to-most prompting, breaking a problem into progressively harder subtasks.

• Process: First, solve a simplified core problem. Then, use follow-up prompts to add layers of complexity or detail.
• Analogy: Like training wheels; the scaffolding (detailed instructions, examples) may be removed in a production-optimized version once the model reliably learns the task structure.

A hybrid pattern where specific steps in an automated chain pause for human intervention. The human provides review, validation, creative input, or makes a critical decision before the workflow proceeds.

• Common Steps for HITL: Final approval of a generated contract, quality check on extracted data, or providing subjective creative direction.
• Value: Combines AI scalability with human judgment, crucial for high-stakes, nuanced, or legally sensitive outputs. It mitigates error propagation by inserting checkpoints.

A prompt pipeline is a predefined, often linear, sequence of prompts where the output of one stage is automatically passed as input to the next. It is the most basic architectural pattern for implementing a prompt workflow, commonly codified in frameworks like LangChain or LlamaIndex. Pipelines enforce a deterministic execution order, making them ideal for straightforward, multi-stage processing tasks such as document summarization or data extraction.

A prompt graph, often modeled as a Directed Acyclic Graph (DAG), is a programmatic representation of a complex workflow where nodes are prompts or tools and edges define data flow and conditional logic. Unlike a linear pipeline, a DAG enables:

• Parallel execution of independent tasks.
• Conditional branching based on intermediate results.
• Aggregation of outputs from multiple paths. This structure is essential for building sophisticated, non-linear reasoning and action systems.

The ReAct (Reason + Act) loop is a foundational agentic pattern integrated into prompt workflows. It structures prompts to alternate between generating explicit reasoning traces and executing actions with external tools. A single ReAct iteration typically follows the sequence:

1. Reason: The model analyzes the situation and plans the next step.
2. Act: The model executes a tool call (e.g., API, calculator, search).
3. Observe: The tool's result is fed back into the context. Workflows often chain multiple ReAct loops to solve complex, multi-step problems.

A routing prompt is a classifier-like component within a workflow that analyzes input to determine the subsequent execution path. It enables dynamic, context-aware workflows through:

• Intent-Based Routing: Classifying user query intent (e.g., "sales inquiry" vs. "technical support") to route to specialized downstream prompts.
• Content-Based Routing: Inspecting document type or structure to choose the appropriate processing chain. This mechanism is critical for creating single-entry-point systems that branch into multiple specialized workflows.

An intermediate representation (IR) is the structured or semi-structured output from one step in a workflow, designed to be cleanly consumed by a subsequent step. Effective IRs are key to robust chaining because they:

• Enforce Schema: Use formats like JSON or XML to guarantee parseable outputs.
• Reduce Ambiguity: Structure information to minimize misinterpretation by the next prompt.
• Enable Validation: Allow for programmatic checks before passing data forward. Common examples include a list of extracted entities or a normalized summary outline.

These are defensive patterns within a workflow to ensure reliability. A verification prompt is a step where the model checks a previous output for errors, consistency, or rule adherence. A fallback prompt is a predefined alternative path executed if a primary step fails, times out, or fails validation. Together, they mitigate error propagation by:

• Catching Hallucinations: Verifying factual claims or code correctness.
• Providing Graceful Degradation: Offering a simplified response if a complex chain fails.
• Maintaining Workflow Integrity: Preventing corrupted state from moving forward.