In Part 1, we examined how classic PBFT consensus works and how earlier versions of HotStuff operate. We also looked at how MonadBFT solves HotStuff’s tail-forking issue which is a problem where valid blocks sometimes get left behind in pipelined systems.

This tail-forking problem creates two big issues: 1) it messes up the rewards for honest block builders and 2) can potentially stall the network.

MonadBFT introduces Reproposal rule and No-Endorsement vote mechanisms to eliminate the tail-forking problem, ensuring that any properly approved block from an honest proposer will always make it into the chain.

In part 2 we explore the other two characteristics of MonadBFT which are 1) speculative finality and 2) optimistic responsiveness. We will also explore the implications of MonadBFT for developers.

One-round speculative finality

Besides tail-fork resistance, another major feature of MonadBFT is speculative finality within a single round.

In practical terms, this means that clients and users can receive a confirmation for their transaction immediately after a block receives a supermajority of votes, even before the next round completes.

Recall that in protocols baseline HotStuff, a block usually isn’t considered final (irreversible) until it has gone through at least two phases (e.g. Fast-Hotstuff & Diem-BFT): one phase to get a Quorum Certificate (lock the block with ≥2f+1 votes), and a second phase where the next leader builds on that QC and commits the block.

This two-phase commit is needed to ensure safety: once enough honest nodes have locked a block, no conflicting block can gather a quorum, and the commit in the next round makes it permanent. So normally, a client might have to wait for the next block or next round to be produced before they know the previous transaction is final.

MonadBFT basically allows a transaction to be considered final enough (safe to act on) after just one round of voting. This is called speculative finality.

When a leader proposes a block and the validators vote to form a QC for that block, that block is now in a Voted state (it’s locked by a quorum). In MonadBFT, validators will execute the block’s transactions as soon as they form the QC and even send a preliminary confirmation to clients indicating the block is (speculatively) accepted. This is like saying: “We have a supermajority agreeing on this block. Unless something very unexpected happens, consider this block confirmed.”

This immediate confirmation is optimistic. The block hasn’t been committed in the ledger yet. That will happen when the next proposal comes and finalizes it (QC-on QC), but under normal conditions, nothing will revoke it. The only scenario that can revert a speculatively executed block is if the leader equivocated (i.e. proposed two different blocks at the same height to split the vote)​.

You can think of speculative finality as a nice by-product of tail-forking resistance. The tail-forking resistance guarantees that even if the next leader crashes, the current proposal won’t be abandoned (thanks to reproposal and NEC rules). So the only time a speculatively executed block gets dropped is if the original proposer equivocated (double-signing fault that is provably malicious), which is: 1) detectable via conflicting QCs, 2) slashable and 3) extremely rare.

In previous protocols, they didn’t guarantee that the next leader would repropose the previous block, so tail-forking was possible, breaking speculation assumptions.

Optimistic Responsiveness

In most consensus protocols, there’s a built-in wait after each round like a buffer period or timeout. This is to make sure all messages have arrived before moving forward. It is a protective mechanism meant to handle the worst-case scenario like when a leader crashes or sends nothing at all.

These timeouts are often overly conservative. If the network is functioning normally and all validators are behaving correctly, that fixed wait becomes unnecessary overhead. Blocks could have been finalized faster, but the protocol held back just in case.

MonadBFT introduces optimistic responsiveness which means the protocol can advance immediately based on network messages, instead of always relying on fixed timers. The design principle here can be summarized as “fast when it can, patient when it must.”

MonadBFT is designed such that in both the normal case and even in recovery from a fault, it does not pause for a predetermined timeout if it doesn’t have to​.

• In the happy path (means we have an honest leader): There is no built-in delay in proposing or voting. As soon as a leader has the turn, it proposes a block. As soon as validators receive a valid proposal, they vote. The moment the leader (or rather, the next leader, since votes go to the next proposer in pipelined HotStuff) collects 2f+1 votes, QC is formed and can be disseminated. In an optimistically responsive design, this triggers the next phase immediately.

In practice, this means if network latency between nodes is, say, 100ms, the consensus can potentially finish a round in just a couple of hundred milliseconds (plus computation and aggregation overhead).

It doesn’t wait, for example, a full second “slot time” if it doesn’t need to. This is in contrast with Ethereum mainnet which follows a slot-and-epoch model. On Ethereum, block production is fixed at 12-second intervals. Even if everyone is ready earlier, the protocol waits.

MonadBFT’s approach eliminates unnecessary delay. It retains the pipelined HotStuff structure but removes the rigid “you must wait Δ seconds” rule in the normal case. This means it can outperform time-bound systems in responsiveness without sacrificing safety.

• In the unhappy path (leader failure): In many consensus protocols, when a leader fails to propose a block, other nodes only realize this after a timeout Δ has passed. If Δ is, for example, 1 second, that time is essentially lost. MonadBFT handles this differently. When validators detect a missing proposal, they immediately broadcast timeout messages (TC or Timeout Certificate). As soon as 2f+1 of these timeouts are seen, the next leader takes over. The transition to the new view is triggered by quorum-based evidence, not by the clock.

Comparison with hotstuff-family consensus

MonadBFT builds on the lineage of HotStuff-family consensus protocols, but stands out by achieving a combination of desirable properties that no previous design has been able to fully integrate without trade-offs. Earlier protocols were often optimized for some dimensions like pipelined throughput or linear communication but had to sacrifice others. MonadBFT uniquely manages to combine linear messaging complexity, pipelined commits, strong tail-forking resistance, instant responsiveness without fixed delays, and efficient recovery mechanisms, all while preserving fast finality and high liveness guarantees. The table below summarizes how MonadBFT compares to other rotating-leader BFT protocols across these critical dimensions:

What does this mean for Developers and Users?

For Developers, MonadBFT means a couple of things:

• Simpler Finality Model: With MonadBFT, you can treat a block that has a QC (supermajority vote) as effectively finalized for most purposes, because the protocol will finalize it or slash if not. Developers can safely act on 1-block confirmations with high confidence.
• Improved UX for Apps: If you’re building a high-throughput application (exchange, game, etc.), MonadBFT’s low latency and fork-resistance translate to smoother UX. Users see their actions confirmed almost instantly and won’t commonly encounter confusing reorgs or rollbacks. This lets you design applications that assume finality and quick updates.
• Deterministic Behavior: MonadBFT’s stricter rules (like reproposal requirement) reduce the nondeterminism in block inclusion. There are fewer “corner-case” scenarios where a block might be included or skipped depending on subtle timing such as whether a vote or a timeout reached the leader first. MonadBFT replaces such timing-sensitive ambiguity with explicit rules and verifiable evidence. This makes it easier to reason about the protocol’s correctness and to test it. It also provides clear grounds for identifying faulty nodes (e.g., if someone fails to repropose or proposes a conflicting block, you know they violated the protocol).
• Scalability Headroom: If you are a developer concerned with scaling, MonadBFT gives you more headroom before hitting bottlenecks. You can increase block sizes or validator counts more comfortably than on a quadratic protocol. And features like erasure-coded block dissemination mean that you can push lots of data through the network without overtaxing individual nodes. This makes it possible to aim for higher throughput which opens up design space for more ambitious on-chain applications

For End-Users: A normie user won’t know about any of the stuff we discussed here, but they feel its effects. With MonadBFT underpinning Monad the chain, users can expect all the nice qualities below without sacrificing on decentralization and censorship resistance.

• Faster Confirmations: Transactions (like sending tokens, swapping assets, minting NFTs, executing trades) will confirm very quickly.
• Fewer Surprises: The consistency of the chain state is higher as stuff like tail-forking, which is an re-org essentially, gets eliminated
• Fairness and Transparency: Improvements in consensus indirectly mean that the chain’s operation is fairer. No single validator can easily censor transactions or play games with ordering across blocks.

Conclusion

To recap, MonadBFT introduces four core innovations on top of pipelined HotStuff-style consensus:

Tail-Forking Resistance: MonadBFT is the first pipelined BFT protocol to eliminate tail-forking attacks​. It achieves this by requiring the next leader to repropose the last voted block if the previous leader failed, or otherwise show a No-Endorsement Certificate (NEC) as proof that the block lacked support. This guarantees that no block endorsed by a supermajority will be abandoned, protecting honest leaders’ rewards and preventing malicious reorgs and cross-block MEV extraction.

Speculative Finality in One Round: Validators can confirm a block after a single round of communication (one leader proposal and votes), giving clients an immediate assurance of inclusion​. This speculative confirmation will only revert if the leader equivocates (an act that can be proven and punished), making it a safe assumption in practice.

Optimistic Responsiveness: The protocol operates at network speed without inherent delays​. Leaders advance the consensus as soon as the necessary votes are received, and view changes occur as soon as a quorum of timeouts is observed, rather than waiting for a fixed timeout interval. This optimistically responsive design minimizes wait times and maximizes throughput, while still handling asynchrony and faults robustly when they occur.

Linear Communication: On the happy path (meaning leader is honest), message and authentication complexity is linear in the number of validators. MonadBFT retains HotStuff’s efficient communication pattern, using aggregated signatures and simple leader-to-validators broadcasts, which enables the protocol to scale to 100s of validators without performance bottlenecks.

Disclaimer：

1. This article is reprinted from [michael_lwy]. All copyrights belong to the original author [michael_lwy]. If there are objections to this reprint, please contact the Gate Learn team, and they will handle it promptly.
2. Liability Disclaimer: The views and opinions expressed in this article are solely those of the author and do not constitute any investment advice.
3. Translations of the article into other languages are done by the Gate Learn team. Unless mentioned, copying, distributing, or plagiarizing the translated articles is prohibited.