Why a coordinator does not solve the problem
A coordinator is convenient while the system lives in one process on one machine. As soon as the participants are distributed, the coordinator takes on three properties that are expensive in production: it becomes a throughput bottleneck, a single point of failure and the only one everyone is obliged to trust.
The third property is usually underrated. This is not about malice. A software bug, stale state or a partial loss of connectivity is enough for the coordinator to start handing out decisions that contradict what the others see. And the system will accept them, because trust is built into the architecture.
What the Byzantine fault model means
The usual fault model assumes that a node either works correctly or does not work at all. The Byzantine model allows for worse: the node is running but behaves arbitrarily. It sends different versions to different participants, replays old messages, signs with someone else’s name, votes twice.
For a network of autonomous agents this is the accurate way to state the problem. A participant may run on someone else’s machine and on a different version of the code, its clock may drift from the others, it may be compromised. The protocol has to stay correct under exactly these conditions.
How one consensus cycle works
- The round’s leader sends out a signed proposal: which change to the shared state it proposes to commit.
- Each replica checks the proposal on its own (the validity of the state transition, the sequence number, the signature) and replies with its own signed vote.
- The leader collects a quorum of votes from different participants and sends out a commit certificate.
- Each replica checks every signature in the certificate, writes it to its log and only then applies the change.
The arithmetic of fault tolerance
For a committee of n participants, the number of replicas that may behave arbitrarily and the quorum size are calculated in the classical scheme like this:
f = floor((n - 1) / 3)
quorum = 2f + 1In practice, a committee of four survives one failed or malicious participant, provided the other three can communicate. The formula also carries an unpleasant truth: fault tolerance is paid for in participants. To survive two, you need seven. Consensus is expensive, so it is worth applying selectively.
The 2f + 1 quorum is correct when there are exactly 3f + 1 participants: four, seven, ten. With any other committee size, two quorums are no longer guaranteed to overlap in an honest replica, and the quorum has to be calculated differently. The current version of the open runtime calculates the quorum as 2f + 1 for any committee size, and a replica does not refuse to vote for a second, different proposal with the same sequence number. That is why we call it a PBFT-style consensus protocol for a fixed set of nodes and claim no fault-tolerance guarantees for it.
What the protocol must reject
- a repeat vote from the same participant in one certificate, or else a single active node can make up the quorum;
- votes from anyone who is not on the committee;
- altered commands: the signature has to cover the content, not only the fact of sending;
- a wrong sequence or round number, so that a stale decision is not applied;
- a forged signature and the replay of a previously intercepted message.
All of this is checked before a message reaches the consensus logic: the transport verifies the sender, the recipient, the timestamp and a one-time number. The separation of responsibilities matters here. If the consensus code starts dealing with network security, one bug will destroy both properties at once.
Leader change and catch-up synchronisation
The leader may disappear or fall silent. The participants then vote to change the round, and leadership passes to the next one. This is a routine part of the protocol, not an emergency procedure: the system has to keep working without a person stepping in.
A replica that was unavailable catches up with the others from certificates. It requests every committed decision after its last number and applies them, checking the signatures. It does not need to trust whoever sent the history: each certificate can be checked on its own.
Where an agent system needs this
Not everywhere. Consensus makes sense where a decision is shared and irreversible:
- a change to shared state that all participants see;
- admitting a new participant to the trusted perimeter;
- operations on resources where double spending is unacceptable;
- structural operations: merging a group of participants into one and unfolding it again.
Everything else is decided by the participants themselves or by pairs by agreement; the consent of the whole group is not needed for that. If every action goes through a committee, a living system becomes slow: the price of consensus is paid for every decision, while the benefit appears only where divergence is really dangerous.