A useful reading list with a weak taxonomy. Maryam Miradi's post (LinkedIn, 2026-11-11) names 15 agent patterns in three tiers and links a paper for each. The papers are the value. The tiers blur several real distinctions: five of the fifteen are the same generate-critique-retry loop, and three are the same delegation tree. For teaching, regroup them by who owns control flow and what grounds the check.
The 15 patterns as posted
| # | Pattern (post's name) | Linked source | Fit of the citation |
|---|---|---|---|
| 1 | ReAct | ReAct, Yao et al. 2022 | Exact |
| 2 | Plan-and-Execute | Plan-and-Act, 2025 | Good: separate planner and executor models, with re-planning |
| 3 | Reflection / self-critique | Reflexion, Shinn et al. 2023 | Good, but Reflexion learns from a task signal, not pure self-review |
| 4 | Tool use / function calling | Gorilla, 2023 | Narrow: fine-tuning for accurate API calls |
| 5 | Orchestrator-subagent | LLM multi-agent survey, 2024 | Loose: a survey, not the pattern |
| 6 | Supervisor | AutoGen, 2023 | Loose: AutoGen is conversable agents; supervisor is one setup |
| 7 | Hierarchical agents | AgentOrchestra (TEA protocol), 2025 | Fair: a central planner over sub-agents and versioned tools |
| 8 | Sequential pipeline | LangGraph docs | A framework, not evidence |
| 9 | Parallel fan-out / fan-in | LLMCompiler, 2023 | Good: a DAG of calls run concurrently |
| 10 | MapReduce | Same survey as 5 | Reused link; same pattern as 9 |
| 11 | Debate / adversarial | Multiagent Debate, Du et al. 2023 | Exact |
| 12 | Evaluator-optimizer | Self-Refine, 2023 | Mismatch: Self-Refine is one model, not a separate evaluator |
| 13 | Critic-actor | CRITIC, 2023 | Good: critique grounded in tools |
| 14 | Self-healing / retry | Same as 3 (Reflexion) | Reused link |
| 15 | Human in the loop | Plan-Then-Execute user study, CHI 2025 | Good: editing the plan before it runs changes trust and team outcomes |
The post itself adds one-line definitions and a closing line per tier. It ends with a course promotion and a lead-magnet page. The "400+ agents built" claim is the author's and is not checkable.
What the catalog gets wrong
Duplicates presented as distinct. Reflection, evaluator-optimizer, critic-actor, self-healing retry and debate are one loop: produce, check, revise, stop. They differ only in who checks and what the check is grounded in. Fan-out/fan-in and MapReduce are the same. Orchestrator-subagent, supervisor and hierarchical are one delegation tree at different depths.
The grounding of the check is the variable that matters, and the post hides it. A model reviewing its own output with no outside signal is unreliable on reasoning tasks (Huang et al., "Large Language Models Cannot Self-Correct Reasoning Yet", 2023). CRITIC's gains come from checking against search or a code interpreter. Reflexion needs a task signal such as a failing test. Teach the loop with its grounding: self, another model, a tool or test, or a human.
Single-agent vs multi-agent is the wrong first split. The first decision is whether code or the model owns control flow. A sequential pipeline and fan-out/fan-in are workflows, with code routing between model calls. ReAct and orchestrator-subagent let the model choose the next step. That split predicts cost, debuggability and failure modes better than agent count.
"Coordination under load" is not why to go multi-agent. The real reasons are context isolation (each worker sees only its slice) and parallel breadth. Load is a serving problem.
Tool use is not a pattern beside ReAct. It is the primitive every other pattern uses.
Missing patterns
Routing: classify the request, then send it to a specialised prompt or model. Cheaper than an orchestrator and usually enough.
Prompt chaining with gates: fixed steps with a code check between them. The most common production shape.
Handoff: transfer of the whole conversation to another agent, as opposed to delegating a subtask and getting a result back.
Shared state or blackboard: agents coordinate through a store rather than messages.
Durable execution and checkpointing: resume after a crash or a human pause, without redoing side effects.
Guardrails on actions: policy checks before a tool call, not only on output text.
Memory patterns: what persists between runs and how it is checked (see R040, R059).
Choosing a pattern
Start with one model call plus retrieval and tools. Most tasks stop here.
If the steps are known, write a workflow: a chain or a router, with code checks between steps.
If the steps depend on what the model finds, use a single-agent loop (ReAct) with a step and token budget.
Add a check loop only where an outside signal exists: tests, a schema, a tool, a rubric another model can score reliably, or a person.
Split into sub-agents only for context isolation or parallel breadth, and price it. Multi-agent runs cost several times the tokens of one agent. The baseline to beat is best-of-N from one agent at the same budget (R019).
Put a human at the step where a mistake is expensive or cannot be undone, typically the plan, not every action (the HITL study linked as pattern 15).
Failure modes by tier
| Tier | Failure | Mitigation |
|---|---|---|
| Single agent | Loops without progress; a wrong early thought steers later tool calls | Step and token budgets; progress checks; re-plan on tool error |
| Single agent | Plan goes stale as the world changes | Re-plan after each observation that contradicts the plan |
| Multi-agent | Errors compound down a pipeline; each hop drops context | Typed handoff artifacts; validate at each boundary |
| Multi-agent | Workers duplicate or contradict each other | Disjoint task specs; one owner merges results |
| Multi-agent | Debate converges on a confident wrong majority | Diverse models or prompts; a judge with ground truth where possible |
| Feedback loop | Critic and actor share blind spots (same model) | Ground the critic in tools or tests; use a different model |
| Feedback loop | Loop optimises the judge, not the task (R039, R066) | Hold-out checks; cap iterations; measure regressions, not only gains |
| Human in the loop | Rubber-stamping after many approvals | Fewer, higher-stakes checkpoints; show diffs and evidence |
Review checklist
Who owns control flow at each step: code or the model?
For every check loop: what grounds the check, and what stops the loop?
Is there a single-agent baseline at the same token budget?
What exactly passes between agents, and is it validated?
Which steps have side effects, and are they idempotent or checkpointed?
Where does a human approve, and what evidence do they see?
Are iterations, tokens and wall time capped and logged?
Teaching session plan (60 minutes)
10 min, regroup. Hand out the 15 names. Ask the group to merge duplicates. Land on four families: workflows (chain, router, fan-out), the agent loop (ReAct, plan-and-execute), delegation (orchestrator, supervisor, hierarchy, handoff) and check loops (reflection to debate, plus HITL).
15 min, one loop, four groundings. Same code-generation task with self-review, a second model, unit tests and a human. Compare which catch the planted bug.
15 min, workflow vs agent. Build the same task as a three-step chain and as a ReAct agent. Compare tokens, latency and how easy a failure is to trace.
10 min, when to split. Show a task where sub-agents help (wide parallel research) and one where they hurt (a tightly coupled edit).
10 min, critique the post. Use the citation-fit column above: which links support their pattern, and which are a survey or a framework doc standing in for evidence.
Use the post as a list of names and the linked papers as reading. Link to the post rather than copying its infographic.
Related entries
R056 (20 agentic AI terms, also checked for teaching; same correction that reflection needs an outside signal)
R015 (workflows over agents; the case for code owning control flow)
R019 (learned coordination and the best-of-N baseline any multi-agent design must beat)
R054 (production coding harnesses mostly stay single-agent)
R039 and R066 (check loops that sort by their judge; statistical gates for accepting changes)
R069 (models judge in hindsight better than they act; the critic-actor split)
R077 and R065 (fixed pipelines of narrow agents, with and without a human gate)
R023 (a ReAct loop in about 20 lines)
Sources
Maryam Miradi, LinkedIn post, 2026-11-11
The 13 linked sources in the table above
Huang et al., Large Language Models Cannot Self-Correct Reasoning Yet, 2023 (not linked from the post)