# consensus algorithm

A consensus algorithm is a distributed-computing procedure that enables distributed processes or nodes to agree on a single value or decision despite failures or network interruptions.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## DispersedBFT: Bottleneck-Free Primary-Backup Consensus using Dispersed Replication

DevFeed: [DispersedBFT: Bottleneck-Free Primary-Backup Consensus using Dispersed Replication](<https://devfeed.tech/articles/dispersedbft-bottleneck-free-primary-backup-consensus-using-dispersed-replication-142290.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24833>)

Author: Nancy Kansal, Celine Sana, Jelle Hellings

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>)

Tags: [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [replication](<https://devfeed.tech/tags/replication.md>)

### AI overview

DispersedBFT aims to remove the primary bottleneck in PBFT-like consensus by using information dispersal to distribute request replication from the primary to backup replicas. Its variants trade CPU cost against communication cost: one uses Message Authentication Codes and Merkle proofs for lower CPU cost, while another uses digital signatures for lower communication cost. The abstract reports throughput of 3.4 million transactions per second with 43 replicas, up to 6.2 times faster than PBFT and 2.6 times faster than HotStuff. These are reported experimental results; the supplied text does not provide evaluation details.

### Source excerpt

arXiv:2611.24833v1 Announce Type: new Abstract: The advent of blockchains is fueling the development of novel resilient data management systems (RDSs). Typically, these RDSs are managed using a primary-backup design using a consensus protocol such as PBFT. In these primary-backup designs, a single participant, the primary, is responsible for coordinating the replication and execution of requests. Unfortunately, the central role of the primary makes it a bottleneck that drastically limits performance. In this paper, we propose DispersedBFT, a high performance PBFT-like consensus protocol that utilizes dispersed replication to eliminate the primary bottleneck of PBFT-like consensus. In specific, DispersedBFT uses information dispersal to distribute the task of replicating request from the primary to the backups. We propose several variants of DispersedBFT with either low CPU cost (by using Message Authentication Codes and Merkle proofs) or communication cost (by using digital signatures). We practically analyze the performance of DispersedBFT and show it greatly outperforms PBFT and HotStuff: DispersedBFT supports a throughput of 3.4Mtxn/sec with 43 replicas and is up-to 6.2x faster than PBFT and 2.6x faster than HotStuff.

## Duet: Co-Optimizing P2P Message Propagation and Rotating-Leader Consensus

DevFeed: [Duet: Co-Optimizing P2P Message Propagation and Rotating-Leader Consensus](<https://devfeed.tech/articles/duet-co-optimizing-p2p-message-propagation-and-rotating-leader-consensus-131514.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2607.22209>)

Author: Yifeng Ye, Rongji Huang, Gerui Wang, Mingchao Wan, Yuxing Duan, Jingjing Zhang, Shengyun Liu

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [P2P](<https://devfeed.tech/topics/p2p.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [amazon-ec2](<https://devfeed.tech/tags/amazon-ec2.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [broadcast](<https://devfeed.tech/tags/broadcast.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leader](<https://devfeed.tech/tags/leader.md>), [libp2p](<https://devfeed.tech/tags/libp2p.md>), [message](<https://devfeed.tech/tags/message.md>), [network](<https://devfeed.tech/tags/network.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [p2p](<https://devfeed.tech/tags/p2p.md>), [regions](<https://devfeed.tech/tags/regions.md>), [state-machine](<https://devfeed.tech/tags/state-machine.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [topology](<https://devfeed.tech/tags/topology.md>), [trees](<https://devfeed.tech/tags/trees.md>)

### AI overview

Duet co-optimizes rotating-leader consensus and P2P message delivery by using blockchain's state-machine abstraction to record network topology and latency in a trusted, coordinated way. It combines faster leader rotation, reliable broadcast that normally uses tree dissemination and falls back to gossip when needed, and latency-aware dissemination trees. The prototype integrates with Tendermint and libp2p and was evaluated on Amazon EC2 with up to 300 nodes across 10 regions. Against gossip-based dissemination over the same topology, it reports up to 7.26x higher peak throughput.

### Source excerpt

arXiv:2607.22209v2 Announce Type: replace Abstract: In blockchain systems, peer-to-peer (P2P) overlay networks play a crucial role in providing reliable, scalable and efficient message-delivery services to upper layers. However, the consensus layer and the underlying P2P network remain mutually opaque in existing blockchains, waiving the opportunity for further improvement. In contrast to other P2P applications, blockchain can naturally be abstracted as a state machine. We therefore leverage this abstraction to record network topologies and latencies in a trusted and coordinated manner. With this support, we propose three improvements to rotating-leader consensus protocols and their underlying P2P networks: (1) accelerating leader rotation; (2) introducing a reliable-broadcast paradigm that employs tree-based dissemination in the normal case and falls back to gossip only when necessary; and (3) constructing latency-aware dissemination trees. We integrate the above ideas into Tendermint and libp2p, and conduct empirical evaluation on Amazon EC2 platform using up to 300 nodes distributed across 10 regions. The results demonstrate that, compared with gossip-based dissemination over the same topology, our prototype improves peak throughput by up to $7.26\times$.

## Toward Optimal-Complexity Hash-Based Asynchronous MVBA with Optimal Resilience

DevFeed: [Toward Optimal-Complexity Hash-Based Asynchronous MVBA with Optimal Resilience](<https://devfeed.tech/articles/toward-optimal-complexity-hash-based-asynchronous-mvba-with-optimal-resilience-131505.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2410.12755>)

Author: Jovan Komatovic, Joachim Neu, Tim Roughgarden

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [hash](<https://devfeed.tech/tags/hash.md>), [resilience](<https://devfeed.tech/tags/resilience.md>)

### AI overview

The paper presents two asynchronous MVBA protocols for adaptive faults that improve resilience while keeping communication costs low. Reducer tolerates fewer than n/4 failures and retains HMVBA's stated optimal message and time complexity and near-optimal bit complexity; it uses collision-resistant hashes and internally uses a new strong multi-valued Byzantine agreement (SMBA) construction to ensure the decided value was proposed by a correct process. Reducer++ raises resilience to fewer than (1/3 − ε)n failures for any fixed ε > 0, without SMBA. It instead models hash functions as random oracles to ensure termination, with constant time, quadratic message, and quasi-quadratic bit complexity; its constants depend on ε.

### Source excerpt

arXiv:2410.12755v4 Announce Type: replace Abstract: Multi-valued validated Byzantine agreement (MVBA), a fundamental primitive of distributed computing, allows $n$ processes to agree on a valid $\ell$-bit value, despite $t$ faulty processes behaving maliciously. Among hash-based solutions for the asynchronous setting with adaptive faults, the state-of-the-art HMVBA protocol achieves optimal $O(n^2)$ message complexity, (near-)optimal $O(n \ell + n^2 \lambda \log n)$ bit complexity, and optimal $O(1)$ time complexity. However, it only tolerates $t < \frac15 n$ failures. In contrast, the best-known optimally-resilient protocol, SQ, incurs a higher bit complexity of $O(n^2 \ell + n^3 \lambda)$. This poses a fundamental question: Can a hash-based protocol be designed for the asynchronous setting with adaptive faults that simultaneously achieves optimal complexity and optimal resilience? This paper takes a significant step toward answering this question. Namely, we introduce Reducer, an MVBA protocol that retains HMVBA's optimal complexity while improving its resilience to $t < \frac14 n$. Like HMVBA and SQ, Reducer relies exclusively on collision-resistant hash functions. A key innovation in Reducer's design is its internal use of strong multi-valued Byzantine agreement (SMBA), a new variant of Byzantine agreement we introduce and construct, which ensures that the decided value was proposed by a correct process. To further advance resilience toward the optimal one-third bound, we then propose Reducer++, an MVBA protocol that tolerates up to $t < (\frac13 - \epsilon)n$ adaptive failures, for any fixed constant $\epsilon > 0$. Unlike Reducer, Reducer++ does not rely on SMBA. Instead, it employs a novel approach involving hash functions modeled as random oracles to ensure termination. Reducer++ maintains constant time complexity, quadratic message complexity, and quasi-quadratic bit complexity, with constants dependent on $\epsilon$.

## SoK: Design Choices in Tendermint BFT Consensus

DevFeed: [SoK: Design Choices in Tendermint BFT Consensus](<https://devfeed.tech/articles/sok-design-choices-in-tendermint-bft-consensus-131536.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.15847>)

Author: Sanaz Taheri-Boshrooyeh, Yahya Hassanzadeh-Nazarabadi

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>)

Tags: [bft-consensus](<https://devfeed.tech/tags/bft-consensus.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [design](<https://devfeed.tech/tags/design.md>), [performance](<https://devfeed.tech/tags/performance.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [research](<https://devfeed.tech/tags/research.md>), [survey](<https://devfeed.tech/tags/survey.md>)

### AI overview

The survey organizes research on Tendermint BFT consensus around the protocol's design choices, such as vote dissemination and proposer rotation. It classifies proposed changes by which choice they modify, which properties they strengthen or weaken, and whether they require a stronger fault or timing model. It then groups approaches around performance, validator accountability, and protection of exploitable information, identifies recurring strategies, and frames remaining gaps as open questions under explicit models. The supplied text is an abstract, so it does not provide the detailed comparisons or findings of the full survey.

### Source excerpt

arXiv:2611.15847v1 Announce Type: new Abstract: Tendermint is a consensus protocol that tolerates Byzantine faults, implemented first by the Tendermint Core engine and now by CometBFT. Realizing the protocol's separation of agreement from execution, the Application Blockchain Interface (ABCI) of these engines keeps consensus apart from the replicated application, so one engine can serve many independent proof-of-stake chains. A sustained body of research proposes changes that span the protocol's mechanisms, from vote dissemination to block proposal and reward distribution, yet to our knowledge no survey studies the protocol and these works as one family, and broader surveys do not take Tendermint as their subject. We describe the baseline, the protocol as consolidated from its original descriptions, by its design choices. Each is a decision, such as how votes spread or how proposers rotate, through which the baseline provides safety and liveness or another property under its fault and timing model. We classify each work by the design choice it renegotiates, that is, modifies or replaces, by the properties it strengthens or weakens, and by whether its result needs a stronger model. Taking a broader perspective on that classification, we group the surveyed works' solutions into a few threads of concern in the baseline, namely its performance, the accountability of its validators, and the protection of exploitable information. For each thread, we identify the recurring strategies that their approaches follow. Together, these threads and strategies describe the current state of research on the Tendermint family. Where the strategies leave gaps, we pose future directions, each as an open question under an explicit fault and timing model.

## Decentralized Ranking Aggregation via Gossip: Convergence and Robustness

DevFeed: [Decentralized Ranking Aggregation via Gossip: Convergence and Robustness](<https://devfeed.tech/articles/decentralized-ranking-aggregation-via-gossip-convergence-and-robustness-128089.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.22847>)

Author: Kerrian Le Caillec, Anna Van Elst, Igor Colin, Stephan Cl\\'emen\\c{c}on

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [aggregation](<https://devfeed.tech/tags/aggregation.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

The article studies how to reach consensus rankings when preference data is distributed across a network. Its approach uses random gossip: autonomous agents interact locally to compute a global ranking without a coordinator or central authority. The work focuses on convergence, resilience to corrupted nodes, and reducing communication costs. The supplied abstract describes the approach and its aims but gives no specific convergence results or robustness bounds.

### Source excerpt

arXiv:2602.22847v3 Announce Type: replace-cross Abstract: The concept of ranking aggregation plays a central role in preference analysis, and numerous algorithms for calculating median rankings, often originating in social choice theory, have been documented in the literature, offering theoretical guarantees in a centralized setting, \textit{i.e.}, when all the ranking data to be aggregated can be brought together in a single computing unit. For many technologies (\textit{e.g.} peer-to-peer networks, IoT, multi-agent systems), extending the ability to calculate consensus rankings with guarantees of convergence and resilience to potential contamination in a decentralized setting, when preference data is initially distributed across a communicating network, remains a major methodological challenge. Indeed, in recent years, the literature on decentralized computation has mainly focused on computing or optimizing statistics such as arithmetic means using gossip algorithms. The purpose of this article is precisely to study how to achieve reliable and resilient consensus on collective rankings in a decentralized setting, thereby raising new questions, robustness to corrupted nodes, and scalability through reduced communication costs in particular. The approach proposed and analyzed here relies on the robustness guarantees offered by random gossip communication, which allows autonomous agents to compute a global ranking consensus using local interactions only, without coordination or a central authority.

## On the Solvability of Sound Distributed Verification under Byzantine Faults

DevFeed: [On the Solvability of Sound Distributed Verification under Byzantine Faults](<https://devfeed.tech/articles/on-the-solvability-of-sound-distributed-verification-under-byzantine-faults-127789.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2606.13954>)

Author: Gilde Valeria Rodr\\'iguez, Borzoo Bonakdarpour, Armando Casta\\~neda, Sergio Rajsbaum

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [certificate](<https://devfeed.tech/tags/certificate.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [crash](<https://devfeed.tech/tags/crash.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [election](<https://devfeed.tech/tags/election.md>), [linearizability](<https://devfeed.tech/tags/linearizability.md>), [overlap](<https://devfeed.tech/tags/overlap.md>), [safety](<https://devfeed.tech/tags/safety.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The abstract gives tight solvability thresholds for reconstructing a target execution from partial observations in asynchronous message-passing systems with up to t failures: each execution element must initially be witnessed by at least t + 1 processes under crash failures, and 2t + 1 under Byzantine failures. For globally dependent safety properties such as consensus and linearizability, it says a certificate of t + 1 reports is needed to ensure at least one honest report. It concludes that sound distributed verification under Byzantine faults is achievable exactly when input overlap is at least 2t + 1.

### Source excerpt

arXiv:2606.13954v2 Announce Type: replace Abstract: Modern distributed systems, ranging from distributed tracing platforms to blockchain oracle networks, frequently rely on processes holding partial observations to collectively certify a global execution state. Under Byzantine failures, a single malicious process withholding or fabricating partial states renders sound verification impossible, as genuine observations remain indistinguishable from fabricated assertions. To overcome this impossibility, we study input overlap x: the minimum number of processes that initially witness each element of a target execution I. We formalize this challenge as the x-reconstruction problem in asynchronous message-passing systems with up to t failures, where the goal is for all correct processes to recover I completely given an input overlap x. We establish tight matching upper and lower bounds for solvability: under crash failures, x-reconstruction is solvable if and only if x >= t + 1; under Byzantine failures, x-reconstruction is solvable if and only if x >= 2t + 1. Finally, we connect these structural bounds to semantic verification. For globally dependent safety properties (such as consensus, linearizability, k-set agreement, and leader election), sound verification under Byzantine faults requires a certificate of size c = t + 1 to guarantee at least one honest report. Consequently, sound distributed verification under Byzantine faults is achievable if and only if the input overlap satisfies x >= 2t + 1.

## A Simple Phase-King Protocol with Predictions

DevFeed: [A Simple Phase-King Protocol with Predictions](<https://devfeed.tech/articles/a-simple-phase-king-protocol-with-predictions-126725.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11370>)

Author: Antonia Giannoulea, George Papadoulis, Nikos Leonardos, Aris Pagourtzis

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [2026](<https://devfeed.tech/tags/2026.md>), [about](<https://devfeed.tech/tags/about.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [applications](<https://devfeed.tech/tags/applications.md>), [approach](<https://devfeed.tech/tags/approach.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [better](<https://devfeed.tech/tags/better.md>), [bits](<https://devfeed.tech/tags/bits.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [communication](<https://devfeed.tech/tags/communication.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [complete](<https://devfeed.tech/tags/complete.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [predictions](<https://devfeed.tech/tags/predictions.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [simple](<https://devfeed.tech/tags/simple.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The paper presents a deterministic Phase King protocol for synchronous binary Byzantine Agreement with predictions about which processes are honest or Byzantine. For fewer than n/3 Byzantine processes, it tolerates arbitrarily many prediction errors and terminates in O(P) rounds, where P = 1 + min{B/n, f}; B counts incorrect prediction bits held by honest processes, and f is the actual Byzantine count. It uses O(n²P) messages and O(n²P log n) bits, avoiding an initial cubic bit cost for exchanging full prediction vectors. Compared with the cited independent work, it has the same error tolerance and round complexity but weaker communication bounds; its stated advantage is a simpler Phase King design without involved preprocessing, which the authors say may suit time-evolving networks.

### Source excerpt

arXiv:2611.11370v1 Announce Type: new Abstract: Inspired by recent work (Ben-David, Dzulfikar, Ellen, and Gilbert, $\textit{Byzantine Agreement with Predictions}$, PODC 2025) we study synchronous binary Byzantine Agreement in the learning-augmented setting, where each process receives predictions about which processes are honest or Byzantine. We present a deterministic Phase King protocol for the anauthenticated setting, combining early stopping with a specifically designed prediction-aware king selection procedure. For at most $t3$ Byzantine processes, the protocol handles arbitrarily many prediction errors, improving upon the $O(n^{32})$ bound of Ben-David et al., and terminates within $O(P)$ communication rounds, where $P=1+\min\{\mathbf{B}/n,f\}$, $\mathbf{B}$ is the total number of incorrect prediction bits held by honest processes, and $f$ is the actual number of Byzantine processes. Our protocol uses $O(n^2P)$ messages and $O(n^2P\log n)$ bits, avoiding the initial cubic bit cost of exchanging complete prediction vectors. In comparison to very recent independent work (Dufay, Dzulfikar, and Gilbert, $\textit{Predictions Can Only Help! Communication Efficient Byzantine Agreement with Predictions}$, DISC 2026), which achieves the same error tolerance and round complexity but better communication bounds, our construction provides a much simpler Phase King approach that completely avoids involved preprocessing constructions, rendering it more practical, especially for achieving agreement in time-evolving networks. We believe that the novel prediction-aware king selection technique of our scheme is of independent interest and can find further applications in learning-augmented distributed consensus.

## Seamless Reconfiguration for DAG-BFT (Technical Report)

DevFeed: [Seamless Reconfiguration for DAG-BFT (Technical Report)](<https://devfeed.tech/articles/seamless-reconfiguration-for-dag-bft-technical-report-126695.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.00896>)

Author: Michael Yiqing Hu, Leander Jehl, Paul Franke-Bergmann, Jialin Li, Christian Berger

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [byzantine-fault-tolerance](<https://devfeed.tech/tags/byzantine-fault-tolerance.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [downtime](<https://devfeed.tech/tags/downtime.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [report](<https://devfeed.tech/tags/report.md>)

### AI overview

The report presents a protocol for reconfiguring membership in asynchronous DAG-based Byzantine atomic broadcast without halting DAG growth. Existing approaches described in the abstract either pause operation or wait for a predetermined epoch boundary; a single agreed switching round is difficult because dissemination may already have advanced before processes learn of it. The proposed protocol allows membership and corresponding quorum thresholds to change while the DAG continues growing. The authors claim it is the first seamless reconfiguration protocol for this setting in a fully asynchronous network.

### Source excerpt

arXiv:2610.00896v2 Announce Type: replace Abstract: Byzantine Atomic Broadcast in Asynchronous networks has been studied extensively for decades. In a fully asynchronous system with even one possible crash failure, the FLP impossibility result rules out deterministic consensus, motivating randomized protocols that achieve termination with probability one. More recently, DAG-Rider popularized a new abstraction in which processes continuously reliably broadcast blocks to construct a Directed Acyclic Graph (DAG) and then locally derive a total order using a randomized perfect coin. This separation of dissemination from ordering has renewed interest in asynchronous DAG-based Byzantine Fault Tolerance (BFT) and inspired numerous protocols that improve expected latency or throughput. Reconfiguration, however, remains largely unexplored. Existing DAG-based BFT protocols generally assume a static set of processes, whereas deployed systems must occasionally add or remove nodes in response to operational demands. Existing solutions are not seamless; they either pause the system or delay membership changes until a predetermined epoch boundary. This may be impractical and can introduce downtime. A single agreed switching round is difficult to use seamlessly: by the time processes learn it, the dissemination layer may already have advanced beyond it. In this work, we present a seamless reconfiguration protocol for Asynchronous DAG-based Byzantine Atomic Broadcast. Our protocol allows the DAG to continue growing while the membership and corresponding quorum thresholds change, without halting the system. To the best of our knowledge, ours is the first protocol to provide seamless reconfiguration for DAG-based Byzantine atomic broadcast in a fully asynchronous network.

## FirstSwap: Pre-Consensus Trade Approvals for Decentralized Market Design

DevFeed: [FirstSwap: Pre-Consensus Trade Approvals for Decentralized Market Design](<https://devfeed.tech/articles/firstswap-pre-consensus-trade-approvals-for-decentralized-market-design-126705.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10254>)

Author: William Diamond, Fatima Elsheimy, Dahlia Malkhi, Geoff Ramseyer, Srivatsan Sridhar

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Cryptocurrency](<https://devfeed.tech/topics/cryptocurrency.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [auction](<https://devfeed.tech/tags/auction.md>), [batch](<https://devfeed.tech/tags/batch.md>), [block](<https://devfeed.tech/tags/block.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-gt](<https://devfeed.tech/tags/cs-gt.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [delay](<https://devfeed.tech/tags/delay.md>), [dex](<https://devfeed.tech/tags/dex.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [maker](<https://devfeed.tech/tags/maker.md>), [messages](<https://devfeed.tech/tags/messages.md>), [model](<https://devfeed.tech/tags/model.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [orders](<https://devfeed.tech/tags/orders.md>), [prices](<https://devfeed.tech/tags/prices.md>), [pricing](<https://devfeed.tech/tags/pricing.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [quorum](<https://devfeed.tech/tags/quorum.md>), [social](<https://devfeed.tech/tags/social.md>), [trade](<https://devfeed.tech/tags/trade.md>)

### AI overview

FirstSwap gives traders pre-consensus approval that guarantees execution within their submitted price limit, with final ordering based on limit prices rather than block-producer choice. Its economic model finds that under gradual CEX price changes, it rewards earlier traders, discourages delay, and produces higher social welfare and liquidity-provider gains than a batch auction; under abrupt price jumps, it yields higher welfare and smaller AMM losses than fair ordering. For fast approvals, validators reserve only a fraction of available liquidity at each price, and traders obtain approval in one message round with a quorum. The authors show that quorum-certified trades remain jointly admissible and within their limits even with Byzantine validators that may approve arbitrarily. The protocol also supports pre-approving matching buy and sell orders.

### Source excerpt

arXiv:2611.10254v1 Announce Type: new Abstract: Decentralized exchanges typically give traders no execution guarantee until a block is finalized. In the meantime, external prices move, traders strategically delay submission, and block producers can influence inclusion and ordering. We introduce FirstSwap, a DEX built on a constant-function market maker pricing curve that gives traders an early pre-approval before consensus, guaranteeing inclusion and execution within their submitted price limit, with final ordering determined by limit prices rather than by a block producer. We demonstrate the benefits of trade pre-approvals in an economic model combining auction theory with CEX-DEX arbitrage. When the CEX price changes gradually, FirstSwap rewards earlier traders with better prices, discouraging strategic delay and yielding higher social welfare and gains to AMM liquidity providers than a batch auction. When the CEX price jumps abruptly, FirstSwap yields higher welfare and smaller AMM losses than fair ordering. The central challenge is delivering fast trade pre-approvals without consensus. We introduce a decentralized, scaled admissibility protocol under which each validator reserves only a fraction of the available liquidity at every price. A trader obtains approval in a single round of messages with a quorum of validators. Somewhat surprisingly, despite Byzantine validators who may approve trades arbitrarily, we show that all quorum-certified trades are jointly admissible and execute within their limits. Our protocol extends naturally to a setting where buy and sell orders can be pre-approved against each other before a block is finalized.

## Robust and Private Swarm Learning via Zero-Knowledge Validator Admission and Consensus Aggregation

DevFeed: [Robust and Private Swarm Learning via Zero-Knowledge Validator Admission and Consensus Aggregation](<https://devfeed.tech/articles/robust-and-private-swarm-learning-via-zero-knowledge-validator-admission-and-consensus-aggregation-125387.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11477>)

Author: Marco Arazzi, Mert Cihangiroglu, Antonino Nocera

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Federated Learning](<https://devfeed.tech/topics/federated-learning.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Adversarial attacks](<https://devfeed.tech/topics/adversarial-attacks.md>)

Tags: [admission](<https://devfeed.tech/tags/admission.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [attack-surface](<https://devfeed.tech/tags/attack-surface.md>), [attestation](<https://devfeed.tech/tags/attestation.md>), [audit](<https://devfeed.tech/tags/audit.md>), [client](<https://devfeed.tech/tags/client.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [learning](<https://devfeed.tech/tags/learning.md>), [mask](<https://devfeed.tech/tags/mask.md>), [model](<https://devfeed.tech/tags/model.md>), [network](<https://devfeed.tech/tags/network.md>), [oracle](<https://devfeed.tech/tags/oracle.md>), [pool](<https://devfeed.tech/tags/pool.md>), [private](<https://devfeed.tech/tags/private.md>), [robust](<https://devfeed.tech/tags/robust.md>), [swarm](<https://devfeed.tech/tags/swarm.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The framework makes validator admission depend on zero-knowledge evidence that a reference model ran correctly on private data, without disclosing raw samples. It uses attested outputs to form a label-free, collectively IID validator pool from skewed participants, then has admitted validators use Tendermint-style Byzantine fault-tolerant consensus to agree on update masks and quality-derived aggregation weights instead of dataset-size weights. A challenge-based audit rechecks masks without an end-to-end zero-knowledge proof. In four non-IID benchmarks it reportedly matches FedAvg on clean data; under gradient scaling, it retains 94% of clean accuracy on CIFAR-100 and over 99% on FashionMNIST, while FedAvg falls to random chance (2.1% and 11%, respectively).

### Source excerpt

arXiv:2611.11477v1 Announce Type: cross Abstract: Swarm Learning improves resilience and removes the need for a single trusted coordinator by distributing model aggregation and validation across participating nodes. However, it also delegates the validation of model updates to peers whose private data may be biased, unrepresentative, or adversarial, and existing Swarm Learning protocols generally do not attest that data, leaving decentralized validation as an attack surface. We present a robust, privacy-preserving Swarm Learning framework that makes verifiable data quality the condition for admission to the learning task. A validator joins only after a zero-knowledge attestation proves, without revealing any raw sample, that a reference model ran correctly on its private data. The attested outputs also yield a label-free class profile, so the network assembles a collectively IID validator pool from individually skewed validators as accurately as an oracle with the true labels (total-variation distance to uniform 0.025, against 0.021 for the oracle and 0.21 for random selection). Admitted validators score client updates and, through a Tendermint-style Byzantine Fault Tolerant consensus, agree on a gradient mask and a quality-derived aggregation weight for each submission, replacing dataset-size weighting with a quality-aware signal. Adapting the cut-layer idea of Split Learning, a challenge-based audit lets peers re-verify that a mask was computed on the attested data without an expensive end-to-end zero-knowledge proof. Across four benchmarks under non-IID partitions the framework matches FedAvg on clean data; under a gradient-scaling attack that collapses FedAvg to random chance, it retains 94% of clean accuracy on CIFAR-100 and over 99% on FashionMNIST, where FedAvg achieves only 2.1% and 11%. The result is a private, robust, and auditable foundation for decentralized learning.

## Optimal Subcubic Byzantine Agreement with Plain PKI

DevFeed: [Optimal Subcubic Byzantine Agreement with Plain PKI](<https://devfeed.tech/articles/optimal-subcubic-byzantine-agreement-with-plain-pki-119114.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06479>)

Author: Marc Dufay, Roger Wattenhofer

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [pki](<https://devfeed.tech/tags/pki.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [resiliency](<https://devfeed.tech/tags/resiliency.md>)

### AI overview

The abstract presents a deterministic Byzantine Agreement protocol for synchronous authenticated networks that tolerates up to t < n/2 Byzantine parties using plain PKI, without threshold signatures. Its bit complexity is O(κ^1.303 n^2.303), where κ bounds hash or signature size, and its round complexity is O(n). This improves on the stated cubic complexity of known regular-signature protocols at this resilience level; the excerpt does not provide protocol details or comparisons beyond those claims.

### Source excerpt

arXiv:2611.06479v1 Announce Type: new Abstract: We consider Byzantine Agreement (BA), where $n$ parties run a distributed protocol to agree on a common value, despite $t$ parties being byzantine. In the synchronous setting, a choice must be made between the weaker unauthenticated setting, which only allows $t < n/3$ byzantine parties, and the stronger authenticated setting that allows up to $t < n/2$ byzantine parties. For this latter setting, BA can be solved with optimal resiliency and optimal bit complexity. However, so far, all optimal solutions rely on the use of threshold signatures. This shows a gap compared to regular signatures, where only protocols with cubic complexity are known for optimal resiliency $t < n/2$. We wonder whether this cubic complexity is required without the use of threshold signatures and show that this is not the case. More specifically, given $\kappa$ an upper bound on the size of a hash or signature, we describe a deterministic protocol solving BA with bit complexity $\mathcal{O}(\kappa^{(\sqrt{13} - 1)/2} n^{(\sqrt{13} + 1)/2}) \approx \mathcal{O}(\kappa^{1.303}n^{2.303})$ while having optimal resiliency $t

## Breaking Fault Lines: Unifying TEE-Assisted BFT Consensus in Partially Trusted Worlds

DevFeed: [Breaking Fault Lines: Unifying TEE-Assisted BFT Consensus in Partially Trusted Worlds](<https://devfeed.tech/articles/breaking-fault-lines-unifying-tee-assisted-bft-consensus-in-partially-trusted-worlds-119088.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.09742>)

Author: Xiaoqing Wen, Tong Liu, Jianyu Niu, Jialin Li, Cong Wang, Yinqian Zhang, Chen Feng

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Confidential Computing](<https://devfeed.tech/topics/confidential-computing.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [bft-consensus](<https://devfeed.tech/tags/bft-consensus.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [intel](<https://devfeed.tech/tags/intel.md>), [lan](<https://devfeed.tech/tags/lan.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [quorum](<https://devfeed.tech/tags/quorum.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [tee](<https://devfeed.tech/tags/tee.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [trust](<https://devfeed.tech/tags/trust.md>), [wan](<https://devfeed.tech/tags/wan.md>)

### AI overview

The paper derives a tight resilience bound for BFT deployments with arbitrary partial TEE coverage: f < max{n/3, m/2}, where n is total replicas and m are TEE-enabled replicas. It reports that TEEs improve fault tolerance only when they exceed two-thirds of the deployment. Its protocols combine TEE-only and mixed quorums and use a TEE-leader fast path based on hardware-enforced non-equivocation to reduce consensus and view-change latency. Raftel and its pipelined variant, chained-Raftel, are implemented on Intel SGX and evaluated in LAN and WAN settings. In WAN tests, Raftel reaches up to 625 TPS with latency below 670 ms, and exceeds HotStuff throughput by up to 308 TPS while approaching fully TEE-assisted protocols. These are abstract-level reported results; no evaluation details are provided here.

### Source excerpt

arXiv:2609.09742v3 Announce Type: replace Abstract: This paper revisits TEE-assisted BFT under a universal partial-TEE model, where an arbitrary subset of replicas execute inside TEEs while the remaining replicas operate without hardware trust guarantees. We show that heterogeneous trust changes the structure of quorum formation and fault tolerance. In particular, we derive a tight resilience bound f < max {n/3, m/2}, where n is the total number of replicas and m is the number of TEE-enabled replicas. The result reveals a sharp threshold phenomenon: TEEs improve fault tolerance only once they exceed two-thirds of the deployment. Guided by this characterization, we introduce two protocol principles: (1) a dual-quorum construction that safely combines TEE-only and mixed quorums, and (2) a TEE-leader fast path that leverages hardware-enforced non-equivocation to reduce both consensus and view-change latency. We realize these ideas in Raftel, which is, to our knowledge, the first HotStuff-style BFT protocol designed explicitly for arbitrary partial-TEE deployments, and in chained-Raftel, a pipelined variant that further accelerates mixed-trust execution. We implement both protocols atop Intel SGX and evaluate them in LAN and WAN environments. Our results show that Raftel achieves up to 625 TPS with sub-670 ms latency in WAN settings, outperforming HotStuff by up to 308 TPS in throughput while approaching the performance of fully TEE-assisted protocols.

## Distributed Consensus, Optimization, and Learning under Communication Constraints

DevFeed: [Distributed Consensus, Optimization, and Learning under Communication Constraints](<https://devfeed.tech/articles/distributed-consensus-optimization-and-learning-under-communication-constraints-119115.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06524>)

Author: Zheng Chen, Nicol\\\`o Michelusi, Themistoklis Charalambous, Kaibin Huang

Published: 2026-11-05T05:00:00Z

Content type: tutorial

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [communications](<https://devfeed.tech/topics/communications.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [communication](<https://devfeed.tech/tags/communication.md>), [connectivity](<https://devfeed.tech/tags/connectivity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-it](<https://devfeed.tech/tags/cs-it.md>), [delay](<https://devfeed.tech/tags/delay.md>), [design-principles](<https://devfeed.tech/tags/design-principles.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-coordination](<https://devfeed.tech/tags/distributed-coordination.md>), [eess-sp](<https://devfeed.tech/tags/eess-sp.md>), [exchange](<https://devfeed.tech/tags/exchange.md>), [flow](<https://devfeed.tech/tags/flow.md>), [fundamentals](<https://devfeed.tech/tags/fundamentals.md>), [intelligence](<https://devfeed.tech/tags/intelligence.md>), [learning](<https://devfeed.tech/tags/learning.md>), [learning-algorithms](<https://devfeed.tech/tags/learning-algorithms.md>), [math-it](<https://devfeed.tech/tags/math-it.md>), [network](<https://devfeed.tech/tags/network.md>), [network-connectivity](<https://devfeed.tech/tags/network-connectivity.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [principles](<https://devfeed.tech/tags/principles.md>)

### AI overview

The tutorial explains how consensus averaging and distributed optimization let networked nodes cooperate on shared objectives, and how communication conditions affect that cooperation. It highlights that information accuracy, exchange frequency, reliability, network connectivity, and uncertainty influence convergence, training delay, and model accuracy. Building on these fundamentals, it outlines design principles for communication-constrained distributed learning across network topologies and reviews communication-efficient approaches, particularly for wireless networks. The abstract identifies bridging theory and practice as an open need; it does not provide specific algorithm comparisons or implementation guidance.

### Source excerpt

arXiv:2611.06524v1 Announce Type: cross Abstract: Many modern engineering applications require distributed problem-solving in which multiple nodes in a network cooperate to achieve a common optimization objective. Numerous distributed optimization and learning algorithms rely on consensus-based distributed coordination to ensure network-wide agreement via iterative local interactions. In these algorithms, the accuracy, frequency, and reliability of information exchange among network nodes directly influence system performance, including convergence behavior, training delay, and model accuracy. This tutorial article adopts a bottom-up approach to present the fundamentals of consensus averaging and distributed optimization methods, and highlights the impact of network connectivity, information flow, and communication uncertainty on network cooperation and optimization performance. Building on these theoretical insights, we discuss key design principles for communication-constrained distributed learning across diverse network topologies and review common approaches to communication-efficient learning, particularly in wireless networks. Despite substantial progress, further efforts are needed to bridge the gap between theory and practice and fully realize the potential of cooperative and networked intelligence.

## Distributed LTL Synthesis under Arbitrary Message Adversaries

DevFeed: [Distributed LTL Synthesis under Arbitrary Message Adversaries](<https://devfeed.tech/articles/distributed-ltl-synthesis-under-arbitrary-message-adversaries-116491.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04561>)

Author: Benedikt Bollig, Patricia Bouyer-Decitre, Matthias F\\"ugger, Dhrubajyoti Ghosh, Thomas Nowak, Nathalie Sznajder

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automaton](<https://devfeed.tech/topics/automaton.md>)

Tags: [adversary](<https://devfeed.tech/tags/adversary.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [graph](<https://devfeed.tech/tags/graph.md>), [linear](<https://devfeed.tech/tags/linear.md>), [logic](<https://devfeed.tech/tags/logic.md>), [message](<https://devfeed.tech/tags/message.md>), [processes](<https://devfeed.tech/tags/processes.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [regular](<https://devfeed.tech/tags/regular.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

For two processes communicating over unreliable links with at least one message delivered each round, LTL synthesis can still be undecidable--even when messages contain complete causal histories. For every ω-regular message adversary A, the abstract gives a decidability criterion: synthesis is decidable exactly when the image π(A), derived through iterated chromatic subdivision, is nowhere dense in [0,1]. In decidable cases, a procedure takes a deterministic parity automaton for A and a specification, decides realizability, and constructs an algorithm when one exists. The abstract also states that this decidability condition is equivalent to consensus being repeatedly solvable in bounded time.

### Source excerpt

arXiv:2611.04561v1 Announce Type: new Abstract: Reactive synthesis is the problem of generating a program that produces outputs satisfying a logical specification for every input stream. We study distributed synthesis for two processes communicating in rounds over unreliable links, with at least one message delivered in every round. Despite this delivery guarantee, we show that synthesis from linear temporal logic specifications is undecidable, even when messages carry the processes' complete causal histories. More generally, we give a complete characterization of the communication restrictions that make synthesis decidable. Restrictions are described by a message adversary $A$, a set of allowed infinite graph histories: sequences of communication graphs, each specifying which messages are delivered in a round. Iterated chromatic subdivision associates these histories with points in the unit interval, yielding an image $\pi(A) \subseteq [0,1]$. For every $\omega$-regular message adversary $A$, synthesis is decidable if and only if $\pi(A)$ is nowhere dense. In the decidable cases, our procedure takes a deterministic parity automaton for $A$ and a specification, decides realizability, and constructs a realizing distributed algorithm whenever one exists. Further, our topological arguments shed new light on the fundamental requirements of synthesis. They show that, for $\omega$-regular message adversaries, synthesis is decidable if and only if consensus is repeatedly solvable in bounded time. This links two previously unrelated problems from formal verification and distributed computing through the processes' uncertainty about communication.

## Beyond Leaderless: Randomized Consensus Against Mobile Crashes

DevFeed: [Beyond Leaderless: Randomized Consensus Against Mobile Crashes](<https://devfeed.tech/articles/beyond-leaderless-randomized-consensus-against-mobile-crashes-113793.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01323>)

Author: Ittai Abraham, Kaya Alpturer, Pranav Garimidi, Joachim Neu, Tim Roughgarden, Ertem Nusret Tas

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [adversary](<https://devfeed.tech/tags/adversary.md>), [beacon](<https://devfeed.tech/tags/beacon.md>), [broadcast](<https://devfeed.tech/tags/broadcast.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leader](<https://devfeed.tech/tags/leader.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [network](<https://devfeed.tech/tags/network.md>), [replica](<https://devfeed.tech/tags/replica.md>), [vote](<https://devfeed.tech/tags/vote.md>), [voting](<https://devfeed.tech/tags/voting.md>)

### AI overview

ML-FVS adapts fixed-view Simplex to withstand mobile crashes by allowing multiple leaders to broadcast proposals. At the voting deadline, replicas vote on proposals seen so far; a hidden threshold beacon revealed afterward orders leaders by priority and resolves votes to the highest-priority proposal. The model combines permanent adaptive Byzantine faults with mobile crashes. With a constant crash budget and Byzantine corruption delayed by Δ, the authors report O(Δ) expected latency across repeated views whose leaders start honest; with immediate Byzantine corruption, they report liveness. Their evaluation under random network delays and stochastic faults finds fewer view failures with multiple leaders, even when rational leaders delay proposals to increase rewards.

### Source excerpt

arXiv:2611.01323v1 Announce Type: new Abstract: Many consensus protocols fail to terminate under attack from an adversary that has the power to move between replicas and repeatedly crash one of them, even in synchrony. We present Multi-Leader Fixed-View Simplex (ML-FVS) to defend against such an adversary while keeping the simple structure and good-case latency of Simplex consensus. Our protocol extends fixed-view Simplex with multiple leaders, each of which may broadcast a proposal. At the voting deadline, each replica votes on the set of proposals it has seen so far. A hidden threshold beacon revealed after the votes gives a priority order on the multiple leaders, resolving each vote to its highest-priority proposal. Our model combines permanent adaptive Byzantine faults with mobile crashes. For a constant crash budget and $\Delta$-delayed Byzantine corruption, we obtain $O(\Delta)$ expected latency over repeated views whose leaders start honest. With immediate Byzantine corruptions, the protocol still achieves liveness. We also evaluate the protocol under random network delays and stochastic faults, finding that multiple leaders reduce view failures even when rational leaders delay their proposals to increase rewards.

## Network Topology Does Not Matter: The Breakdown of Classical Consensus in LLM Populations

DevFeed: [Network Topology Does Not Matter: The Breakdown of Classical Consensus in LLM Populations](<https://devfeed.tech/articles/network-topology-does-not-matter-the-breakdown-of-classical-consensus-in-llm-populations-107950.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.37699>)

Author: Sahil Rajesh Dhayalkar

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [graph theory](<https://devfeed.tech/topics/graph-theory.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [bias](<https://devfeed.tech/tags/bias.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [collective](<https://devfeed.tech/tags/collective.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [connectivity](<https://devfeed.tech/tags/connectivity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [content](<https://devfeed.tech/tags/content.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [convex](<https://devfeed.tech/tags/convex.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [llm](<https://devfeed.tech/tags/llm.md>), [matter](<https://devfeed.tech/tags/matter.md>), [network](<https://devfeed.tech/tags/network.md>), [topology](<https://devfeed.tech/tags/topology.md>)

### AI overview

Across eight instruction-tuned models and 73,080 controlled exchanges, measured LLM opinion updates often moved outside the range of observed opinions and included active repulsion, violating assumptions used in classical consensus models. In simulations of 10,000 agents, network algebraic connectivity explained almost none of the final outcome variance; model update bias and message framing were the reported drivers. Several model populations, including models up to 7B parameters, reached confident agreement on objectively false claims across network structures. The findings suggest classical graph metrics may not predict LLM population behavior; the evidence here is an abstract, not the full paper.

### Source excerpt

arXiv:2610.37699v1 Announce Type: cross Abstract: As multi-agent language model networks become widely deployed, predicting their collective behavior is a critical challenge. Classical distributed consensus theory relies on network topology to predict convergence, structurally assuming that agent updates are convex combinations, population means are conserved, and weights are content-independent. In this work, we demonstrate that these foundational assumptions fail for large language models (LLMs). By deterministically extracting continuous credence from token-level probabilities across eight instruction-tuned models and 73,080 controlled exchanges, we directly measure the empirical LLM update operator. We find that LLMs systematically violate convexity by updating outside the hull of observed opinions, exhibiting active repulsion (negative weights) that fundamentally breaks row-stochastic modeling and standard bounded-confidence repairs. Scaling these empirically fitted operators to simulations of 10,000 agents reveals that algebraic connectivity explains almost none of the final outcome variance. Instead, population dynamics are governed entirely by the model's internal update bias and message framing. Consequently, populations of several models, including those with up to 7B parameters, reliably compound small local drifts to reach confident agreement on objectively false claims regardless of their network structure. Our results prove that classical graph-theoretic metrics are inadequate for LLM populations, highlighting a profound deployment risk where multi-agent deliberation predictably saturates in collective delusion.

## Nearly-Optimal Time-Sample Trade-off in Consensus Dynamics

DevFeed: [Nearly-Optimal Time-Sample Trade-off in Consensus Dynamics](<https://devfeed.tech/articles/nearly-optimal-time-sample-trade-off-in-consensus-dynamics-107598.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.40562>)

Author: Francesco d'Amore, Joel Rybicki, Nobutaka Shimizu, Takeharu Shiraga, Robin Vacus

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-consensus](<https://devfeed.tech/tags/distributed-consensus.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [matching](<https://devfeed.tech/tags/matching.md>), [math-pr](<https://devfeed.tech/tags/math-pr.md>), [sample](<https://devfeed.tech/tags/sample.md>), [time](<https://devfeed.tech/tags/time.md>), [trade](<https://devfeed.tech/tags/trade.md>)

### AI overview

In synchronous h-Majority, each node samples h nodes uniformly with replacement each round and adopts the most frequent sampled opinion, resolving ties uniformly at random. For every h >= 3 and initial configuration, the process reaches consensus with high probability within Õ(1 + min{1/min{h²p_max, 1}, √n/h}) rounds, where p_max is the largest initial opinion share. If the most popular opinion initially has a sufficiently large lead, all nodes adopt it with high probability within O(log n/min{h²p_max, 1}) rounds. The authors also prove a lower bound matching the general trade-off up to polylogarithmic factors for fixed, opinion-symmetric update rules that select a sampled opinion or the node's current opinion.

### Source excerpt

arXiv:2610.40562v1 Announce Type: new Abstract: How does the number of sampled opinions affect the time required to reach consensus in distributed consensus dynamics? We study the synchronous $h$-\textsf{Majority}, in which every node independently samples $h$ nodes uniformly at random with replacement in each round and adopts a most frequent sampled opinion, breaking ties uniformly at random. We show that $h$-\textsf{Majority} achieves the nearly-optimal trade-off between the sample size and the consensus time, among a broad class of consensus dynamics. In particular, we prove the following results. For every sample size $h \ge 3$ and for every initial configuration, we prove that the process reaches consensus with high probability within $\widetilde{O}\left(1+\min\left\{\frac{1}{\min\{h^2p_{\max},1\}},\frac{\sqrt{n}}{h}\right\}\right)$ rounds, where $n$ is the number of nodes and $p_{\max}$ is the largest initial fraction of nodes supporting any single opinion. This is the first bound on the consensus time for $h$-\textsf{Majority} that holds for every $h\ge3$ and every initial configuration. When the initially most popular opinion has a sufficiently large lead over every other opinion, we show that all nodes adopt this opinion with high probability within $O(\log n/\min\{h^2p_{\max},1\})$ rounds. We establish a matching lower bound up to polylogarithmic factors for any fixed update rule that treats all opinions symmetrically and that selects either a sampled opinion or the node's current opinion.

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

DevFeed: [Simple-IT: Practical Low-Latency Signature-Free BFT Consensus](<https://devfeed.tech/articles/simple-it-practical-low-latency-signature-free-bft-consensus-107557.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2606.14404>)

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

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [bft-consensus](<https://devfeed.tech/tags/bft-consensus.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leader](<https://devfeed.tech/tags/leader.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pipelining](<https://devfeed.tech/tags/pipelining.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [practical](<https://devfeed.tech/tags/practical.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-computing](<https://devfeed.tech/tags/quantum-computing.md>), [simple](<https://devfeed.tech/tags/simple.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

Simple-IT is a leader-based Byzantine fault-tolerant consensus protocol that avoids public-key signatures, relying instead on authenticated channels described as cheap and post-quantum secure. It targets the latency gap in practical signature-free consensus: its theoretical latency is four message delays, or three on the optimistic path. The authors say its simpler design permits implementation and optimizations such as speculative pipelining. In a geo-distributed testbed, they report throughput and latency competitive with state-of-the-art protocols that use quantum-vulnerable signatures. The supplied text is an abstract and gives no experimental measurements or further implementation details.

### Source excerpt

arXiv:2606.14404v2 Announce Type: replace Abstract: Recent advances in quantum computing pose a looming threat to most current Byzantine fault-tolerant (BFT) consensus protocols, which rely on quantum-vulnerable public-key signature schemes such as Ed25519 and BLS12-381. Instead of switching to much more expensive post-quantum secure signature schemes, an alternative is to use signature-free protocols, which rely only on cheap, post-quantum secure authenticated channels. In this paper, we ask whether signature-free BFT consensus protocols can match the performance of current state-of-the-art, quantum-vulnerable BFT consensus protocols. While previous work on the Sailfish++ protocol showed that state-of-the-art throughput is attainable signature-free, the question of latency is still open. Several recent signature-free protocols have low latency in theory, but they are all very intricate, and no practical implementation has so far been presented. In this work, we propose Simple-IT, a new leader-based, signature-free BFT consensus protocol that achieves a theoretical latency of 4 message delays (one more than the optimum), and only 3 on its optimistic path. Crucially, Simple-IT is simple enough to be amenable to implementation and to practical optimizations such as speculative pipelining, and, as we show experimentally in a geo-distributed testbed, it achieves both throughput and latency competitive with state-of-the-art quantum-vulnerable protocols.

## Finding Nemo-Nemo: CFT DAG-based Consensus in the WAN

DevFeed: [Finding Nemo-Nemo: CFT DAG-based Consensus in the WAN](<https://devfeed.tech/articles/finding-nemo-nemo-cft-dag-based-consensus-in-the-wan-101579.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2604.08914>)

Author: Rithwik Kerur, Pasindu Tennage, Philipp Jovanovic, Dahlia Malkhi, Alberto Sonnino, Igor Zablotchi

Published: 2026-10-27T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [wan](<https://devfeed.tech/tags/wan.md>)

### AI overview

Nemo-Nemo is a crash-fault-tolerant consensus protocol designed for wide-area networks. It propagates commands through a causally ordered DAG, lets all replicas propose commands, and uses multiple leaders to avoid a single-leader bottleneck. Separating command dissemination from consensus lets propagation continue during stalled commits; proposals that miss deadlines are deterministically deferred rather than dropped. The abstract says Nemo-Nemo commits on the DAG in two network hops, matching existing CFT systems' latency while achieving higher throughput. It does not provide measurements or details of the evaluation.

### Source excerpt

arXiv:2604.08914v3 Announce Type: replace Abstract: This paper introduces Nemo-Nemo, a practical crash-fault tolerant (CFT) consensus protocol designed to outperform existing protocols in wide-area networks by bridging design principles from the CFT and Byzantine-fault tolerant (BFT) worlds. By structuring command propagation through a causally ordered DAG, Nemo-Nemo allows all consensus replicas to propose commands with a naturally self-regulating communication regime. By exploiting multi-leader architecture, Nemo-Nemo avoids the performance bottleneck inherent to single-leader protocols. By separating command dissemination from consensus logic, Nemo-Nemo handles challenging network conditions even when consensus commits are stalled. Moreover, leader proposals that miss a deadline are never dropped, but deterministically deferred and executed later, preserving throughput under transient network delays. And by enabling Nemo-Nemo to commit on a DAG in just two network hops, it matches the latency of existing CFT systems, while achieving significantly higher throughput. The result is a robust, deployable system: the first DAG-based CFT consensus protocol proven to exceed state-of-the-art wide-area network performance in both speed and resilience.

## Quantum Cadence: Post-Quantum Consensus with Multiple Concurrent Proposers

DevFeed: [Quantum Cadence: Post-Quantum Consensus with Multiple Concurrent Proposers](<https://devfeed.tech/articles/quantum-cadence-post-quantum-consensus-with-multiple-concurrent-proposers-100177.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.32803>)

Author: Mohammad Mussadiq Jalalzai, Tobias Klenze, Jovan Komatovic

Published: 2026-10-26T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>)

Tags: [accountability](<https://devfeed.tech/tags/accountability.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [broadcast](<https://devfeed.tech/tags/broadcast.md>), [cadence](<https://devfeed.tech/tags/cadence.md>), [certificate](<https://devfeed.tech/tags/certificate.md>), [certificates](<https://devfeed.tech/tags/certificates.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [counts](<https://devfeed.tech/tags/counts.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [fast](<https://devfeed.tech/tags/fast.md>), [free](<https://devfeed.tech/tags/free.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [latency](<https://devfeed.tech/tags/latency.md>), [messages](<https://devfeed.tech/tags/messages.md>), [multiple](<https://devfeed.tech/tags/multiple.md>), [number](<https://devfeed.tech/tags/number.md>), [performance](<https://devfeed.tech/tags/performance.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [quantum](<https://devfeed.tech/tags/quantum.md>)

### AI overview

Quantum Cadence avoids quorum certificates, which become costly when post-quantum signatures cannot be compactly aggregated: validators count quorums from messages they receive themselves. Its safety and liveness do not depend on signatures, though signatures can provide accountability. Quantum Chorus replaces Cadence's Chorus slot consensus, retaining its fast path of dissemination and two voting rounds; if that path fails, it runs Coda, a signature-free Byzantine agreement protocol for multiple proposers. In simulations with 200 validators, Quantum Chorus had latency comparable to Chorus and scaled better as the number of proposers increased. The abstract also outlines adapting Cadence's slot scheduler, Conductor.

### Source excerpt

arXiv:2610.32803v1 Announce Type: new Abstract: The consensus protocols of most high-performance blockchains use quorum certificates, which bundle the signatures of a quorum of validators. Signature schemes such as BLS can aggregate the signatures of a whole quorum into a single short signature, which keeps these certificates small. A large-scale quantum computer would break these schemes, and no post-quantum scheme with comparable aggregate size and aggregation time is known. Without aggregation, a certificate holds one large post-quantum signature per member of the quorum, so it becomes infeasible for each validator to broadcast certificates, as modern consensus protocols often require. We present Quantum Cadence, a post-quantum consensus protocol with multiple concurrent proposers that avoids certificates altogether: every validator counts quorums among the messages it has received itself. Its safety and liveness do not even depend on signatures, although we add signatures to obtain accountability. Quantum Cadence builds on Cadence and replaces its slot consensus, Chorus, with Quantum Chorus, which keeps the optimal fast-path latency of Chorus: dissemination followed by two rounds of votes. When its fast path fails, Quantum Chorus runs Coda, our signature-free Byzantine agreement for multiple proposers. We also outline how the Conductor, which schedules the slots of Cadence, can be adapted to Quantum Cadence. In simulations with 200 validators, Quantum Chorus has a latency comparable to that of Chorus and scales better with the number of proposers.

## HPTS 2026 (Day 2 and Day 3)

DevFeed: [HPTS 2026 (Day 2 and Day 3)](<https://devfeed.tech/articles/hpts-2026-day-2-and-day-3-97842.md>)

Original publisher: [Read original article](<https://muratbuffalo.blogspot.com/2026/10/hpts-2026-day-2-and-day-3.html>)

Author: Murat (noreply@blogger.com)

Published: 2026-10-23T16:45:30Z

Content type: article

Language: en

Sources: [Metadata](<https://devfeed.tech/sources/metadata.md>)

Topics: [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [best](<https://devfeed.tech/tags/best.md>), [big-data](<https://devfeed.tech/tags/big-data.md>), [building](<https://devfeed.tech/tags/building.md>), [but](<https://devfeed.tech/tags/but.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [chair](<https://devfeed.tech/tags/chair.md>), [checksums](<https://devfeed.tech/tags/checksums.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [compress](<https://devfeed.tech/tags/compress.md>), [compression](<https://devfeed.tech/tags/compression.md>), [compute](<https://devfeed.tech/tags/compute.md>), [hpts](<https://devfeed.tech/tags/hpts.md>), [trip-report](<https://devfeed.tech/tags/trip-report.md>)

### AI overview

The notes trace a recurring systems challenge: moving data and handling operational overhead often constrain performance, energy use, and freshness. The GPU engine Sirius aims to accelerate existing databases without modifying DuckDB, while compressing data to trade abundant GPU compute for scarce memory. Microsoft's DPU approach assigns small accelerators to repetitive tasks such as compression and encryption; the notes also describe runtime selection of data movement strategies based on actual downstream consumption. For object storage, proposals include a net-change diff API, shared append-only logs for concurrent table writes, and a Tesla time-series database querying Parquet directly on S3. Viktor Leis argues that today's S3 designs inherit HDD-driven needs for caching and large reads, and that SSD-based object storage could remove some of this complexity, at higher reported cost. Other talks address reducing Cassandra storage overhead, modeling retry-related metastability, quorum protocols' operational requirements, and the freshness-versus-scalability tradeoffs in lakehouse and HTAP systems.

### Source excerpt

This is the second half of my HPTS 2026 notes. Day 1 was mostly about AI and the importance of specifications. Day 2 and day 3 cover hardware, object storage, failures, consensus, and lakehouses. Session 5: Hardware will save us all (chair: Natassa Ailamaki) The Fastest Way to be the Fastest (Bobbi Yogatama, NVIDIA) GPUs and databases have a love-hate relationship, and Bobbi listed the three reasons: limited GPU memory capacity, the interconnect bottleneck, and engineering complexity. The first two are being fixed by the hardware roadmap. HBM is getting larger and faster. Interconnects and network fabrics are getting faster. But engineering complexity requires some work. No one is eager to rewrite their database to get it work with a GPU. Bobbi introduced Sirius, a GPU-native composable analytics engine. It offers a drop-in accelerator for your existing database, with GPU-native execution underneath. MICE is the design principle: modular, interoperable, composable, extensible. Bobbi showed how Sirius plugs into DuckDB with no modification to DuckDB. The other design lesson from Bobby is to spend compute to save memory. On a GPU, compute is the abundant resource and memory capacity and bandwidth are the scarce ones, so the classic tradeoff needs to flip here. It is best to compress the data, compress everywhere, and operate on the compressed data. The Next Watt Saved Won't Come from a CPU or a GPU (Devashish Purandare, Microsoft) Datacenter power consumption is the bottleneck in building datacenters right now. Where is the power consumed? Tax cycles are 60-80% of all execution. There is datacenter tax: compression, crypto, data movement, memory allocation, protocol and RPC handling. Then there is also system tax: error handling, checksums, filesystems, kernel, STL, networking, multithreading. Unfortunately, no single category dominates, so there is no single high value thing to fix. So how do we fix this? Dev titled his next section: how I learned to stop worrying ab

## Fast Tendermint: Speeding Up a Foundational Consensus Protocol

DevFeed: [Fast Tendermint: Speeding Up a Foundational Consensus Protocol](<https://devfeed.tech/articles/fast-tendermint-speeding-up-a-foundational-consensus-protocol-97295.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.13434>)

Author: Preston Vander Vos, Daniel Cason

Published: 2026-10-23T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>), [AutoCorrode library](<https://devfeed.tech/topics/autocorrode-library.md>)

Tags: [bft-consensus](<https://devfeed.tech/tags/bft-consensus.md>), [communication](<https://devfeed.tech/tags/communication.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [fast](<https://devfeed.tech/tags/fast.md>), [formal](<https://devfeed.tech/tags/formal.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leader](<https://devfeed.tech/tags/leader.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [rotation](<https://devfeed.tech/tags/rotation.md>), [specification](<https://devfeed.tech/tags/specification.md>)

### AI overview

Fast Tendermint adapts Tendermint for systems with n > 5f Byzantine processes and decides in two communication steps in the good case, while retaining Tendermint's leader rotation. It combines the prevote and precommit phases into one voting step and merges the locked and valid state. The work reports proofs of agreement, validity, and termination, plus a Quint specification used to model-check the protocol. The excerpt does not describe performance measurements or behavior beyond the stated good-case result.

### Source excerpt

arXiv:2608.13434v2 Announce Type: replace Abstract: Tendermint is among the most widely studied and deployed Byzantine fault-tolerant (BFT) consensus protocols, owing in part to its native leader-rotation mechanism that subsumes complex view changes. Like most partially-synchronous BFT protocols, Tendermint tolerates $f < n/3$ Byzantine processes and decides in three communication steps. Motivated by the push for lower-latency blockchains, a recent line of work shows that consensus can be solved in two communication steps when $f < n/5$. We present Fast Tendermint, an adaptation of Tendermint to the $n > 5f$ setting that decides in two communication steps in the good case, while preserving Tendermint's leader-rotation structure. Fast Tendermint collapses Tendermint's prevote and precommit steps into a single voting step and merges the $locked$ and $valid$ state. We give proofs of agreement, validity, and termination, and a formal specification in Quint, a modern surface syntax for TLA+, used to model-check the protocol.

## The End of Consensus Research?

DevFeed: [The End of Consensus Research?](<https://devfeed.tech/articles/the-end-of-consensus-research-95173.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.30114>)

Author: Cl\\'ement Burgelin, Rachid Guerraoui, Zicong Hong, Yinan Hu, Anne-Marie Kermarrec, Rafael Pires, Rasmus Moorits Veski, Martijn de Vos

Published: 2026-10-22T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Agent Harness](<https://devfeed.tech/topics/agent-harness.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [vulnerability-research](<https://devfeed.tech/topics/vulnerability-research.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-harness](<https://devfeed.tech/tags/agent-harness.md>), [ai](<https://devfeed.tech/tags/ai.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [distributed-computing](<https://devfeed.tech/tags/distributed-computing.md>), [experimentation](<https://devfeed.tech/tags/experimentation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [key-value-store](<https://devfeed.tech/tags/key-value-store.md>), [knowledge-base](<https://devfeed.tech/tags/knowledge-base.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leader](<https://devfeed.tech/tags/leader.md>), [lean](<https://devfeed.tech/tags/lean.md>), [lease](<https://devfeed.tech/tags/lease.md>), [local](<https://devfeed.tech/tags/local.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [modular](<https://devfeed.tech/tags/modular.md>), [research](<https://devfeed.tech/tags/research.md>)

### AI overview

AI helped discover A-greement, a consensus protocol for geo-replicated state machines, but the authors argue that human experts remain essential to consensus research. Across six deployments with 5 or 9 replicas, it reduced mean latency over the fastest baseline by 12.2% on write-heavy workloads and 33.3% on read-heavy workloads, while matching the baseline on read-only workloads. Its paths combine lease-authorized local reads, direct client learning for leader-ordered writes, and fast fixed-quorum per-key writes, chosen according to network topology and workload. The AI-greement harness brings together a protocol knowledge base, modular implementation skeleton, and Lean-based verification framework; its formalization also exposed previously unreported vulnerabilities in existing protocols.

### Source excerpt

arXiv:2610.30114v1 Announce Type: new Abstract: Consensus is a fundamental problem in distributed computing and at the core of state machine replication (SMR). Despite decades of active human research, discovering practical low-latency solutions to the problem is still open, as it requires combining protocol knowledge, correctness reasoning, implementation, and experimental evaluation. We report on how AI helped us discover A-greement, a new consensus protocol for geo-replicated state machines that significantly outperforms state-of-the-art solutions. Averaged across six deployments with 5 or 9 replicas, A-greement reduces the mean latency of a geo-distributed key-value store over the fastest baseline by 12.2% and 33.3% on write-heavy and read-heavy workloads, respectively, and matches the fastest baseline on read-only workloads. A-greement combines lease-authorized local reads, direct client learning for leader-ordered writes, and a fast fixed-quorum per-key write path, selected according to network topology and workload. At the heart of our discovery lies AI-greement, an agent harness for the "autonomous" discovery, implementation, experimentation, and verification of candidate protocols. AI-greement integrates (1) a concept-oriented protocol knowledge base, (2) a modular implementation skeleton, and (3) a Lean-based verification framework with reusable safety definitions, reference specifications, and proofs. AI-greement is of independent interest: its Lean formalization uncovers several previously unreported vulnerabilities in existing consensus protocols, and it provides guidelines on how domain-specific harnesses can turn general-purpose coding agents into effective tools for (distributed) computing research. Yet we argue that human consensus experts remain essential before, during, and after the search: agents reshape the researcher's role rather than end consensus research.

## Building Exten: OVHcloud's Own NVMe Block Storage Engine

DevFeed: [Building Exten: OVHcloud's Own NVMe Block Storage Engine](<https://devfeed.tech/articles/building-exten-ovhcloud-s-own-nvme-block-storage-engine-50597.md>)

Original publisher: [Read original article](<https://blog.ovhcloud.com/en/posts/exten-nvme-block-storage/>)

Author: Tristan Groléat

Published: 2026-08-06T12:00:00Z

Content type: article

Language: en

Sources: [OVHcloud Blog](<https://devfeed.tech/sources/ovhcloud-blog.md>)

Topics: [NVMe](<https://devfeed.tech/topics/nvme.md>), [Disk image](<https://devfeed.tech/topics/disk-image.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [control-plane](<https://devfeed.tech/topics/control-plane.md>), [ceph](<https://devfeed.tech/topics/ceph.md>), [gRPC](<https://devfeed.tech/topics/grpc.md>), [IO](<https://devfeed.tech/topics/io.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Network](<https://devfeed.tech/topics/network.md>), [Compression](<https://devfeed.tech/topics/compression.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [ceph](<https://devfeed.tech/tags/ceph.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [compression](<https://devfeed.tech/tags/compression.md>), [control-plane](<https://devfeed.tech/tags/control-plane.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [go](<https://devfeed.tech/tags/go.md>), [grpc](<https://devfeed.tech/tags/grpc.md>), [io](<https://devfeed.tech/tags/io.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [openstack](<https://devfeed.tech/tags/openstack.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

OVHcloud describes Exten, its own NVMe block storage engine built in C++ and Go as an alternative to its Ceph-based solution. The article outlines the six-server cluster architecture, NVMe over Fabrics, gRPC communication between data and control planes, and Raft-based fault tolerance.

### Source excerpt

Reliable and well integrated into OpenStack, Ceph has been our Block Storage solution for years. But in order offer more performance at a lower cost, we acquired Exten, and are now able to build our own NVMe block storage solution in C++ and Go.

[Next page](<https://devfeed.tech/topics/consensus-algorithm.md?cursor=WyIyMDI2LTA4LTA2VDEyOjAwOjAwKzAwOjAwIiwgIjZhNGYxYWUwLTU3ZjYtNDhiYS04NWU5LWIxNWI3ZTAwNjc1OSJd>)