Match each multi-agent production pattern to the workload shape it fits

Match pairs·Medium·4.0 · 0·~2 min·Asked atKore Ai Observe Ai Snap

Attempt it

Drag each answer to line up with its matching prompt

Planner plus executor

Tasks with a large tool surface that exceeds single agent reliability and naturally splits by tool subset

Parallel research plus reducer

Long horizon tasks that benefit from explicit planning and step by step execution by different prompts

Critic loop

Tasks that fit in one system prompt with under 15 tools and have no specific named single agent failure

Retrieval router plus specialist

Tasks that pull from multiple retrieval sources where picking the right one is itself a hard decision

Supervisor plus large worker pool

Tasks with a verifiable quality bar where one pass is often not enough

Single agent

Tasks decomposable into independent sub-queries that can run concurrently and need synthesis

Each multi-agent pattern is the right answer to a **specific workload shape**. Picking the wrong pattern for the workload is the most common source of cost blow-ups and brittleness. - **Planner plus executor**: long-horizon tasks (days of work in a coding agent, multi-step procurement). One agent thinks ahead and emits a structured plan; another agent executes the plan step by step. Devin, OpenHands, and Claude Code subagents all use this. - **Parallel research plus reducer**: tasks that decompose into N independent sub-queries (research a topic from multiple angles, multi-source retrieval). Fan out workers, reduce results with a synthesis agent. LangGraph Send is the canonical primitive. - **Critic loop**: tasks with a quality bar where one pass is often not enough (essay revision, code review, fact-checking). Producer drafts, critic scores, producer revises until threshold or max-iter. - **Retrieval router plus specialist**: tasks where picking the right retriever (vector DB, BM25, web search, internal tool) is itself a hard decision. A small router agent picks; a specialist runs the call. - **Supervisor plus large worker pool**: tasks with a large tool surface that exceeds single-agent reliability (Devin-style 30+ tools across categories). Workers each own a tool subset; supervisor routes. - **Single agent**: tasks that fit in one system prompt with under 15 tools and have no specific named single-agent failure. This is the right answer for most production agent features in 2026. The trap is reaching for multi-agent because it sounds sophisticated. Single agent is on the list because it is the right pattern for most workloads.

**Picking the right multi-agent pattern is reading the workload shape**, not picking a fashionable framework. **Planner plus executor** fits long-horizon work where planning benefits from a different prompt (and often a different model) than execution. Planner emits a structured plan; executor walks it. Devin, OpenHands, Claude Code subagents use this. The split earns its keep because planning rewards reasoning depth and execution rewards tool-use reliability. **Parallel research plus reducer** fits tasks that decompose into independent sub-queries. Planner identifies N angles; N workers run concurrently; reducer synthesises. Map-reduce shape. LangGraph's Send is the canonical primitive. **Critic loop** fits tasks with a verifiable quality bar where iteration helps. Producer drafts, critic scores, producer revises until threshold or max-iter. The discipline is the threshold and the cap. **Retrieval router plus specialist** fits tasks where the routing decision is itself hard. A small router picks which retriever (vector store, BM25, web search); a specialist runs the call. **Supervisor plus large worker pool** fits tasks with a tool surface that exceeds single-agent reliability. Devin uses 30+ tools split across categories. Supervisor routes; workers own tool subsets. **Single agent** is the default for most production features. Workloads that fit one system prompt, under ~15 tools, with no named single-agent failure should not pay multi-agent overhead. Cursor agent mode, Claude Code's primary loop, most 2026 agent products ship this way. The discipline: **start single, escalate on evidence**. Other patterns earn their cost only when the workload shape genuinely fits.

TL;DR

Each pattern fits a workload shape: planner-executor for long-horizon, parallel-reducer for decomposable, critic for verifiable, router for retrieval, supervisor for large tool surface.

Memory aid

Easy to grasp

Imagine choosing the right kind of team for different jobs. Building a house needs a planner who sketches the design and builders who execute - that is planner-executor. Searching for a lost pet across a neighbourhood needs many people fanning out and reporting back - that is parallel research with a reducer. Editing a novel needs a writer and a strict critic going back and forth - that is the critic loop. A library help desk needs someone who picks the right librarian for each question - that is the retrieval router. A workshop with many specialised machines needs a foreman directing the right machinist - that is supervisor plus workers. And many everyday tasks just need one good person with a few tools - that is single agent.

Key concepts

Multi-Agent Systems

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Multi-agent design in 2026 is not 'pick a framework and a topology.' It is 'read the workload shape and pick the pattern that fits.' Each of the six patterns below solves a specific failure mode that the alternatives do not. Picking the wrong pattern for the workload is the most common cause of multi-agent systems that cost 5-10x what they should, take 3x the latency they need, and ship with debuggability that punishes the on-call rotation.

This walkthrough names each pattern, gives the workload shape it fits, identifies the specific failure mode it solves, and shows how production systems compose 2-3 patterns into workflows that match the actual shape of the work.

Diagnostic question: before picking a pattern, ask 'what shape is this workload?' Long-horizon, parallel-decomposable, quality-iterable, route-heavy, large-tool, or simple? Match the pattern to the shape.

Planner-executor and parallel-research patterns

Planner plus executor

Shape: long-horizon work (10+ steps), planning benefits from explicit reasoning, plan is partially verifiable before execution.

Pattern: one agent reads the goal and emits a structured plan (ordered steps, expected outputs per step). Another agent (often on a different model) walks the plan step by step, executing tool calls.

Failure mode it solves: a single agent doing long-horizon work loses track of the goal mid-execution as the context window fills with tool outputs. The planner has a clean context to reason in; the executor has a focused per-step context.

Bonus: enables model splits. Plan on Claude Opus 4.7 or GPT-5.5 (reasoning depth); execute on Claude Haiku 4.5 or GPT-5.5-mini (faster, cheaper).

Real examples: Devin, OpenHands, Replit Agent, Claude Code subagents.

When it does not fit: short tasks (under 5 steps) where the planning overhead is larger than the task.

Parallel research plus reducer

Shape: query decomposes into N independent sub-questions, N is data-dependent, parallel cost is worth the wall-clock improvement.

Pattern: planner identifies sub-queries. Send-style fan-out spawns N workers. Each worker runs independently. A reducer (often a synthesis agent) merges results.

Failure mode it solves: sequential research is slow, and single-agent research often stops retrieving early because the context starts looking like an answer. Fan-out parallelises; the separate reducer ensures synthesis is its own intentional step.

Real examples: Anthropic's research mode in Claude Opus 4.7, multi-source RAG systems, parallel evaluation pipelines.

When it does not fit: sub-queries with sequential dependencies (the answer to query 2 depends on query 1). Forcing parallelism on dependent work just blocks branches against each other.

Critic loop and retrieval router

Supervisor-plus-pool and single agent

Pattern composition and how to pick

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Devin (Cognition) composes planner plus executor with supervisor plus large worker pool: a planner produces the task list and an executor crew of 30+ tools runs it.
Anthropic's research mode in Claude Opus 4.7 uses parallel research plus reducer for complex queries: fan-out subqueries, synthesis at the end.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow would you compose patterns for a multi-source RAG system over confidential and public data?

Retrieval router picks among internal vector store, BM25 over docs, and public web search. Parallel research fans out to chosen sources. Reducer synthesises. Optionally a critic loop verifies the answer against retrieved evidence. Three-pattern composition: router + parallel + (optional) critic.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Forgetting that single agent is in the list on purpose. The right pattern for many production tasks is one agent with a tool belt, not any multi-agent topology.

60 second bullets to scan on the way to the call.

Name each pattern and the workload shape it fits
Identify the specific failure mode each pattern solves

Primary sources. Browse if you want the original framing.