Simple-IT: Practical Low-Latency Signature-Free BFT Consensus

arXiv:2606.14404 · cs.DC · Submitted 2026-06-12 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: I'm Tom.

Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.

Tom: We're looking at the paper: "Simple-IT: Practical Low-Latency Signature-Free BFT Consensus".

Jane: Here's the gist of the paper. Simple-IT proposes a new leader-based, signature-free BFT consensus protocol that achieves theoretical latency of 4 message delays (one more than the optimum) and only 3 on its optimistic path, while matching the throughput and latency of state-of-the-art quantum-vulnerable protocols experimentally <ref:2606.14404#pg2> Recent advances in quantum computing pose a looming threat to most current Byzantine fault-tolerant (BFT) consensus protocols, which rely on quantum-vulnerable publickey signature schemes such as Ed25519 and BLS12-381 <ref:2606.14404#pg2>.

Tom: Instead of switching to much more expensive post-quantum secure signature schemes, an alternative is to use signaturefree protocols, which rely only on cheap, post-quantum secure authenticated channels <ref:2606.14404#pg2>.

Jane: While previous work on the Sailfish++

35: protocol showed that stateof-the-art throughput is attainable signature-free, the question of latency is still open <ref:2606.14404#pg2>.

Tom: Protocol Design and Latency Characteristics Simple-IT achieves a good-case latency of 4 message delays when paired with Bracha’s RBC protocol

7: , and only 3 message delays on its optimistic path when paired with Opt-RBC <ref:2606.14404#pg2>.

Title and authors: Jane: So, to recap, this paper "Simple-IT: Practical Low-Latency Signature-Free BFT Consensus" explores whether signature-free consensus protocols can match the performance of current state-of-the-art quantum-vulnerable BFT protocols.

Tom: It's about asking if we can get the same throughput and latency without using those costly public key signatures, which they suggest is a viable path because it relies only on cheap authenticated channels.

Lu: The core idea seems to be adapting the Simplex protocol to this signature-free setting by replacing quorum certificates with convergence mechanisms that aren't needed, which is a smart way to simplify things.

Meng: I wonder how much of that simplification actually helps when you have a lot of Byzantine faults, because those convergence mechanisms usually come with their own complexity tradeoffs.

Lalam: The paper lays out the protocol variants S and Sopt, and it shows that when paired with specific reliable broadcast protocols, they achieve good-case latencies of four message delays and optimistic latencies of three message delays.

The paper's summary: Tom: So what this means for us practically is that they achieved a good-case latency of four message delays when Simple-IT is paired with Bracha’s RBC protocol, which is pretty solid for a leader-based system.

Jane: And if you look at the optimistic path, when they use Opt-RBC, the latency drops to only three message delays as long as at least approximately 5n six parties behave correctly when n equals three f <ref:2606.14404#pg2>.

Lu: That three message delay is significant because it's the theoretical lower bound for tolerating more than one failure, even for protocols that still use signatures, and Simple-IT hits it at the cost of slightly bigger optimistic path quorums than signature-based protocols do.

Meng: Bigger quorums mean more messages to send in the optimistic scenario, so I’m worried about how much bandwidth that translates to when we're running this on a geo-distributed testbed.

Lalam: They also introduced the Reliable Notification protocol, which is novel and guarantees that if every correct party raises an outcome, all correct parties eventually confirm it without needing those traditional certificates.

The paper's improvements: Tom: The authors suggest several specific improvements, like using Reliable Broadcast to notarize blocks and then finalizing them in just one more message delay to get that good-case commit latency down to one RBC plus one delta.

Jane: They also showed how they can use speculative proposal mechanisms, calling them S s and S s opt variants, which allow leaders to propose speculatively before they know if the previous round's proposal was safe.

Lu: This speculative pipeline allows for a proposal pipeline of depth k, which enables a good-case block time of one delta or an optimistic block time of one delta when at most fo parties are faulty.

Meng: If you can reduce the block time to just one delta on the optimistic path, that's much better for real-time data processing pipelines where you need fast feedback loops.

Lalam: They also showed how the shared-mempool design has a substantially lower outgoing bandwidth cost per committed transaction compared to leader-driven erasure-coded RBC, which is a huge win for the network overhead.

Conclusion: Tom: To wrap up, Simple-IT demonstrates that postquantum security in BFT consensus doesn't have to sacrifice performance, and signature-free protocols are a practical way to build quantum-safe systems.

Jane: The key results are the latency numbers: four message delays good case with BrachaRBC, and three message delays on the optimistic path with Opt-RBC when at most fo parties are faulty.

Lu: The implication is that you can have high performance in replicated AI systems without needing to switch to much more expensive post-quantum signature schemes, provided you use these specific reliable broadcast implementations.

Meng: For deployment, the empirical results show that Mempool-Simple-IT actually surpasses Autobahn on both latency and throughput axes, peaking at one hundred seventy thousand transactions per second at roughly zero point five seconds of latency.

Lalam: And we have to remember the limitation they mentioned: their optimistic block time for Simple-IT variants S and Sopt is three delta and two delta respectively when at most fo parties are faulty.

Tom: So, in a nutshell, Simple-IT gives us a practical path toward high-performance quantum-safe replicated systems by using signature-free methods instead of expensive signatures.

Qianyu Yu, Juan Villacis, Giuliano Losa, Zhuolun Xiang, Xuechao Wang

The Hong Kong University of Science and Technology · University of Bern · Stellar Development Foundation · Aptos Labs

cs.DC

Submitted: 2026-06-12

Updated: 2026-10-29

Comments: Fixes a number of correctness issues and makes other improvements

Code: https://github.com/qyu100/Simple-IT

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 97/100

The gist: Simple-IT proposes a new leader-based, signature-free BFT consensus protocol that achieves theoretical latency of 4 message delays (one more than the optimum) and only 3 on its optimistic path…

Terminology

Summary

Simple-IT proposes a new leader-based, signature-free BFT consensus protocol that achieves theoretical latency of 4 message delays (one more than the optimum) and only 3 on its optimistic path, while matching the throughput and latency of state-of-the-art quantum-vulnerable protocols experimentally <ref:2606. p. 014404#pg2>

Motivation for Signature Removal

Recent advances in quantum computing pose a looming threat to most current Byzantine fault-tolerant (BFT) consensus protocols, which rely on quantum-vulnerable publickey signature schemes such as Ed25519 and BLS12-381 <ref:2606.14404#pg2>. Instead of switching to much more expensive post-quantum secure signature schemes, an alternative is to use signaturefree protocols, which rely only on cheap, post-quantum secure authenticated channels <ref:2606. p. 014404#pg2>. While previous work on the Sailfish++ [35] protocol showed that stateof-the-art throughput is attainable signature-free, the question of latency is still open <ref:2606. p. 014404#pg2>.

Protocol Design and Latency Characteristics

Simple-IT achieves a good-case latency of 4 message delays when paired with Bracha’s RBC protocol [7], and only 3 message delays on its optimistic path when paired with Opt-RBC <ref:2606.14404#pg2>. The protocol adapts the Simplex [12] protocol to the signature-free setting by replacing quorum certificates with convergence mechanisms that make them unnecessary <ref:2606. p. 114404#pg2>. Furthermore, it uses Reliable Broadcast (RBC) to notarize blocks and then finalizes them in one more message delay, achieving a good-case commit latency of 1RBC+1δ <ref:2606. p. 114404#pg2>.

Performance and Practical Implementation

The authors developed two implementations, Mempool-Simple-IT and Dispersed-Simple-IT, to evaluate the protocol on a geo-distributed testbed <ref:2606.14404#pg2>. The experimental results show that both variants closely match or surpass their post-quantum-vulnerable counterparts <ref:2606. p. 214404#pg2>. MempoolSimple-IT achieves better latency and throughput than Autobahn across the entire latency-throughput spectrum, peaking at 170,000 transactions per second (92 MB/s) at roughly 0. p. 25 seconds of latency <ref:2606. p. 214404#pg2>.

Liveness and Correctness Guarantees

The protocol ensures liveness through two key design elements: either all correct parties deliver the leader’s proposal, or all correct parties disable round r, or both <ref:2606.14404#pg2>. The round timer is set to a duration of ∆to = (ds + dt)∆ time to ensure that after GST, every round that has a correct leader commits <ref:2606. p. 514404#pg2>. The optimistic block time of Simple-IT variants S and Sopt is 3δ and 2δ respectively <ref:2606. p. 9 p. 9 p. 914404#pg2>.

Conclusion on Security Trade-offs

The results demonstrate that postquantum security in BFT consensus need not come at the cost of performance, and that signature-free protocols are a practical path to quantum-safe, high-performance replicated systems <ref:2606.14404#pg2>. The bandwidth/CPU costs of signature-freedom are negligible relative to data dissemination for leader-based protocols <ref:2606. p. 214404#pg2>.

Related Work Context

Signature-free BFT protocols rely only on authenticated channels after setup and are closely related to unauthenticated and information-theoretic BFT <ref:2606.14404#pg2>. Leader-Based BFT Consensus achieves low latency by leveraging signatures, with protocols like PBFT [11], Simplex [12], Hydrangea [33] and Raptr [39] being examples <ref:2606. p. 014404#pg2>. DAG-Based BFT Consensus disseminates data in parallel and derives an ordering from the resulting DAG, with Sailfish++ [36] extending Sailfish to be signature-free and achieving 3δ latency under optimistic conditions <ref:2606. p. 114404#pg2>. Reliable Broadcast [7] tolerates optimal f. p. 3

Reliable Notification Protocol

The Reliable Notification protocol is novel and may be of more general interest, satisfying Unanimity, Totality, and Validity properties <ref:2606.14404#pg2>. The proof for Validity shows that a correct party confirms e by invoking rn confirm(e) only after receiving ⟨accept, e⟩ messages from 2f + 1 parties <ref:2606. p. 914404#pg2>.

Latency Bounds Summary

The optimistic latency of Simple-IT variants S and Sopt is 3δ if at most fo parties are faulty <ref:2606.14404#pg2>. The optimistic block time of Simple-IT variants S and Sopt is 3δ and 2δ respectively <ref:2606.14404#pg2>. The eventual worst-case view duration of Simple-IT is ∆to+dtδ: 5∆+2δ for variant S (Bracha-RBC) and 8∆+4δ for variant Sopt (Opt-RBC) <ref:2606. p. 914404#pg2>. The optimistic block time of Simple-IT using propose-upon-delivery pipelining is doδ if at most fo parties are faulty <ref:2606. p. 914404#pg2>. The eventual worst-case view duration (Definition 5) of the pipelined-proposal version of Simple-IT is ∆to+dtδ: 5∆+2δ for variant S s (Bracha-RBC) and 8∆ + 4δ for variant S s opt (Opt-RBC) <ref:2606. p. 914404#pg2>. The optimistic block time of Simple-IT variants S and Sopt is 3δ and 2δ respectively <ref:2606.14404#pg2>.

Empirical Evaluation Findings

MempoolSimple-IT surpasses Autobahn on both latency and throughput axes <ref:2606.14404#pg2>. Dispersed-Simple-IT matches DispersedSimplex’s peak throughput with roughly 9 percent worse latency <ref:2606. p. 214404#pg2>. PQ-DispersedSimplex shows the post-quantum signature overhead in the same dispersed setting, at about 1 second latency, has a latency roughly double that of even Dispersed-Simple-IT with Bracha-RBC <ref:2606. p. 214404#pg2>. The shared-mempool design has a substantially lower outgoing-bandwidth cost per committed transaction than leader-driven erasure-coded RBC <ref:2606. p. 214404#pg2>.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Improved BFT consensus in quantum-threat environments by replacing expensive post-quantum signatures with signature-free protocols that rely only on authenticated channels secured by fast symmetric cryptography like HMAC-SHA256. This allows high performance while maintaining security against quantum adversaries, as signaturefree protocols, which rely only on cheap, post-quantum secure authenticated channels offer a viable alternative to expensive schemes.

  2. Enhanced latency in distributed AI systems by implementing the Simple-IT protocol variants S and Sopt, which achieve a good-case latency of 4 message delays and an optimistic path latency of 3 message delays, respectively. This performance level is competitive with state-of-the-art quantum-vulnerable BFT protocols, ensuring faster transaction finality in replicated AI systems.

  3. Increased throughput and scalability in data processing pipelines by utilizing the Dispersed-Simple-IT implementation which uses leaderdriven erasure-coded block propagation. This approach allows for matching DispersedSimplex’s peak throughput with roughly 9 percent worse latency compared to simpler approaches, making it suitable for high-volume AI training data dissemination.

  4. Optimized speculative proposal mechanisms in consensus protocols by implementing the S s and S s opt variants of Simple-IT, which allow leaders to speculatively propose before they determine that the previous round’s proposal is safe. This enables a proposal pipeline of depth k, allowing for a good-case block time of 1 delta or an optimistic block time of 1 delta.

  5. Improved resilience against Byzantine failures in replicated AI systems by leveraging the Reliable Notification protocol, which guarantees that if every correct party raises e, all correct parties eventually confirm e. This mechanism ensures that consensus progress is maintained even when a significant number of nodes are faulty.

Sources

Related papers