Roles, Debate & Collaboration

A single agent doing everything is like one person who is simultaneously the author, the fact-checker, and the editor of a report. They will miss their own mistakes, because the same reasoning that produced the error also evaluates it. The fix is structural, not just smarter prompting: split the work across agents that have different jobs, different information, or different vantage points, and let them check each other.

This is the unifying idea behind every pattern in this lesson. Collaboration helps for two distinct reasons:

1. Specialization — a focused agent with a tailored prompt, its own tools, and a single objective carries less context and makes fewer errors than a generalist juggling everything at once.
2. Independent perspectives — when several agents reason separately and then reconcile, idiosyncratic errors tend to cancel while correct reasoning reinforces.

Anthropic's production multi-agent research system (June 2025) is the headline proof: a Claude Opus 4 lead researcher coordinating Claude Sonnet 4 subagents beat single-agent Opus 4 by over 90% on their internal research eval. But it consumed roughly 15× more tokens. Collaboration is a lever, not a free upgrade — the rest of the lesson is about pulling it deliberately.

The most dependable way to use multiple agents is to give each one a role: a tailored system prompt, a scoped tool set, and one clear objective. A common four-role team:

• Planner — decomposes the goal into ordered subtasks; holds the strategy, not the details.
• Researcher — gathers facts via search/retrieval tools; returns evidence, not opinions.
• Critic — stress-tests proposals, finds gaps and errors; has no incentive to defend the work.
• Executor — carries out concrete steps (write code, call APIs, draft the output).

Crucially, role specialization is a prompting technique, not a model-selection one. The same base model is instantiated several times with different system prompts and tools — you do not need different underlying models. Each role gets less context and a narrower job, which reduces cognitive load and per-call token cost.

In frameworks this is first-class: CrewAI gives every agent a role, goal, and backstory; LangGraph models roles as nodes; the OpenAI Agents SDK uses handoffs between role-defined agents.

from crewai import Agent

planner = Agent(
    role="Planner",
    goal="Break the objective into an ordered, verifiable task list",
    backstory="A meticulous strategist who never writes code, only plans.",
    tools=[],  # planning needs no external tools
)

critic = Agent(
    role="Critic",
    goal="Find flaws, missing cases, and unsupported claims in a draft",
    backstory="A skeptical reviewer rewarded only for catching real problems.",
    tools=[search_tool],
)

Think of a panel of experts arguing toward a verdict: each states a position, hears the others, and refines. Multi-agent debate works the same way — N agents independently propose an answer, read each other's responses, and iteratively revise across several rounds until they converge. The foundational result — Du et al. (2023), Improving Factuality and Reasoning through Multiagent Debate — showed this improves mathematical reasoning (on GSM8K, a grade-school math word-problem benchmark) and reduces hallucination versus a single pass. ChatEval (ICLR 2024) extended it to evaluation: diverse critic roles judging a response agreed with human ratings far better than a single GPT-4 judge — roughly 10% higher Kendall-τ (a rank-correlation score, where higher means closer to human judgment) on the TopicalChat benchmark.

The catch, established by Smit et al. (Should we be going MAD?, ICML 2024), is that debate does not reliably beat simpler methods like self-consistency unless it is carefully tuned. The two failure modes to know:

• Sycophancy / consensus collapse — LLMs are agreeable by default, so a debate can converge on a wrong answer before the correct one surfaces, scoring below a single agent. A confident majority can bully a correct minority into conforming ("tyranny of the majority").
• Degeneration of thought — agents become overconfident and stop genuinely considering new perspectives, while "problem drift" decays the discussion over long runs.

Diversity is the antidote. ChatEval's gains came from heterogeneous roles (one judging factual accuracy, one style, one relevance); homogeneous agents lose most of the benefit.

Sometimes you don't need agents to argue — you just need them to vote. Ask a hard question to five people who can't see each other's answers, then go with the majority: the lone mistakes cancel out and the common answer wins. That is the intuition behind self-consistency, and it is debate's cheaper cousin. Self-consistency (Wang et al., 2022) runs one model multiple times independently, sampling different reasoning chains, then takes the majority answer. There is no inter-agent communication at all — and that is the whole point.

This is the most common confusion in the field, so be precise:

Because samples are independent, self-consistency is immune to sycophancy — no agent can talk another out of a correct answer. Smit et al. found properly tuned self-consistency is often competitive with debate, and it is markedly simpler and cheaper. Ranked-voting variants (2025) further improve over plain majority voting for reasoning tasks.

The practical rule: debate only earns its extra cost when agents bring genuinely different information or tools to the table. If they would all reason over the same context, you usually want self-consistency — sample several times and vote, rather than letting agents negotiate.

The generator–critic loop is the most cost-efficient collaboration pattern, because it adds just one extra agent call per iteration while providing structured external feedback. It is directed and asymmetric: agent A produces a draft, agent B critiques it, A revises — repeat until the critic is satisfied or a cap is hit.

This is not the same as debate. Debate is an N-agent symmetric pattern where everyone sees everyone and converges on consensus; generator–critic is a two-agent directed pipeline with distinct producer and reviewer roles. The asymmetry is a feature — the critic has no draft to defend, so it is far less prone to sycophancy.

def generator_critic(task, generate, critique, max_rounds=3):
    draft = generate(task)
    for _ in range(max_rounds):
        review = critique(task, draft)
        if review["approved"]:
            return draft
        draft = generate(task, feedback=review["feedback"])
    return draft  # return best effort after the cap

Research has extended multi-role loops in various directions — for example, recent self-training frameworks (such as SAGE, 2026) chain four roles like Challenger, Planner, Solver, Critic to evolve a model's weights from self-generated data. Note the distinction: that is a training-time technique, not a runtime inference pattern like the loop above. For runtime use, the two-agent generator–critic version captures most of the collaboration value at the lowest cost and is the pattern to reach for first.

Collaboration scales cost faster than benefit, and there is real research on where the curve flattens.

• Agent count and rounds. A 2025 literature review found the sweet spot is 3–4 diverse agents over 2–4 rounds. Beyond that, accuracy plateaus or degrades from problem drift and degeneration of thought. More is not better.
• Context explodes quadratically. In a fully-connected debate, every agent reads every other agent's output, so tokens scale ~O(N²) per round. A 6-agent debate needs roughly 6× the tokens of a single pass — and debate systems often incur ~6× the compute of single-agent inference.
• Token overhead is pattern-specific. The headline "15× cost" applies to deep-research orchestration like Anthropic's, not to every multi-agent system. A simple generator–critic loop adds only ~1–2× per iteration.

The industry has converged accordingly: in 2026, major vendors (Anthropic, OpenAI, AutoGen/AG2, Cognition, LangChain) default to orchestrator + isolated subagents, with supervisor/orchestrator-worker as the dominant topology. Peer-mesh debate is reserved for specific high-value accuracy scenarios where its cost is justified.

The discipline mirrors the whole course: use the least amount of collaboration that solves the problem. Add a critic before you add a debate; add a vote before you add a mesh.