"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.
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:
| Key | Validation | Escalation | Timeout default |
|---|---|---|---|
refund.decision | schema + limit rule | human approval above limit, judge below | reject |
ticket.category | allowed values | owner only | owner's value |
report.summary | length, required sections | judge agent | owner's value |
account.hold | boolean | owner, proposals auto-accepted | hold |
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.



