Source: Anthropic, "Building effective agents" (published December 19, 2024, still live as of October 2026): https://www.anthropic.com/engineering/building-effective-agents
The seven at a glance
- The augmented model: one Claude call with tools, the building block.
- Prompt chaining: fixed steps, each one uses the answer before it.
- Routing: sort the input first, then send it to the right prompt.
- Parallelization: several calls at once, then put the answers together.
- Orchestrator and workers: one call splits the job and hands out the pieces.
- Evaluator and optimizer: one call writes, another grades, repeat.
- The autonomous agent: Claude picks its own next step until the job is done.
First, one difference that matters
Anthropic splits these into two groups:
- Workflows: you decide the steps in advance and Claude follows them. Patterns 2 to 6 are workflows.
- Agents: Claude decides its own next step and which tools to use. Only pattern 7 works this way.
Anthropic's advice is to find the simplest solution that works and add steps only when they clearly help. For many jobs, pattern 1 is enough.
1. The augmented model (the building block)
What it is: one Claude call that can use extras: search, tools and memory. Every other pattern is built from this.
When to use it: almost always first. Anthropic writes that for many applications, one well-prepared call with the right information and a few examples is usually enough.
Beginner example: give Claude a document you trust (a price list, your FAQ) and ask it to answer a customer question using only that document. One call, one answer.
2. Prompt chaining
What it is: the job is cut into fixed steps. Each step takes the answer from the step before. You can add a check between steps.
When to use it: when the task splits cleanly into the same steps every time. You trade a little speed for a more accurate result.
Beginner example: step 1, ask for an outline of a blog post. Step 2, check the outline against your own short list (does it answer the reader's question?). Step 3, only then ask Claude to write the post from that outline. In Claude Code, the docs call this chaining subagents: "Use the code-reviewer subagent to find performance issues, then use the optimizer subagent to fix them."
3. Routing
What it is: the first step sorts the input into a type, then sends it to the prompt (or model) made for that type.
When to use it: when your inputs fall into clear groups that are better handled separately, and the sorting itself is reliable.
Beginner example: sort incoming emails into three labels: question, refund, support. Each label gets its own prompt. Anthropic's own example: send easy questions to a smaller, cheaper model like Claude Haiku and hard ones to a stronger model like Claude Sonnet.
4. Parallelization
What it is: several calls work at the same time, and the results are put together. Two kinds: split the job into independent parts (sectioning), or run the same task a few times and compare (voting).
When to use it: when the parts don't depend on each other, so running them at once saves time, or when you want more than one opinion before you trust the answer.
Beginner example: paste the same draft into three separate chats. Ask one to check facts, one to check tone, one to check length. Then read the three answers side by side. In Claude Code, the docs show the same idea with subagents: "Research the authentication, database, and API modules in parallel using separate subagents."
5. Orchestrator and workers
What it is: one main call looks at the job, decides which smaller tasks it needs, hands them to worker calls, and puts their results together.
When to use it: when you can't know the steps in advance. The difference from pattern 4: here the main call decides the pieces, you don't.
Beginner example: ask Claude to plan a small website and let it decide which pages are needed, then write each page as a separate task, then put them together. In Claude Code, subagents work this way: each one has its own job description, Claude hands it a task when the task matches that description, and the results come back to the main conversation.
6. Evaluator and optimizer
What it is: one call writes an answer, another call grades it and gives feedback, and they repeat in a loop until the answer is good enough.
When to use it: when you have clear rules for what "good" looks like, and feedback actually makes the answer better.
Beginner example: ask Claude to write a short product description. In a second chat, paste your rules (under 80 words, no jargon, ends with a question) and ask it to grade the description against them. Send the feedback back to the first chat and repeat until it passes your rules.
7. The autonomous agent
What it is: Claude gets a goal, then plans and works on its own, using tools and checking the results at each step, in a loop until the job is done or it hits a stopping point you set.
When to use it: for open-ended jobs where you can't predict the number of steps or write a fixed path. It costs more, and mistakes can stack up, so Anthropic recommends lots of testing in a safe place and clear limits.
Beginner example: in Claude Code, give it one small, safe job in an empty folder ("build a one-page to-do list in index.html, then open it and check that adding an item works") and watch the steps it chooses. Keep a person in the loop and stop it if it goes off track.
How to pick yours
- Write down one task you repeat every week.
- Start at pattern 1. Move down the list only if the simpler pattern really can't do the job.
- Most beginner tasks land on 1, 2 or 3.
The honest part
- These are patterns, not products. You can mix them (a chain with a router inside it, for example).
- Anthropic's post notes that much of the tooling it describes has changed since December 2024. The seven patterns are the same.
- More steps cost more time and money. Add one only when it clearly makes the result better.