The last article covered where Cardano is going and why to believe it. This one zooms in on the hardest parts: what Dijkstra actually changes, and how it produces “unlimited scaling” and “two-minute settlement.” I’ll tie the whole piece to one question — where exactly is a consensus chain’s bottleneck?

The ceiling every chain hits: one formula

Nearly every public chain is bound by the same physical constraint: a new block must be seen by the network quickly. The reasoning chain is short: a block is the vehicle of consensus, and the whole network extends the same ledger. If a block is too big and takes too long to propagate, some nodes will produce the next block before seeing it, two branches grow at once, and the chain forks. So a protocol must choose between “big blocks” and “frequent blocks,” and throughput gets locked into “block size ÷ block time” — any chain that builds its security on global synchronization is stuck with this formula.

That alone explains why “on-chain scaling” reads like a dead end: bigger blocks won’t propagate, tighter intervals won’t last, and the only escape is moving the work — which is what Ethereum did, down to L2. None of these paths touches the formula itself; they all walk around it.

Leios: split “ordering” from “packing,” and the ceiling vanishes

Leios’s cleverness is denying the formula’s premise. My first reaction to the idea was: shouldn’t global synchronization mean synchronizing everything? Thinking it through, the only thing nodes truly cannot disagree about is order. Who goes first, which transaction follows which — that must be instantly consistent network-wide; the transaction content itself can arrive seconds late and nobody cares. The formula held because it bundled “the order that must sync” together with “the data that could be async,” and Leios unbundles them.

The split gives blocks two roles (I unpacked Leios’s original three-layer design in “Cardano’s Biggest Upgrade Yet, Leios”; what follows is today’s two-layer Linear version). Ranking Blocks (RBs) stay tiny and light, caring only about “who goes first,” propagating exactly as they do today — fully synchronous, security model untouched. Endorser Blocks (EBs) are the big ones, referencing batches of transactions, no longer squeezing into the consensus channel; they spread down a dedicated bandwidth pipeline, get validated by a stake-selected committee, and enter the ledger after a high-threshold vote (e.g., 75%) issues a certificate.

flowchart TB
    T[A transaction] --> EB[Endorser Block<br/>batches of transactions<br/>spreads on the bandwidth pipeline]
    EB --> V[Stake-selected committee validates<br/>high-threshold vote, e.g. 75%]
    V --> CERT[Certificate]
    CERT --> RB[Ranking Block<br/>small, fast, fully synchronous<br/>records EBs and their order]
    RB --> CHAIN[On-chain]

Following one transaction makes it concrete: a transaction gets packed into some EB and spreads along the bandwidth pipe; the committee validates the EB, the votes reach quorum, a certificate is issued; RBs keep their old rhythm and record which EBs, in what order. The sync channel still carries the small, fast ordering block, while the heavy cargo rides the side pipeline.

Here’s the turning point: the part that “must sync” (ordering) and the part that “can be async” (packing) are fully separated. What must sync stays small and fast; packing rides the bandwidth rail. And that’s why security isn’t torn apart — the ordering layer never shrank, and the packing layer is backed by committee endorsement.

Why this counts as “unlimited scaling”

The throughput formula existed because it assumed all data had to squeeze into the small block that syncs network-wide. Leios breaks precisely that assumption: transactions no longer enter ranking blocks; they enter endorser blocks that ride the bandwidth pipe and can in principle be produced without end.

So the new formula becomes: throughput ≈ network bandwidth ÷ transaction size. The ceiling moves from a hard protocol rule to physical network bandwidth — an infrastructure capability that grows as the network upgrades, unlike a protocol parameter that tops out.

“Unlimited” isn’t mysticism, then. It’s handing the decision about the ceiling back to the physical world. Ordering stays linear forever, security is topped up every step, and only throughput tracks bandwidth. August’s first public test already measured about 6x mainnet; what mainnet reaches depends on transaction size and network health.

Peras: settlement from 12 minutes to 2

Throughput asks “how much can fit,” settlement asks “when does the money count.” This was Cardano’s weakest hand. Praos settles probabilistically: the more blocks pile up behind one, the lower its rollback chance — but at no point does a hard line exist saying “past here, it cannot flip.” Exchanges fall back on the blunt method: wait for confirmations until the rollback probability is negligible, which at Cardano’s block pace means around twelve minutes.

Peras’s answer is to stack a voting layer on Praos. Time splits into rounds; each round draws a voting committee weighted by stake; members sign votes for the block they endorse; when one round gathers quorum, those signatures coalesce into a certificate.

The certificate changes the mechanics of the block race. Under Praos, two competing branches pull apart in weight slowly, block by block, neither able to instantly dominate. A certificate-boosted block becomes “heavy” in one stroke — ordinary block production cannot catch up in comparable time. Rolling back a certified block takes more than producing new blocks: a certificate is a one-time set of signatures from a stake-drawn committee within a single round, and an adversary cannot re-derive it by mining longer; the only path is assembling another quorum, which is exactly what the protocol makes hardest.

Failing to vote doesn’t break anything either: when a round misses quorum, it enters cool-down, the boost expires, and the chain falls back to plain Praos until conditions recover. The speed is an added gear; the safety floor is still Praos itself — self-healing, never forcing it.

The mechanism pushes high-confidence time from about 12 minutes down to about 2. For an ordinary holder, 2 vs 12 barely matters; for bridges, partner chains, exchanges, high-value DeFi, and institutional settlement, it’s real money — every minute locked in settlement waiting is a cost. Certificates and voting stay compact, backed by a formal Agda spec, and the paper has passed SCN ‘26 review.

Cost: stop the resource burn

With capacity and speed up, one question remains: is it cheap to use? Dijkstra counts that bill too. July’s van Rossem hard fork already updated the Plutus cost model — the price list that decides what every step of script execution costs on-chain — making contract execution cheaper; that’s the first stone laid before Leios. Nested Transactions restructure instead: a complex transaction’s sub-transactions are organized into a nested structure, so resource allocation and reuse get smarter and total execution overhead drops.

Putting it together: pack more, confirm faster, spend less

The three are one chain: pack more (Leios), confirm faster (Peras), spend less (Nested Transactions). And it stands only because neither collapses: Leios puts trust in the linear chain, Peras accelerates under benign conditions and falls back to the conservative protocol under hostile ones — the security model is never watered down.

So my read is that Dijkstra’s value isn’t the pretty TPS number; what it actually does is move Cardano from “slow but steady” toward a settlement layer that’s “fast, steady, and cheap.” Once both phases (Leios and Nested Transactions in Q4 2026, Peras in Q2 2027) clear testing and voting, we’ll find out.

Article Link: