Coordination and Consensus Mechanisms

Coordination is the process of making multiple agents work together toward a shared goal. Consensus is the process of deciding what the system believes or should do when agents produce multiple outputs.

In a single-agent system, the agent decides. In a multi-agent system, the architecture must define how decisions are made.

Without coordination, multiple agents may duplicate work, contradict one another, or drift away from the user’s goal. Without consensus, the system may produce a confusing blend of incompatible conclusions.

Coordination mechanisms

Coordination can be implemented in several ways.

Centralized coordination uses an orchestrator to assign tasks and make decisions.

[Orchestrator]
  ├── asks Agent A for research
  ├── asks Agent B for analysis
  └── asks Agent C for critique

This is controllable and easy to log.

Turn-based coordination gives agents a fixed order.

Planner → Researcher → Writer → Reviewer → Finalizer

This is useful for pipelines.

Event-driven coordination triggers agents when relevant events occur.

Event: draft_created → Reviewer runs
Event: test_failed → Debugger runs
Event: policy_conflict → Compliance agent runs

This is useful in stateful systems like LangGraph workflows.

Voting-based coordination asks several agents or model calls to produce answers, then chooses the majority or highest-scored answer.

This is useful for tasks with clear answers, but weaker for open-ended writing.

Consensus strategies

Consensus does not always mean majority vote. Different tasks need different aggregation strategies.

Common strategies include:

• Majority vote: choose the answer most agents agree on.
• Weighted vote: give more weight to specialist agents.
• Judge model: ask a reviewer model to compare outputs.
• Rule-based selection: choose based on deterministic criteria.
• Source-based authority: prefer outputs backed by stronger evidence.
• Human approval: escalate when disagreement is high-impact.

Example weighted vote:

{
  "question": "Is this code change a security risk?",
  "votes": [
    { "agent": "GeneralReviewer", "answer": "low risk", "weight": 1 },
    { "agent": "SecurityReviewer", "answer": "medium risk", "weight": 3 },
    { "agent": "TestAgent", "answer": "no failing tests", "weight": 1 }
  ],
  "decision": "medium risk"
}

The security specialist’s vote matters more for security questions.

Conflict resolution

Agents often disagree. A researcher may report weak evidence. A writer may produce a confident draft. A reviewer may flag unsupported claims.

Define conflict policies in advance:

If factual claims conflict, prefer primary sources.
If a specialist and generalist disagree in the specialist's domain, prefer the specialist.
If confidence is low, state uncertainty or escalate.
If safety reviewer flags high risk, block action until reviewed.

Conflict policies prevent arbitrary synthesis.

Example: research consensus

Suppose three agents evaluate whether a library supports a feature.

{
  "ResearchAgentA": {
    "answer": "supported",
    "evidence": "README mentions beta support",
    "confidence": "medium"
  },
  "ResearchAgentB": {
    "answer": "not fully supported",
    "evidence": "API docs mark the feature experimental",
    "confidence": "high"
  },
  "ReviewerAgent": {
    "answer": "partially supported",
    "evidence": "Feature exists but is experimental",
    "confidence": "high"
  }
}

A good final answer is not “supported” by majority if the nuance matters. It should say:

The feature appears to be partially supported, but it is experimental rather than fully stable.

Consensus should preserve important uncertainty.

Coordination state

Multi-agent coordination needs shared state. The state may include:

• Task goal
• Assigned subtasks
• Agent statuses
• Intermediate outputs
• Open questions
• Conflicts
• Decisions
• Final synthesis

Example:

{
  "goal": "Produce a security review of a pull request",
  "agents": {
    "StaticAnalyzer": "complete",
    "SecurityReviewer": "complete",
    "TestAgent": "failed_tests_found"
  },
  "conflicts": [
    "SecurityReviewer says input validation is insufficient; Implementer says framework handles it."
  ],
  "decision": "Request code change before approval"
}

State makes the system inspectable.

Stopping rules

A multi-agent system needs stopping rules. Otherwise, agents may continue debating, revising, or searching indefinitely.

Stopping rules may include:

Stop when all required subagents have completed.
Stop when reviewer approves final draft.
Stop after maximum debate rounds.
Stop when confidence threshold is reached.
Stop when disagreement requires human escalation.
Stop when budget or latency limit is reached.

Example:

{
  "max_debate_rounds": 3,
  "require_reviewer_approval": true,
  "escalate_if_high_risk_disagreement": true
}

Practical takeaway

Coordination is the difference between a multi-agent system and a pile of model calls. Consensus mechanisms determine how outputs become decisions.

Reliable systems define task assignment, communication rules, conflict policies, stopping conditions, and escalation paths. The more agents you add, the more explicit these controls must become.