Verification and Consensus

A single agent has a blind spot: it can't reliably catch its own mistakes, because the same reasoning that produced an error also reviews it. Multi-agent systems can exploit independence — one agent checking another's work is far more likely to surface a problem than self-review. This lesson covers the two main ways to turn extra agents into extra correctness.

Independent and adversarial verification

The simplest verification pattern adds a second agent whose only job is to check the first agent's output. Crucially, the checker should be independent — given the original task and the proposed answer, but not the first agent's reasoning, so it forms its own judgment instead of rubber-stamping. An even stronger variant is adversarial: instruct the checker to actively try to break the answer — find the unsupported claim, the missing edge case, the step that doesn't follow.

• A writer drafts; a critic is told to assume it's wrong and find why.
• A researcher answers; a fact-checker re-verifies each claim against sources.
• A code generator proposes a change; a reviewer hunts for the bug.

This division of labor works because the critic's prompt is narrow and skeptical, a posture the original agent — optimizing for a complete, confident answer — doesn't naturally hold.

Majority voting

When a task has a checkable or discrete answer, run it through several independent agents and take the majority vote. Different samples make different mistakes; errors that one agent makes, two others often don't, so the consensus answer is more reliable than any single run. Voting is most effective when:

• The answers are comparable — a classification, a yes/no, a structured extraction — so "agree" is well defined.
• The agents are genuinely independent — different prompts or sampling, not the same call run three times, which just repeats the same bias.
• The cost of being wrong justifies paying for three-to-five runs instead of one.

Voting trades tokens for confidence. It catches the random errors a single agent would have shipped silently.

Know what verification can't do

Verification raises reliability; it doesn't guarantee it. If every agent shares the same training bias or the same flawed source, they can be confidently wrong together — consensus among correlated agents is false comfort. And each extra verifier adds cost and latency. Use these patterns where errors are expensive and detectable: a financial extraction, a compliance check, a generated migration. For low-stakes or easily-corrected output, a single call plus a cheap validation is the better trade. The next lesson makes that cost-benefit explicit.