Multi-Agent Orchestration: Planner + Executor + Verifier

A single agent trying to do everything in one context window hits limits: context bloat, role confusion, weak self-critique. Splitting into specialized agents with narrow roles is the cheapest way to add reliability. The patterns below are well-attested in production at Anthropic, OpenAI, and research papers.

Pattern 1 — Planner / Executor / Verifier

# Simplified planner/executor/verifier loop
goal = "Migrate all CSV files in /data to parquet, preserving schemas."

plan = planner(goal)                       # returns ordered steps
for step in plan.steps:
    result = executor(step, tools=TOOLS)   # has MCP + shell + file
    ok, notes = verifier(step, result, goal)
    if not ok:
        fix = planner(f"Step failed: {notes}. Replan from here.")
        plan.splice(step, fix)
    log(step, result, ok)

final_ok, summary = verifier("final", plan.history, goal)

Pattern 2 — Judge / Worker (competitive)

Spawn N workers to attempt the same task with different prompts or temperatures. A judge scores their outputs and returns the best. Used in AlphaCode, Anthropic's research tooling, and most SWE-bench top submissions. More compute, better results.

Pattern 3 — Debate

Two agents argue opposite sides of a question. A third agent reads the debate and picks a winner. Effective for subjective tasks (editorial decisions, design tradeoffs) where a single pass lacks rigor. OpenAI's 'debate' research and Anthropic's CAI pipeline both use variants.

Pattern 4 — Swarm (parallel specialists)

A coordinator sends the same input to specialist agents (e.g., 'legal reviewer', 'UX reviewer', 'accessibility reviewer') and merges their feedback. Better than one generalist because each specialist can have a narrower, sharper system prompt and different MCP toolset. CrewAI and Microsoft Agent Framework lean into this pattern.

LangGraph state skeleton

from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class State(TypedDict):
    goal: str
    plan: List[str]
    current_step: int
    results: List[dict]
    verdict: str

graph = StateGraph(State)
graph.add_node("plan", plan_fn)
graph.add_node("execute", execute_fn)
graph.add_node("verify", verify_fn)
graph.add_node("replan", replan_fn)

graph.set_entry_point("plan")
graph.add_edge("plan", "execute")
graph.add_conditional_edges("verify",
    lambda s: "execute" if s["current_step"] < len(s["plan"])
             else "replan" if s["verdict"] == "fail"
             else END,
)
graph.add_edge("execute", "verify")
graph.add_edge("replan", "execute")

app = graph.compile(checkpointer=MemorySaver())  # durable state

Coordination pitfalls

• Context duplication — N agents each get the full history → N× cost. Use summaries.
• Role leakage — executor starts planning, verifier starts executing. Tighten system prompts.
• Infinite replans — cap replan attempts (e.g., 3) before escalating to human.
• Verifier sycophancy — a verifier trained by the same lab often over-approves. Mix providers.
• Serial bottlenecks — if only the planner can proceed, you lose the parallelism you paid for.

Next lesson: how to actually build the planner/executor/verifier in LangGraph.