ArchitecturePart 7 of 8

Consensus for AI Agents: Validation, Judges, Votes and Humans

Agents don't need Raft or Paxos. They need a decision policy for each piece of shared state. How schema checks, judge agents, weighted votes and human approval settle disagreements.

DNotifier Team••5 min read
Back to blog
Consensus for AI Agents: Validation, Judges, Votes and Humans

"Consensus mechanism" is one of those phrases that means very different things depending on who says it. When someone asks how a multi-agent platform reaches consensus, I usually ask back: consensus about what?

Because there are two very different problems hiding under the same word, and only one of them is the one agents have.

What Raft and Paxos actually solve

Algorithms like Raft and Paxos keep several copies of the same data in agreement when machines crash or the network splits. Every node runs the same deterministic operations, and the hard part is agreeing on their order. Byzantine fault tolerant versions go further and tolerate nodes that lie, at the price of needing at least 3f+1 nodes to survive f liars.

That's the right tool for keeping a database or a ledger consistent. Your agent platform probably uses something like it underneath, in its storage layer.

It's not what your agents are arguing about. Your refund agent and your fraud agent aren't disagreeing about the order of log entries. They're disagreeing about a judgment: is this refund OK? Running Raft between them would get you a very reliable record of the disagreement and no decision.

So for agents, "consensus" really means: a decision policy for each piece of shared state, applied the same way every time, with a record of what happened.

Step zero: don't let it become a disagreement

The cheapest disagreement is the one that never reaches a model.

A surprising share of "the agents disagreed" incidents I've looked at were really invalid data. An agent proposed a refund of -40. Another wrote a date in the wrong format. A third set a status that doesn't exist. None of those need a judge. They need a validator.

So before anything else, each state key can carry a schema (types, required fields, allowed values) plus server-side rules ("amount must not exceed policy.refundLimit"). The server rejects invalid writes and says which field failed. No model is involved, which means no model can be talked into accepting a bad value.

I'm firm on this one: an LLM should never be the thing that checks whether a number is positive.

The escalation ladder

For real disagreements, the ones about judgment, we use a ladder. Each key chooses how far up it may go.

1. The owner decides. From part 6: non-owners propose, the owner accepts or rejects. Most disputes end here, because the owner usually has the context to decide.

2. A judge agent. If the owner and the proposer still disagree, a third agent sees both positions and the evidence, and decides. Two rules make this work:

  • The judge should differ from the agents in the dispute: a different model, or at least a different prompt and instructions. A judge running the same model with the same blind spots tends to side with whichever argument sounds more like itself.
  • The judge gets the evidence, not just the two conclusions. "Fraud says deny, refunds says approve" is a coin toss. "Three chargebacks on this card in 30 days, policy says hold above two" is a decision.

3. A weighted vote. For decisions where several agents have a legitimate view, eligible agents vote, weighted by how reliable each has been (that's the trust score in part 8). Require a quorum, and be honest about one thing: five agents built on the same model with similar prompts are closer to one vote than five. Correlated voters don't add much information.

4. A human. For anything with a large blast radius, like money, messages to customers, deletions or permission changes, the decision goes to a person through an approvals inbox. This isn't a failure of automation. It's where the automation should hand over.

Escalation ladder for a contested write
Escalation ladder for a contested write

Timeouts and defaults decide more than you think

Every rung needs a timeout and a default outcome. The judge might fail. The vote might not reach quorum. The human might be at lunch.

The default is a design decision, not a fallback:

  • For money and sending: fail closed. No refund, no email, until someone decides.
  • For safety holds and flags: fail toward the hold. It's cheaper to release a hold than to undo a payment.
  • For low-stakes content: accept the owner's value and move on.

Write the default down per key. The worst outcome is an escalation that times out into "whatever the last write was", which takes you right back to last-write-wins.

Choosing a policy per key

A rough guide we use:

KeyValidationEscalationTimeout default
refund.decisionschema + limit rulehuman approval above limit, judge belowreject
ticket.categoryallowed valuesowner onlyowner's value
report.summarylength, required sectionsjudge agentowner's value
account.holdbooleanowner, proposals auto-acceptedhold

How DNotifier handles it

Schema-checked state. Each key in shared state can have a JSON Schema plus server-side rules. Invalid writes are refused by the server, not judged by an LLM, and the error names the field that failed.

Escalation policy per key. When the owner and the proposer disagree, the key's policy decides: a judge agent, a weighted vote, or human approval through the approvals inbox in the portal. Each has a timeout and a default outcome.

Human approval steps. Workflows can also pause for a person at any step, independent of state, for actions you always want a human to see.

Every decision is traced. The proposal, the checks, who decided, the reason and whether a timeout fired all appear in Traces.

FAQ

Do AI agents need a blockchain or a BFT protocol for consensus?

Almost never. Those protocols solve agreement on ordered data between machines that may crash or lie. Agents disagree about judgments. What they need is validation, a clear owner, and an escalation policy, all enforced by the platform.

Isn't a judge agent just another opinion?

It is, which is why it should see the evidence, run on a different model or prompt from the disputing agents, and sit below human approval for high-stakes keys.

How do you weight votes fairly?

Use measured reliability, not seniority or guesswork. Weights built from traced history (errors, feedback, failed tests) are explained in part 8. And discount correlated agents.

When should a human decide?

When the action is hard to undo or affects customers directly. Make that a property of the key, so it doesn't depend on someone remembering to add an approval step to each workflow.

Trust in multi-agent systems

Part 7 of 8

  1. Part 1Multi-Agent Systems Need Shared Context, Not Just Message Passing
  2. Part 2Agent Identity: How an Agent Proves Who It Is
  3. Part 3Who Can Call Whom: Agent-to-Agent Authorization
  4. Part 4Requested vs Granted: Tool Permissions for AI Agents
  5. Part 5Conflict Resolution on Shared State: Owners and Write Rules for Every Key
  6. Part 6Version-Checked Writes and Proposals: Optimistic Concurrency for AI Agents
  7. Part 7Consensus for AI Agents: Validation, Judges, Votes and Humans
  8. Part 8Agent-to-Agent Prompt Injection and Earned Trust

Tags

#multi-agent-systems#agent-trust#multi-agent consensus#ai agent consensus mechanism#judge agent#agent voting#human in the loop escalation

Keep reading

Related articles

View all →