Home › Claude › Agent › Sequential

➡️ Sequential workflow: one step at a time

Some jobs only make sense in order. You can't analyse data you haven't collected, or review a report that hasn't been written. A sequential workflow splits a big task into a chain of smaller steps, and each step uses the output of the step before it.

• Beginner
• ⏱ 20 min
• General workflow pattern

What is it?

In a sequential workflow you break a task into fixed steps that run in a set order. Step 1's output becomes step 2's input, and so on, like passing a baton in a relay race. Each step is a small, focused job, often a single call to Claude with its own instructions.

Step

One focused piece of work, such as "list the key facts".

Dependency

When one step needs another step's result before it can start.

Gate (check)

A test between steps that checks the output is good enough to continue.

Checkpoint

Saved progress, so a failed run can restart from the last good step instead of from the beginning.

Retry

Trying a failed step again, usually a limited number of times.

Why is it important?

• Better quality: Claude does better at one clear job at a time than at "research, analyse, write and review all at once".
• Easier to fix: when something goes wrong, you can see exactly which step failed.
• Quality checks between steps catch problems early, before they spread.
• Predictable: the same steps run in the same order every time.

Real-world analogy

How does it work?

1. Split the task into steps that each have one clear goal.
2. Write instructions for each step.
3. Run step 1 with the original input.
4. Check the output (the gate). If it fails, retry the step or stop.
5. Save a checkpoint and pass the output to the next step.
6. Repeat until the last step produces the final result.

Workflow diagram

Simple overview

Detailed: what happens at every step

Try it: run the pipeline

Practical example: research-and-report agent

A manager pastes in a page of messy market notes and wants a clean one-page report.

In this example, "research" means pulling facts out of the notes you supply. To research the live web, you would give the first step a web search tool. See Tool.

Code example

Runnable Python. It needs pip install anthropic, the ANTHROPIC_API_KEY environment variable on your computer or server, and a notes.txt file.

# sequential_report.py: research, then analysis, then draft, then review.
import json
import pathlib
import anthropic

client = anthropic.Anthropic(max_retries=3)  # the SDK retries network and rate-limit errors for us
MODEL = "claude-opus-5-5"
CHECKPOINT = pathlib.Path("checkpoint.json")

def ask(instructions: str, material: str) -> str:
    """One focused Claude call: this step's instructions + the previous step's output."""
    response = client.messages.create(
        model=MODEL,
        max_tokens=16000,
        messages=[{"role": "user",
                   "content": f"{instructions}\n\n<material>\n{material}\n</material>"}],
    )
    return "".join(b.text for b in response.content if b.type == "text")

# Each step: (name, instructions, a simple quality check for its output)
STEPS = [
    ("research", "List the 5 most important facts in this material as bullet points. Use only the material.",
     lambda out: len(out.strip().splitlines()) >= 3),
    ("analysis", "Using these facts, identify 2 trends and 1 risk. Label them TREND and RISK.",
     lambda out: "TREND" in out and "RISK" in out),
    ("draft", "Write a 200-word report for a manager from this analysis. Start with a one-sentence summary.",
     lambda out: len(out.split()) > 80),
    ("review", "Improve unclear sentences and remove unsupported claims. Return only the final report.",
     lambda out: len(out.split()) > 80),
]

def run_pipeline(source_text: str) -> str:
    # If an earlier run stopped part-way, pick up where it left off.
    state = json.loads(CHECKPOINT.read_text()) if CHECKPOINT.exists() else {"done": []}
    material = state.get("last_output", source_text)

    for name, instructions, check in STEPS:
        if name in state["done"]:
            print(f"[done] {name} (skipped: already done, loaded from checkpoint)")
            continue
        for attempt in (1, 2):                     # each step gets at most two tries
            output = ask(instructions, material)
            if check(output):
                break
            print(f"[retry] {name}: output failed its check (attempt {attempt})")
        else:                                       # runs only if both tries failed
            raise RuntimeError(f"Step '{name}' failed twice. Stopping so a person can look.")

        material = output                           # the baton passes to the next step
        state = {"done": state["done"] + [name], "last_output": material}
        CHECKPOINT.write_text(json.dumps(state))    # save progress after every step
        print(f"[done] {name}")

    CHECKPOINT.unlink()                             # finished, so clear the checkpoint
    return material

if __name__ == "__main__":
    print(run_pipeline(pathlib.Path("notes.txt").read_text()))

Expected output (wording varies):

[done] research
[retry] analysis: output failed its check (attempt 1)
[done] analysis
[done] draft
[done] review
Summary: E-scooter demand grew strongly this year, but battery costs are a rising risk.
...

Step-by-step explanation

1. anthropic.Anthropic(max_retries=3): the official SDK automatically retries temporary problems such as network errors and rate limits.
2. ask() makes one focused call. The previous result is wrapped in <material> tags so Claude can clearly tell the instructions from the data.
3. STEPS lists the chain in order. Each entry has a name, instructions and a small check function (a gate).
4. At the start, run_pipeline loads the checkpoint if one exists, so finished steps are skipped.
5. The inner for attempt in (1, 2) loop is the retry: if the check fails, the step runs once more.
6. The for … else block runs only when every attempt failed. The pipeline then stops on purpose instead of passing bad work forward.
7. material = output is the most important line: it's how one step's result passes to the next.
8. After each step, progress is written to checkpoint.json. When everything is done, the checkpoint is deleted.

Passing results between steps

• Pass only what's needed. The draft step needs the analysis, not the raw notes. Smaller inputs are cheaper and keep Claude focused.
• Label the data clearly, for example with tags like <material>, so instructions and content don't get mixed up.
• Use structure when the next step is code. If a program, not Claude, reads the output, ask for JSON. The Claude API's structured outputs feature can guarantee the format.

Error handling, retries and checkpoints

Use cases: when to use it, and when not to

Advantages and limitations

Best practices

• Give each step one goal and a clear, testable output.
• Add a gate wherever a bad output would be expensive to carry forward.
• Log each step's input and output while you're developing.
• Start with the fewest steps that work, and add more only if quality improves.
• Save checkpoints for long or expensive chains.

Knowledge check

Mini project

Key takeaways

• Sequential workflows run steps in order and pass each result forward.
• Focused steps plus checks between them give reliable, high-quality results.
• Use limited retries, checkpoints and a safe stop when things go wrong.
• If steps don't depend on each other, don't force them into a line.
• It's a general pattern ("prompt chaining") that you build in code, not a Claude setting.

Further learning

• Building effective agents, the "Prompt chaining" section (Anthropic engineering blog)
• Prompt engineering overview (official docs)
• Structured outputs for passing JSON between steps (official docs)
• Anthropic Python SDK, including automatic retries (official GitHub repository)