Prompt Chaining: A Complete Framework (2026)

A complete, practical framework for prompt chaining. Sections, in order:

1. What prompt chaining is · 2. Why chains beat one giant prompt · 3. How to decompose a task into a chain · 4. A worked multi-step example (blog post pipeline) · 5. Common chain patterns · 6. When to chain vs. use a single prompt · 7. Chaining vs single prompt (table) · 8. Common mistakes · 9. FAQs · 10. Sources & further reading.

The worked example shows a real four-link chain you can adapt. Each link is a copy-paste prompt.

A prompt chain is a pipeline. You split a task into ordered steps, run a focused prompt for each, and pass the output of one step in as the input to the next. The model only ever has to do one thing at a time, which is where the reliability gain comes from.

This is the multi-call cousin of the decomposition pattern from our 12 prompt patterns guide. Decomposition can happen inside one prompt ('do these steps in order'); chaining puts each step in its own call so you can inspect, edit, or re-run a single step without redoing the whole thing.

Chaining can be run by hand (copy each output into the next prompt) or wired up programmatically with an API. The framework is identical either way; the API just automates the hand-off. See the DAIR.ai guide for the canonical treatment.

A single overloaded prompt fails in predictable ways: the model drops requirements, blends steps together, and produces output that's hard to fix because you can't tell which instruction it ignored. Chaining addresses each of these.

Higher accuracy per step. A focused prompt with one job outperforms an omnibus prompt juggling five. Each link can use the right pattern — few-shot here, strict format there — without compromise.

Inspectable intermediates. You can check (or have a human approve) the output of step 2 before step 3 runs. When the final result is wrong, you can see exactly which link broke instead of rewriting one monolithic prompt.

Reusability and cost control. Links are reusable across chains, and you can route cheap steps to a cheaper model and expensive reasoning to a stronger one — see live pricing for OpenAI, Claude, and Gemini. A summarize step doesn't need your most expensive model.

Decomposition is the skill that makes chaining work. A practical procedure:

1. Write the end deliverable in one sentence. Know exactly what the last link must produce.

2. Work backwards. Ask 'what does the final step need as input?' Repeat until you reach what you already have. Those are your links, in reverse.

3. Make each link's output a clean input. Specify the output format of each step so the next step can consume it without parsing surprises (a list, JSON, a labeled section).

4. Add a checkpoint where it matters. Insert a human-review or validation step before anything irreversible or expensive.

5. Collapse links that don't earn their place. If two steps always succeed together, merge them. The goal is the fewest links that keep each step reliable, not the most.

Goal: turn a topic into a finished, fact-checked draft. One prompt does this badly; a four-link chain does it well.

Link 1 — Research questions. Output feeds Link 2.

``` You are a content strategist. For the topic "{topic}", list the 6 questions a skeptical target reader most wants answered. Return a numbered list only. ```

Link 2 — Outline. Takes Link 1's questions as input.

``` Group these questions into 4-6 logical sections. For each section, write an H2 and 3 bullet sub-points. Return the outline only. Questions: {output_of_link_1} ```

Link 3 — Draft. Takes the outline as input.

``` Write the section below into 120-180 words of plain, direct prose. Use only facts I provide; if a claim needs a source, mark it [CITE] rather than inventing one. Section outline: {one_section_from_link_2} ```

Link 4 — Fact-check pass. Takes the draft as input.

``` Review the draft below. List every factual claim and mark each as: supported by provided facts, needs a source ([CITE]), or unverifiable. Do not rewrite — just audit. Draft: {output_of_link_3} ```

Each link is small, testable, and reusable. The [CITE] convention in Links 3-4 keeps the chain honest — it surfaces every claim that needs a real source rather than letting the model fabricate one. Productize parts of this with the Blog Post Outline tool.

---

Run Link 3 once per section (a fan-out), then a final assembly step stitches the sections together. That fan-out-then-merge shape is one of the most common and useful chain structures.

Sequential. Straight line: A to B to C. The default — research, outline, draft, edit.

Fan-out / fan-in. One step produces N items, you run the next step on each in parallel, then merge. The blog pipeline above fans out over sections. Great for batch work.

Router. A first step classifies the input, then routes it to a different downstream prompt depending on the class (e.g. a support ticket routed to billing vs. technical handling).

Generate-then-validate. A producing step followed by a checking step that gates or corrects the output — the fact-check link above, or any draft-then-critique loop. Pairs naturally with the refine-loop pattern from our patterns guide.

Default to a single prompt. Most tasks don't need a chain — an RTF or CO-STAR prompt handles them in one call, with less latency and lower cost. Chaining adds moving parts; only spend that complexity when it buys reliability.

Chain when: the task has genuinely distinct stages; you need to inspect or approve an intermediate result; a single prompt keeps dropping requirements; or different stages want different models or settings. Those are the signals that the job is too big for one call.

The cost trade-off is real. A chain makes multiple API calls instead of one, so it costs more tokens and more wall-clock time. The payoff is accuracy and debuggability. If a single prompt already produces reliable output, chaining it is over-engineering.

Single prompt when: the task is one coherent stage, a single prompt produces reliable output, and latency/cost matter. Most everyday tasks fit here — don't chain what RTF already handles.
Chain when: the task has distinct stages, you need to inspect or approve intermediates, a single prompt keeps dropping requirements, or different steps want different models/settings.

The most common reason a chain that works in testing breaks in production is sloppy hand-offs: a link emits output in a slightly different shape than the next link expects, and the chain silently degrades. A few habits prevent this.

Make every link's output machine-friendly. End each prompt with a strict output spec — 'return a numbered list only, no preamble' or 'return only valid JSON matching this schema.' For programmatic chains, lean on native structured-output modes (OpenAI, Claude) so the downstream step never has to parse prose.

Pass forward only what the next link needs. Stuffing the entire prior conversation into each step wastes input tokens and dilutes focus. Extract the specific field or section and pass that, not the whole transcript — this is also where most of a chain's cost lives.

Label injected content. When you splice a prior output into the next prompt, fence it ('Outline:\n{output}') so the model can't confuse upstream output with your instructions — the delimiter pattern from our 12 prompt patterns guide, which doubles as a prompt-injection guard per the OWASP LLM Top 10 when any link touches untrusted text.

Estimate the chain's cost before scaling it. A four-link chain run across 50 sections is 200 calls. Sketch the token math first — the AI Prompt Cost Calculator helps — and route cheap links to cheaper models.

Over-chaining. Breaking a simple task into eight links adds cost and latency for no accuracy gain. Use the fewest links that keep each step reliable.

Loose hand-offs. If a link's output format isn't specified, the next link has to guess how to parse it. Lock each step's output shape so the chain doesn't break on a stray preamble.

No validation step. Chains compound errors — a wrong intermediate quietly poisons everything downstream. Add a generate-then-validate link before anything expensive or irreversible.

Ignoring cost. Routing every link to your most expensive model is wasteful. Match the model to the step using current pricing for OpenAI, Claude, and Gemini; cheap steps belong on cheap models.

Prompt chaining is documented established practice (current as of June 2026):

DAIR.ai Prompt Engineering Guide — prompt chaining: https://www.promptingguide.ai/

Learn Prompting: https://learnprompting.org/

OpenAI prompting guide: https://platform.openai.com/docs/guides/prompt-engineering

Claude prompt-engineering overview: https://docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview

Model pricing (to route steps cost-effectively): OpenAI https://developers.openai.com/api/docs/pricing ; Claude https://claude.com/pricing ; Gemini https://ai.google.dev/gemini-api/docs/pricing

Related on this site: Complete Guide to Prompt Engineering and 12 Prompt Patterns That Convert (see the decomposition pattern).