Ouroboros Leios is a major evolution of the Cardano consensus protocol, engineered to deliver significantly higher throughput while maintaining decentralization and security. Its design introduces pipelining and parallelism into transaction processing — two powerful changes that allow the network to scale. But with this advancement comes a subtle yet crucial shift: Leios must soften the strict determinism that underpins traditional blockchain behavior. In practice, this means that many of the guarantees users and developers take for granted — like the assumption that a valid transaction will always be included once it passes local checks — become probabilistic rather than absolute. This shift is not a flaw but an inherent cost of moving from a serialized to a parallel system. It reflects the core trade-off in designing scalable decentralized infrastructure. What Is Determinism? Determinism, in the context of blockchain protocols, refers to the idea that identical inputs should always lead to the same outputs. When a user submits a valid transaction — meaning one that satisfies the UTxO and script conditions based on the current ledger state — they expect that transaction to be accepted and included in the blockchain exactly once. This expectation extends to the outcome of fees, the order of transactions, and the final ledger state. Under deterministic assumptions, a transaction that passes local validation is guaranteed to succeed globally, and nodes processing the same data in the same order will produce the same result. In Praos, the existing consensus protocol used by Cardano, this determinism is relatively easy to maintain. Every block is produced sequentially in 20-second intervals, giving nodes ample time to receive the latest block, update their UTxO state, and filter out conflicting or redundant transactions from the mempool. Because of this structure, nodes operate with a relatively synchronized global view, which makes transaction inclusion predictable and conflicts rare. In Praos, a single block is produced, then quickly propagated across the network. After that, the system enters an idle period, during which most nodes do very little until the next block is created. This slower pace gives the network more time to synchronize and resolve conflicts, which reduces the chance of duplicated or conflicting transactions being processed at the same time. Thanks to this, Praos can provide a high degree of determinism. The Role of Pipelining in Leios Leios changes the game by introducing a pipelined architecture for transaction processing. Instead of one block being constructed at a time, Leios separates the processing of transactions into three distinct stages, each handled by its own type of block. Input Blocks (IBs) are built rapidly and in parallel by block producers using their local view of the mempool. These blocks are speculative: they propose transactions that might be valid but are not yet final. Endorsement Blocks (EBs) come next. They filter and validate the transactions proposed in Input Blocks, resolving any conflicts or duplications. Finally, Ranking Blocks (RBs) anchor the endorsed transactions into the ledger and finalize them as part of the canonical chain. In three phases in the pipeline, 3 different types of blocks are created. The pipelined flow allows for overlapping stages. While one Ranking Block is being finalized, new Input Blocks are already being created for the next. This approach removes bottlenecks and enables high transaction throughput — but it also introduces uncertainty. Because nodes are not globally synchronized and operate off different snapshots of the mempool and UTxO state, it becomes common for the same transaction to appear in multiple Input Blocks, or for conflicting transactions to coexist temporarily in the system. Leios processes transactions in several pipelines running in parallel. The result of the pipeline is the creation of new Ranking Blocks. New ones are created continuously. The Softening of Determinism With parallel Input Block production, the assumption that local validity ensures global inclusion no longer holds. A user may submit a valid transaction, and that transaction may appear in several Input Blocks due to propagation delays and local differences in state. However, only one version of the transaction will ultimately be endorsed and finalized; the others will be discarded. TX3 is a duplicate and has been inserted into all four Input Blocks. This conflict must be resolved. This breaks the determinism seen in Praos. In Leios, the path from transaction submission to finalization involves speculative inclusion and post hoc filtering. Validity is no longer a binary decision made at submission time — it’s a process resolved through consensus across multiple layers. The final ledger remains deterministic, but the journey to that ledger becomes probabilistic. Fee Handling in a Non-Deterministic Pipeline One area where this softening of determinism becomes particularly visible — and challenging — is in the handling of transaction fees. Under Praos, users pay once, and their transaction is either accepted and finalized, or it is rejected and costs nothing. In Leios, a user might submit a single transaction with a fee (say, 0.17 ADA), but that transaction could be picked up by multiple block producers and included in four different Input Blocks. Since all four copies require processing and consume network resources, this creates ambiguity: should the user pay four times? Or just once? The protocol must walk a fine line. On one hand, it’s unfair to charge an honest user more than once for a single action they submitted only once. On the other hand, the network must not allow attackers to cheaply spam the system by submitting redundant or conflicting transactions that are never finalized but still use up compute and bandwidth. TX3 is a duplicate and was inserted into all four Input Blocks. The user submitted the transaction only once and paid a fee of 0.17 ADA. However, resolving the conflict may be more costly than just 0.17 ADA. This is not a trivial problem. It affects both economic incentives and user trust. Although Leios is expected to charge fees only for the finalized transaction, preventing abuse may require additional mechanisms — such as temporary collateral, fee deferral until endorsement, or tombstoning of discarded transactions. These tools can ensure that attackers pay real costs for trying to clog the system, while honest users are shielded from overpayment. Data Availability and the Limits of Synchronization Data availability is another critical aspect that becomes more difficult in a pipelined, parallel system. In Praos, each new block is broadcast and diffused across the network before the next one is built, giving nodes time to remain in sync. This helps ensure that everyone has access to the same ledger state before acting on it. Leios, by contrast, allows new Input Blocks to be built almost continuously, and by different nodes working in parallel. This reduces the time window for synchronization and increases the chances that some nodes will miss certain blocks or transactions before producing their own. As a result, data availability becomes a more sensitive issue — not just for conflict resolution, but for maintaining ledger correctness and efficient validation. Ensuring that all relevant Input and Endorsement Blocks are available to validate a given Ranking Block becomes essential. If this availability breaks down, validators may be unable to finalize blocks or may reject valid transactions due to missing context. The Throughput–Determinism Trade-off At the heart of all this lies a fundamental trade-off. Determinism favors serialization, isolation, and predictability. High throughput favors concurrency and speculation (during the preparation phase). These two goals are in tension. It is not possible to process thousands of transactions in parallel while preserving perfect global determinism without sacrificing scalability. Complete pipeline cycle from speculative transaction inclusion to conflict resolution. Ouroboros Leios makes a deliberate choice: it softens determinism in order to scale. It embraces speculative transaction inclusion, defers finality to later stages, and accepts that not every valid transaction will be finalized immediately. In return, it offers vastly higher throughput, lower latency, and the ability to support large-scale decentralized applications and infrastructure. The ledger remains coherent and secure, but the path to that ledger is now paved with trade-offs, filtering, and reconciliation. The protocol trusts that consistency will emerge through consensus — not be enforced up front by strict serialization. The output of each pipeline cycle is a new Ranking Block, which defines the current global state of the ledger at that specific point in time. All new transactions added to the Input Blocks in the following pipeline cycle are then validated against this latest Ranking Block, ensuring consistency and correctness across the system. All duplicate and conflicting transactions must be resolved before a new Ranking Block is created. Creating three Ranking Blocks in three consecutive pipelines. Notice how the Input Blocks reference previous Ranking Blocks and that new Input Blocks are created continuously without a break. Conclusion Ouroboros Leios changes how Cardano processes transactions at a fundamental level. By introducing pipelining and parallelism, it opens the door to scalability and responsiveness that sequential systems cannot achieve. But to do so, it must relax some of the rigid guarantees of determinism — particularly around transaction inclusion, fee finality, and data propagation. This softening of determinism is not a weakness, but a new design paradigm. It acknowledges that in a distributed, high-throughput system, flexibility and adaptability are essential. The challenge now is to build the right incentive structures, validation layers, and conflict resolution mechanisms that preserve fairness, efficiency, and trust in a more complex and dynamic environment. Leios does not abandon determinism. It refactors it — postponing it until the protocol has done the hard work of reconciling parallel intentions into a singular, finalized truth. The next article will explore why duplicate and conflicting transactions occur, and explain how Praos and Leios handle them differently.
