Multi-Agent Orchestration: Planner + Executor + Verifier

Why multi-agent

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)Planner writes the plan. Executor runs it. Verifier checks. Replan on failure.

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 statePlanner/executor/verifier as an explicit state machine. Checkpointers let you pause, rewind, and resume.

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.