Byzantine fault tolerance

Also known as: BFT

On this page 8

Byzantine fault tolerance (BFT) is the property of a distributed system that lets honest participants reach agreement on a single, correct state even when some participants crash, send conflicting messages or deliberately try to deceive the rest. Consensus mechanisms in public and private blockchains are judged largely by how much Byzantine behavior they can absorb before safety or liveness breaks down.

The name comes from the Byzantine generals problem, a thought experiment published in 1982 in which army commanders must agree on a common plan while some of them, and some of their messengers, may be traitors. A system is called Byzantine fault tolerant when it guarantees agreement as long as the share of faulty participants stays below a proven threshold, which for classical protocols is fewer than one third of the voting power.

How Byzantine fault tolerance reaches agreement

BFT protocols reach agreement by making participants exchange signed votes in several rounds and accept a decision only when a quorum of votes supports it. Because every message carries a digital signature, a dishonest node cannot forge the votes of others, although it can still send different votes to different peers, which is called equivocation.

The core arithmetic is simple. With n validators and at most f Byzantine ones, classical protocols require n ≥ 3f + 1 and a quorum of 2f + 1 votes. Any two quorums of that size overlap in at least f + 1 validators, so they always share at least one honest validator, and an honest validator never votes for two conflicting blocks in the same round. That overlap is what prevents two different blocks from being finalized at the same height.

The following table shows how the fault threshold scales with the size of the validator set.

Validators (n)Maximum faulty (f)Quorum (2f + 1)
413
725
1037
1003367
Validator set size and tolerated Byzantine faults

In proof of stake systems the count is usually weighted by stake rather than by node, so the condition becomes less than one third of total stake controlled by misbehaving validators.

Safety, liveness and network timing assumptions

Every BFT protocol balances two guarantees. Safety means honest nodes never finalize conflicting blocks, while liveness means the network keeps producing new blocks. A well-known impossibility result shows that no deterministic protocol can guarantee both in a fully asynchronous network if even one node may fail, so designers choose a timing model.

Most production blockchains assume partial synchrony: messages may be delayed arbitrarily for a while, but eventually arrive within an unknown bound. Under this model, safety holds at all times and liveness resumes once the network stabilizes. This is why a BFT chain facing a severe network split typically halts rather than forks.

The table below compares the three timing models used in BFT research and engineering.

Timing modelAssumption about delaysPractical consequence
SynchronousKnown upper bound on delayTolerates more faults but fails if the bound is violated
Partially synchronousBound exists but is unknownSafety always, liveness after the network stabilizes
AsynchronousNo bound at allNeeds randomization, higher message cost
Network timing models in Byzantine fault tolerant protocols

Major BFT protocol families

Modern blockchain consensus builds on a lineage of protocols that progressively reduced communication overhead. Practical Byzantine Fault Tolerance (PBFT), introduced in 1999, showed that BFT could run at useful speed, but its all-to-all voting costs quadratic messages per decision and limits it to a few dozen nodes.

Later designs restructured voting around a rotating leader, aggregated signatures and pipelined rounds, which allows hundreds or even thousands of validators to participate. The table summarizes representative approaches without implying that any single one is universally superior.

Protocol familyKey ideaTypical use
PBFTThree-phase all-to-all votingPermissioned ledgers with few nodes
Tendermint-style BFTRotating proposer, two voting rounds per heightProof of stake application chains
HotStuff and descendantsLinear messaging through the leader, pipelined phasesHigh-throughput validator networks
Gasper-style finality gadgetCheckpoint voting layered over a fork-choice ruleLarge proof of stake networks
Asynchronous BFTRandomized agreement without timing assumptionsResearch and adversarial environments
Representative BFT protocol approaches

BFT compared with Nakamoto consensus

Byzantine fault tolerance and Nakamoto consensus both tolerate malicious participants, but they offer different kinds of certainty. BFT protocols deliver deterministic finality: once a quorum commits a block, it cannot be reverted without at least one third of validators provably misbehaving. Nakamoto consensus, used with proof of work, provides probabilistic finality that strengthens as more blocks are added on top.

The comparison below highlights the practical trade-offs that matter for exchanges, wallets and application developers.

PropertyClassical BFTNakamoto consensus
FinalityDeterministic, often within secondsProbabilistic, grows with confirmations
Fault thresholdBelow one third of voting powerBelow one half of hash rate
Participant setKnown validators with identities or stakeOpen, anonymous miners
Behavior under partitionHalts to preserve safetyKeeps producing blocks, may reorganize
Main scaling limitMessage overhead per validatorBlock propagation and confirmation time
Classical BFT versus Nakamoto consensus

Many current networks are hybrids. They use a longest-chain or fork-choice rule for fast block production and a BFT-style voting layer to mark checkpoints as final, which combines availability with strong economic finality.

Accountability, slashing and economic security

Pure BFT theory assumes a fixed bound on faulty nodes, but open blockchains must also make that bound economically expensive to exceed. Proof of stake systems therefore pair BFT voting with accountable safety: if two conflicting blocks are ever finalized, the protocol can identify at least one third of validators who signed contradictory votes.

That evidence feeds slashing, which destroys part of the offending validators’ stake. The resulting guarantee is often expressed as a cost: reverting a finalized block would require attackers to forfeit at least one third of all staked value, which turns a mathematical threshold into a measurable security budget.

Limitations and common misconceptions

BFT is a precise guarantee with clear boundaries, and several recurring misunderstandings lead to flawed risk assessments.

  • BFT does not stop collusion above the threshold. If one third or more of the voting power coordinates, the chain can halt, and two thirds or more can finalize invalid history.
  • Fault tolerance is not decentralization. A network with 21 validators controlled by a handful of entities may be formally BFT yet socially fragile.
  • Halting is a design choice, not a bug. Choosing safety over liveness means BFT chains stop during long partitions instead of producing competing histories.
  • Message complexity still matters. Large validator sets increase bandwidth and latency, so protocols cap the active set or aggregate signatures.
  • Software bugs are outside the model. A shared client defect can make many honest validators behave identically wrong, which is why client diversity is encouraged.

In simple terms

Imagine a group of people who must agree on one shared record, knowing that a few of them might lie. Byzantine fault tolerance is a set of voting rules that still produces the right answer as long as fewer than one third are dishonest.

Everyone signs their vote, and a decision counts only when a large majority agrees. Because any two large majorities always share at least one honest member, the liars cannot trick the group into accepting two different versions of the record. The key takeaway is that the network stays correct without trusting any single member.

A practical example

A proof of stake network runs 100 validators with roughly equal stake and a block time of about six seconds. During a routine upgrade, a software fault takes 12 validators offline, and a separate operator controlling 8 validators starts broadcasting conflicting votes in an attempt to finalize two competing blocks.

Together these 20 faulty validators remain below the limit of 33, so the remaining 80 honest validators still form the required quorum of 67 votes. Blocks continue to finalize every few seconds, the conflicting votes are recorded as evidence, and the equivocating operator loses part of its stake through slashing. A cryptocurrency exchange that credits deposits after one finalized block sees no reversal, which illustrates the outcome BFT is designed to deliver: continuous, irreversible finality despite failures and attacks.