Prompt Chaining

The foundational pattern where a complex objective is broken into a linear sequence of simpler subtasks. Each prompt in the chain handles one discrete step, with its output becoming the input for the next.

• Example: A customer service workflow: 1) Classify query intent, 2) Extract key entities (order ID, issue), 3) Generate a draft response, 4) Apply a brand tone adjustment.
• This structure makes complex reasoning tractable and outputs more predictable and auditable.

Enables dynamic, non-linear workflows where the execution path depends on the content of intermediate outputs. A routing prompt acts as a classifier to determine the next step.

• Intent-Based Routing: A prompt analyzes user input to classify intent (e.g., 'billing', 'technical support', 'sales'), triggering a different specialized sub-chain for each.
• Fallback Prompts: Provide alternative paths if a primary step fails validation or times out, increasing system resilience.

The mechanism for maintaining coherence across a chain by explicitly carrying forward relevant information. This transforms a series of independent calls into a stateful conversation with the model.

• Intermediate Representations: Outputs are often structured (e.g., JSON) to be easily parsed and injected into subsequent prompts.
• Context Accumulation: Critical data like user preferences, conversation history, or extracted facts are passed step-by-step, preventing the model from 'forgetting' earlier decisions.

A cyclic pattern where an output is repeatedly fed back into a refinement or correction prompt. This is used for quality assurance, detail enhancement, or error correction.

• Verification Prompts: A dedicated step where the model critiques its own or a previous step's output for errors, consistency, or rule adherence.
• Stepwise Refinement: Begin with a coarse output (e.g., a document outline) and use follow-up prompts to progressively add detail, polish language, or adjust format.

Chains interleave LLM reasoning with calls to external systems, APIs, or functions. This pattern, exemplified by the ReAct (Reason + Act) loop, grounds the workflow in real-world data and actions.

• Tool-Use Chaining: A prompt generates a reasoning trace and a precise function call; the tool's result is then fed into the next prompt for further analysis or action.
• Example: 1) Prompt decides a user needs a weather report, 2) Calls a weather API, 3) Uses the API's JSON response to generate a natural language summary.

Engineering considerations focused on making chains production-ready. Key concerns include managing chain latency, cost, and preventing error propagation.

• Prompt Chain Optimization: Reordering steps, caching frequent intermediate results, and using smaller/faster models for simpler steps to reduce total cost and latency.
• Error Containment: Designing validation steps and fallbacks to prevent a mistake in an early prompt from corrupting all subsequent outputs.

The foundational cognitive step of breaking a complex problem into a sequence of simpler, atomic subtasks. This is a prerequisite for designing an effective prompt chain.

• Key Activity: Analyzing an end goal to define discrete, executable steps.
• Example: Decomposing "Write a market analysis report" into: 1) Gather company data, 2) Identify competitors, 3) Analyze trends, 4) Draft sections, 5) Synthesize conclusions.
• Relation to Chaining: Provides the logical blueprint that a prompt chain operationalizes.

A predefined, often linear, sequence of prompts where the output of one stage is programmatically passed as input to the next. It represents the implemented automation of a chain.

• Key Characteristic: Fixed, deterministic flow of execution.
• Implementation: Commonly built using frameworks like LangChain, LlamaIndex, or custom orchestration code.
• Example: A customer support pipeline: 1) Classify query intent, 2) Retrieve relevant documentation, 3) Draft a response, 4) Check for policy compliance.

A non-cyclic graph structure modeling complex prompt workflows, where nodes are prompts and edges define data flow and dependencies. Enables parallel and conditional execution beyond simple linear chains.

• Key Advantage: Allows for branching, merging, and concurrent prompt execution.
• Use Case: A research assistant that can simultaneously summarize one document while extracting data from another, then synthesize the results.
• Tooling: Often designed and visualized in platforms like PromptFlow or Semantic Kernel.

The structured or semi-structured output from one prompt in a chain, explicitly designed for consumption by a subsequent step. This is the data contract between prompts.

• Purpose: Reduces ambiguity and error propagation by enforcing a clean, parseable format.
• Common Formats: JSON, XML, YAML, or a specific plain-text template.
• Example: A first prompt outputs {"entities": ["Company A", "Product B"], "sentiment": "positive"} which is directly fed into a second prompt for analysis.

A foundational chaining pattern that structures prompts to alternate between generating explicit reasoning traces and executing actions with external tools in a cyclical loop.

• Core Pattern: Thought → Action → Observation → Thought...
• Purpose: Grounds the model's reasoning in real-world data and API results.
• Example: An agent's loop: Thought: "I need the current weather." Action: call_api(get_weather, "London") Observation: {"temp": 12°C, "condition": "rainy"} Thought: "Now I can advise the user to take an umbrella..."

An advanced prompting framework that extends chaining by exploring multiple parallel reasoning paths (branches) and using a search or scoring mechanism to select the best continuation.

• Key Mechanism: Breadth-first search or depth-first search over a tree of possible reasoning steps.
• Advantage: Mitigates the sequential brittleness of linear chains by evaluating alternatives.
• Example: For a complex planning task, the chain generates 3 different first steps, evaluates each, and only continues expanding the highest-scoring branch.