What does multi-agent Claude actually mean in practice?

Multi-agent Claude means running more than one Claude instance as part of a single workflow. In practice this looks like: dispatching two Claude agents to work on independent subtasks simultaneously (parallel dispatch), using a smaller Claude model for quick lookups and a larger one for deep analysis (model routing), or having one Claude agent review another's output before it reaches you (supervision loops). It's an organizational pattern, not a separate product.

How do Claude agents pass context to each other?

Agents share state through files. One agent writes its output to a structured file (JSON, Markdown, plain text), and the next agent reads that file as its input context. This is the shared-state pattern: a file acts as the handoff point between agents. More sophisticated setups use a shared state file that all agents can read and write, with each agent responsible for a defined section. The key discipline is schema: agree on the structure before you build the pipeline.

When should I use multiple Claude agents instead of one?

Use multiple agents when two conditions are true: the tasks are genuinely independent (they don't need each other's output to proceed), and the tasks together would take longer sequentially than the coordination overhead of running them in parallel. If the tasks are sequential, a single agent with a multi-step prompt is simpler and less fragile. Multi-agent patterns pay off most clearly when you have 3+ independent tasks that would each take more than a few minutes.

// topics

patriola.com

Topic guide

Claude Multi-Agent Workflows

What multi-agent Claude actually looks like in practice — not the whitepaper version.

What it actually is

More than one Claude, working as a system

Multi-agent Claude gets presented as a research concept. In practice it's a handful of patterns that intermediate users can build with the tools they already have: Claude Code, a terminal, and a clear picture of how tasks decompose. There's no special infrastructure required — just a different way of thinking about how work gets distributed.

The core idea is simple: some work is faster and better when split across multiple agents than when handled by one. The patterns below are the practical expressions of that idea. Patriola's Guide to Claude: AI Teams covers the full system.

Pattern 1

Parallel dispatch

Parallel dispatch means sending multiple independent tasks to separate Claude agents simultaneously, instead of running them one after another in a single session. The prerequisite is independence: the tasks cannot need each other's output to proceed. When that condition is met, parallel dispatch can cut wall-clock time by half or more on multi-task workloads.

In Claude Code, parallel dispatch means opening multiple terminal sessions and running separate Claude instances, each with its own focused prompt. One agent handles the research task. Another drafts the outline. A third runs the code analysis. Each works simultaneously. You collect the outputs and synthesize — or hand that synthesis to a fourth agent.

The practical discipline: define the task boundaries before dispatching. Agents that overlap on scope create conflicts. Agents with clear, non-overlapping responsibilities produce outputs you can combine without rework.

Pattern 2

Model routing

Not every task needs the same model. Quick classification, short lookups, simple rewrites — these run well on smaller, faster models. Complex analysis, nuanced writing, architecture decisions — these benefit from the largest available model. Model routing is the practice of matching task size to model capability deliberately, rather than using the same model for everything by habit.

In practice this means: before dispatching, ask whether the task is a lookup or a judgment call. Lookups go to a fast model. Judgment calls go to the most capable model in your stack. The cost and speed difference is significant on any workload with dozens of Claude calls per day.

Pattern 3

Supervision loops

A supervision loop is a workflow where one Claude agent reviews another's output before it reaches you. Agent A produces a draft. Agent B reviews it against a rubric and returns a structured critique. You see the critique alongside the draft — or the loop runs another iteration automatically before surfacing anything.

Supervision loops are most useful when: output quality matters more than speed, you're working at a scale where reviewing everything manually isn't practical, or you've identified specific failure modes (tone drift, missed constraints, hallucinated details) that a reviewing agent can catch systematically. The reviewing agent's prompt is the critical design decision — it needs to know what "good" looks like for the specific output type.

Pattern 4

Shared state

Agents in a multi-agent system communicate through files. One agent writes its output to a structured file; the next reads that file as input context. This is the shared-state pattern. The file is the handoff point — it's how context moves between agents without either agent needing to be aware of the other's existence.

A simple shared-state setup: a JSON file with defined sections for each agent's contribution. Agent A writes to the "research" section. Agent B reads the "research" section and writes to the "draft" section. Agent C reads both sections and produces the final output. Each agent sees a complete picture of prior work without any inter-agent communication channel more complex than a file read.

You — dispatching parallel agents I need to (1) research the three main competitors for our landing page copy, (2) draft a first-pass outline for the page, and (3) pull the key metrics from last quarter's analytics file. These are independent. How do I run all three simultaneously?

Claude Open three terminal windows. In each, start a Claude Code session with a focused prompt for that task only. Window 1: competitor research prompt with a target output format (structured Markdown). Window 2: outline draft with your page goals as context. Window 3: analytics extraction with the file path and the specific metrics you need. All three run simultaneously. When they're done, paste all three outputs into a fourth session and ask me to synthesize. Total wall-clock time is the slowest of the three, not the sum of all three.

Agent delegation prompt template

You are [agent role — e.g., "a research agent"]. Your only task in this session is [single, specific task statement].

Context: [relevant background the agent needs to do its task]

Constraints:
- Scope: [what is in and out of scope]
- Output format: [exact format — JSON, Markdown, plain text with specific structure]
- Length: [target length or field limits]
- Do not: [specific things this agent should not do or decide]

When you are done, write TASK COMPLETE as the final line of your output.

Go deeper

Book 5 is the full system

The patterns above get you started. Book 5 — Patriola's Guide to Claude: AI Teams — covers the complete multi-agent architecture: team composition, shared-state schema design, supervision loop configuration, error handling between agents, and the orchestration patterns that make large Claude systems reliable. Read AI Teams for the complete architecture.

Two more real multi-agent patterns from this series: The Council Pattern, on running parallel agents as independent reviewers rather than a single pipeline, and Federation, on coordinating agents across separate, isolated projects.

More on this

For scheduling the individual jobs a multi-agent team runs, see Claude Automations. For how those agents share state and memory with each other, see Claude Memory System.

Book 5 is coming

Read the book

Team composition, shared-state schema design, supervision loops, and orchestration patterns.