Propose–Vote Consensus

Updated 27 June 2026

Propose–vote consensus is a decision-making abstraction where agents propose candidate values and then vote to select the outcome, ensuring fault tolerance and inclusiveness.
It employs diverse aggregation methods—from majority and weighted votes to cryptographic signatures—to certify proposals while managing Byzantine faults and optimizing throughput.
Applications span permissioned blockchains, democratic decision frameworks, and distributed machine learning, with empirical data showing significant performance gains.

A propose–vote consensus is a class of decision-making protocols in which one or more agents, nodes, or processes propose candidate values, and a set of participants cast votes to select, certify, or aggregate among them. Such approaches unify a wide spectrum of models, from democratic collective choice and distributed systems to machine learning and blockchain settings. The propose–vote abstraction encompasses a highly generic paradigm: candidates (proposals) are surfaced by one or more agents, then votes—potentially weighted, aggregated, or combined—determine which proposal is adopted, certified, or used for downstream updates.

1. Core Propose–Vote Workflow and Abstraction

The generic propose–vote pattern has two or more phases. Typically:

Propose phase: One or multiple participants (e.g., “leader,” “proposer(s),” “anchor model”) put forward candidate values, policies, or blocks.
Vote phase: Each eligible voter (node, agent, or instance) evaluates (and may validate) proposals and casts a vote, often a signature or explicit ranking or weighting.
Quorum or Aggregation: Votes are tallied according to system-specific rules—a majority, supermajority, weighted sum, certificate of signatures, stochastic aggregator, or any function with appropriate intersection/safety properties.

Concrete implementations elaborate this abstraction to address context-specific constraints such as Byzantine agreement, strategic agent behavior, or communication cost. For example, leader-based BFT protocols like HotStuff instantiate a propose–vote loop over blocks, with cryptographically secure voting for safety and liveness (Neiheiser et al., 2021). Social choice procedures such as the Propose-or-Vote (PoV) protocol map the phases to candidate nomination and majority-based selection, even under sequential elimination (Gersbach, 6 Jun 2025). Extensions to machine learning employ propose–vote at the training or self-supervision level, using aggregates of model outputs (Du et al., 17 Mar 2026).

2. Protocol Classes and Algorithmic Variants

The propose–vote consensus pattern admits substantial variation across domains. Core classes include:

Protocol/Application	Proposer Role(s)	Vote Aggregation
Leader-Based BFT (HotStuff, etc.)	Single round-robin	Cryptographic signatures, 2f+1 quorum
Tree-Based Aggregation (Our-System)	Root/internal	Tree-aggregated multisets, m-ary trees
Committee Blockchains (Iniva)	Elected proposer	Inclusive multi-signatures, tree + fallback
Democratic PoV	Self-selected	Majority voting, sequential elimination
RLVR (DCRL)	Model as anchor/explore	Harmonic-mean over sample distributions
Polynomial Voting (PoS)	Any stakeholder	Weighted voting, polynomial/quadratic scaling
Networked Social Choice	All agents	Median voter/feedback on stubbornness
Nash Lottery/MaxParC	All agents	Utility aggregation, Nash bargaining, lottery

Leader-based BFT: A leader proposes a value, and a quorum of 2f+1 votes certifies it for safety (quorum certificate). Traditional star topologies concentrate vote aggregation at the leader, limiting scalability; tree-based aggregation balances load and bandwidth (Neiheiser et al., 2021).

Tree-based aggregation: “Our-System” replaces all-to-one collection with m-ary trees, distributing both computational and communication workload and admitting robust bin-rotating reconfiguration for optimal liveness under f Byzantine faults (Neiheiser et al., 2021). Iniva further strengthens vote inclusiveness and incentive-compatibility in committee-based settings by combining deterministic tree overlays with fallback “2nd-chance” rebroadcasts and indivisible BLS aggregation (Baloochestani et al., 2024).

Democratic and game-theoretic PoV: The Propose-or-Vote protocol enables agents to self-select as candidates/proposers or voters; sequential elimination and random pairing implement the Condorcet winner under single-peaked preferences in one round (Gersbach, 6 Jun 2025).

Nondeterministic proportional consensus: Mechanisms such as the Nash Lottery and MaxParC use continuous or threshold ballot aggregation followed by stochastic selection or bargaining to achieve proportional influence and mitigate minority suppression and status-quo bias (Heitzig et al., 2020).

Machine learning and RL: Dual Consensus RL employs a “model as proposer” for anchor samples and a temporarily unlearned “explorer” for diversity, with votes (or pseudo-labels) fused by harmonic mean, robustifying pseudo-labeling in unsupervised scenarios (Du et al., 17 Mar 2026).

3. Safety, Liveness, and Convergence Properties

Correct propose–vote consensus protocols must satisfy properties suited to their application domains:

Quorum Intersection: Any two sets of size q=2f+1 in an n-replica BFT system overlap in at least f+1 correct replicas, ensuring alignment and blocking equivocation (Neiheiser et al., 2021).
Reliable Dissemination: All correct processes eventually receive valid proposals if the underlying communication is robust (Neiheiser et al., 2021 Baloochestani et al., 2024).
Certificate Integrity: Aggregated votes must prove, via cryptography or auditability, that claimed support genuinely corresponds to distinct correct voters (Neiheiser et al., 2021 Baloochestani et al., 2024).
Inclusiveness: All honest votes get included in the final certificate when leader and internal nodes are honest, and fallback is available (Baloochestani et al., 2024).
Termination/Liveness: In BFT settings, protocols may require at most f+1 reconfigurations to guarantee progress, exploiting bin rotation over disjoint process groups (Neiheiser et al., 2021). In Iniva, no reconfiguration is required due to fallback paths.
Equilibrium Implementation: Democratic propose–vote, such as PoV, implements the Condorcet (median) winner as the unique subgame-perfect Nash equilibrium outcome under single-peaked quadratic utilities, with adjustments for even/odd cardinalities and tie-breaking (Gersbach, 6 Jun 2025).
Convergence in Social Networks: Networked propose–vote consensus with feedback on “stubbornness” enables, under decreasing-stubbornness rules, universal convergence to consensus, while increasing-stubbornness requires sufficient initial compromise (Ohlin et al., 2024).
Proportionality and Fairness: Proportional consensus methods guarantee that any group of size sN can secure a winning probability at least s for a chosen outcome by bullet-voting, formalized via the linear power curve (Heitzig et al., 2020).

4. Scalability, Aggregation Topologies, and Performance

Propose–vote scalability and efficiency depend critically on aggregation structure, communication complexity, and voting rule design.

Star vs. Tree: Classic star (all-to-one) aggregation centralizes bandwidth and CPU at the leader (bottleneck). In contrast, m-ary aggregation trees balance load among internal nodes, with performance scaling as (n–1)/m, leading to empirical throughput gains of up to 38× HotStuff in large geo-distributed settings (n=400, m≈20) (Neiheiser et al., 2021).
Pipelining: Tree-based systems permit deep pipelining, with up to 7× more parallel consensus instances in WAN deployments, further exploiting high-latency links (Neiheiser et al., 2021).
Overhead and Trade-offs: Protocols like Iniva incur ≈30% throughput overhead versus centralized star, justified by the reduction in omission probability (from m to m²) and enhanced inclusion (Baloochestani et al., 2024).
Cryptography: BLS signature aggregation yields cost nearly independent of signature count, while secp256k1 cost grows linearly (Neiheiser et al., 2021).
Byzantine Resilience: Aggregation schemes are robust against targeted vote omissions, with the probability of losing an individual vote scaling as m² for an adversary controlling fraction m of nodes in Iniva (Baloochestani et al., 2024).
Asynchronous Operation: Recent protocols such as Validated Strong Consensus (VSC) achieve safety and liveness with O(N) view-change and voting message complexity, matching HotStuff–style protocols without threshold signatures, by leveraging explicit vote graphs and randomized elimination (Xu et al., 2024).

5. Applications Across Domains

Propose–vote consensus is foundational in:

Permissioned/Byzantine Blockchains: Leader-based BFT (HotStuff, Our-System, Iniva), committee-based PoS chains, and asynchronous SMR all build on propose–vote abstractions (Neiheiser et al., 2021, Baloochestani et al., 2024, Xu et al., 2024, Tang et al., 2022).
Democratic Procedures: Propose-or-Vote mechanisms are applicable to parliamentary motions, committee decisions, and entry-limited elections for efficient, median-centric consensus (Gersbach, 6 Jun 2025).
Nondeterministic Democracy: Nash Lottery and MaxParC generalize propose–vote to fairness-proportional lotteries, applied to electoral, multi-faction, or participatory budgeting scenarios (Heitzig et al., 2020).
Distributed ML & RL: Dual Consensus RL, Self-reward, and related pseudo-labeling strategies for LLMs instantiate propose–vote in the generation and selection of supervision signals (Du et al., 17 Mar 2026).
Consensus in Social Networks: Feedback-based iterative opinion dynamics in peer networks or committees (Ohlin et al., 2024).

6. Key Theoretical Results and Performance Metrics

Substantial formal analysis underpins propose–vote consensus mechanism design:

Optimal Liveness: Tree reconfiguration via (f+1) bin rotations yields liveness in the minimal number of rounds for BFT protocols (Neiheiser et al., 2021).
Vote Inclusion: Iniva achieves inclusiveness (all honest votes retained) in at most 7Δ communication rounds, without reconfiguration, under both crash and Byzantine faults (Baloochestani et al., 2024).
Omission Probability: Under Iniva, the probability of omitting a single honest vote without high collateral exclusion drops from m (star) to m², increasing the cost of targeted adversarial attacks (Baloochestani et al., 2024).
Condorcet Implementation: PoV uniquely enforces the Condorcet winner under single-peakedness in one round, provided odd electorate or AI tie-breakers (Gersbach, 6 Jun 2025).
Power-Proportionality: In MaxParC and Nash Lottery, any group can guarantee influence proportional to its size, substantiating strong fairness even under strategic voting (Heitzig et al., 2020).
Convergence Rates: For opinion dynamics, decreasing-stubbornness rules accelerate convergence to consensus, with practical rates approaching an order-of-magnitude speed-up over static-stubbornness dynamics (Ohlin et al., 2024).
Empirical Performance: Tree-based BFT (Our-System) achieves up to ~38× throughput of HotStuff with BLS signatures, and Iniva maintains >99% honest-vote inclusion with moderate system size and adverse conditions (Neiheiser et al., 2021, Baloochestani et al., 2024).

7. Design Trade-Offs, Extensions, and Research Directions

Aggregation Depth vs. Latency: Larger tree fan-out reduces per-node load but impairs fault tolerance; deeper trees amortize aggregation at the cost of higher latency (Neiheiser et al., 2021).
Reconfiguration Overhead: Optimal bin-rotation avoids exponential reconfiguration costs upon faults but requires cardinality constraints (each bin ≥ internal nodes) (Neiheiser et al., 2021).
Security–Liveness Tuning: In polynomial voting PoS, increasing the polynomial parameter α slows power accrual in exchange for security against stake monopoly, captured in explicit convergence and decay rates (Tang et al., 2022).
Indivisibility and Auditability: Algorithmic mechanisms leverage cryptographic properties (e.g., BLS aggregation) or explicit signature multiplicity tracking to enforce vote inclusion and identify/penalize free-riding or omission (Baloochestani et al., 2024).
Generalization Potential: The propose–vote abstraction, especially as formalized in two-stage RL and cross-domain protocols, admits drop-in adoption in any unsupervised, committee, or distributed learning context, with empirical support for improved stability and consensus accuracy (Du et al., 17 Mar 2026).
Future Work: Open questions concern adaptive reconfiguration, dynamic network topologies, algorithmic resistance to strategic manipulation or sybil attacks, and the interplay between communication complexity and fair division in large-scale decentralized systems (Neiheiser et al., 2021, Gersbach, 6 Jun 2025, Tang et al., 2022).

Propose–vote consensus, as a theoretical and practical construct, provides a unified principled foundation for a broad range of distributed decision-making and aggregation systems, simultaneously balancing efficiency, fault-tolerance, proportionality, and strategic robustness across diverse application domains.