The instrument is fine. The plumbing is the problem.
Binary contracts financialized everything. A binary contract pays $1 if an event occurs and $0 if it doesn't. Its inverse, the NO contract, pays $1 if the event does not occur. Because the payoff is bounded between zero and one dollar, the price is a probability: a YES trading at 64¢ is roughly* the market saying 64% likely. That is an unreasonably clean primitive. Binary contracts are an option whose strike is "the event happened,” first time traders can understand it, and regulators in most jurisdictions have actually gotten comfortable with them. Polymarket and Kalshi used it to turn elections, weather, macro prints, and sports into liquid markets. Overall the contract works.
So I want to be precise about what doesn't work, because the popular diagnosis is wrong. The popular diagnosis is that the binary contract is too crude, and the fix is to invent a richer instrument. I believe the contract is fine and the infrastructure underneath it never grew up. We built binaries, scrambled to make them work on everything, and then stopped thinking about the plumbing. Three problems follow from the plumbing, not the contract.
Take a concrete market: "what will the price of BTC be on July 4, 2026?" That's a scalar question, and a binary can't express a scalar directly. So you do what every prediction venue does: you list a ladder of binaries. BTC ≥ $50k by July 4, ≥ $60k, ≥ $65k, ≥ $70k, and so on. Each rung is a binary. Together the rung prices sample the distribution of where BTC lands. The ladder is the workaround that lets a discrete instrument cover a continuous variable, and almost every interesting market is secretly a ladder.
That workaround creates three pathologies:
- Liquidity fragmentation. The single underlying belief, "where will BTC be," is split across N separate order books that don't know about each other. The same conviction that should deepen one market instead spreads thin across many. Each book is shallower than the truth warrants.
- Fixed bands. The market creator picks the rungs. If the listed strikes are $65k and $70k, there is no native way to say "I think it's $67.5k." Your precision of expression is capped by someone else's grid.
- Maker capital inefficiency. A market maker has to quote every rung and post the full notional behind every share at every rung, even though their positions across the ladder net out in a very predictable way. Capital that should back one coherent view is instead frozen rung by rung. So makers quote fewer markets, less deeply, which feeds straight back into the first problem.
There is a school of thought that attacks all three by changing the instrument. Paradigm's Distribution Markets work and platforms like Function Space let traders express a belief as a curve, a continuous probability distribution, rather than a stack of binaries. Pricing comes off a payoff curve instead of an order book, so there's no cold-start liquidity to source and no grid to fragment across. It's elegant, and it genuinely solves fragmentation and fixed bands by construction. I have a lot of respect for the idea.
But changing the instrument has costs. A novel continuous instrument is a new regulatory surface, a new thing institutions have to get comfortable underwriting, and a new thing a first-time user has to learn. Curve-priced markets also lean on an AMM-style payoff function rather than a central limit order book, which trades away some of the price discovery and the "someone is taking the exact other side of my trade" clarity that a CLOB gives you. You solve fragmentation by giving up the order book.
This essay is about the other road. Keep the binary contract (it's adopted, it's legal, it's understood) and fix the infrastructure underneath it. The mechanism is what I've been calling a 4D order book. The claim is that all three pathologies are consequences of running each rung as an isolated 2D book, and that once you put the whole ladder under one structure, capital efficiency, liquidity, and execution quality stop being trade-offs and start being properties.
One book, four dimensions
A classic order book has two dimensions: price and depth (the resting quantity at each price). That's all you need when the thing trading is a single instrument, like a share of stock or one futures contract. Price and depth fully describe the state.
A laddered execution risk is not one instrument. It's a family of related binaries, indexed by two more things: which strike (the $50k rung vs. the $65k rung) and which date (the July 4 expiry vs. the July 5 expiry). So the natural state isn't a book. It's a four-dimensional object:
Strike date × Strike value × Price × Depth
Today the industry stores this as a sparse pile of 2D books, one per (date, strike) cell, that are blind to one another. The 4D framing says: model the whole object as one thing, on one thread, on one ordered log. When you do, three capabilities fall out that are simply unavailable when the cells are isolated:
- Netting computes collateral against your whole position in the object, not rung by rung.
- Implied liquidity lets an order at one cell fill from economically equivalent orders at other cells, including synthetic cells the creator never listed.
- Atomic execution treats a sweep or quote across many cells as a single all-or-nothing operation.
Let me take them in order. The math is general (it works for any laddered binary market), and I'll keep it at the level of why it's true rather than the production constants.
Pillar one: Capital efficiency through netting
Here is the principle the entire pillar rests on:
A participant's required collateral should equal their worst-case loss across all joint resolution outcomes, computed over their entire position at once, never the sum of per-instrument requirements.
Make that precise. A resolution group (a ladder, a single binary, a mutex set) has a finite set of mutually exclusive outcomes Ω, the states the world can resolve into. Each instrument i pays Mᵢ(ω) per unit held in outcome ω (for a binary, either $1 or $0). A participant holds hᵢ units of instrument i (signed: positive for long, negative for short) and carries a net cash basis B, which is what they've already paid or received, with resting orders folded in at their limit prices as if filled. Their net worth if the world resolves to ω is
W(ω) = Σᵢ hᵢ · Mᵢ(ω) + B.
The collateral that keeps the account solvent in every state is the negative of the worst state, floored at zero:
Margin = max( 0 , − min over all outcomes ω of [ Σᵢ hᵢ · Mᵢ(ω) + B ] ).
This one expression, a payout-matrix worst case, is the whole netting engine. Everything interesting is a special case of it.
The covered pair → zero margin. Hold q YES and q NO on the same rung. In the YES-wins state the YES pays $q and the NO pays nothing; in the NO-wins state it's the reverse. Either way Σᵢ hᵢ·Mᵢ(ω) = $q, a guaranteed dollar per pair, in every outcome. If you acquired the pair for $q (basis B = −$q), then W(ω) = 0 everywhere and the margin is exactly zero. The pair is self-collateralizing; it carries no risk because it can't lose. (This is precisely minting a contract pair.)
Cross-strike netting → spreads cost the gap, not the notional. On a survival ladder with strikes K₁ < K₂ < … < Kₙ, the rung "≥ Kᵢ" pays $1 in every outcome where the underlying reached at least Kᵢ. Reaching K₂ implies you reached K₁, so the outcomes are monotone, which collapses the payout matrix to upper-triangular: Mᵢ(ω) = $1 exactly when the realized band is at or above Kᵢ. Now consider a vertical spread: long "≥ Kᵢ", short "≥ Kⱼ" with i < j. Its payoff is
$1 · ( 1[ band ≥ Kᵢ ] − 1[ band ≥ Kⱼ ] ),
where 1[·] is 1 when the condition holds and 0 otherwise. That pays $1 only when the underlying lands between Kᵢ and Kⱼ, and $0 otherwise. The worst case is bounded by the gap between two adjacent strikes, not by the full notional of either leg. Margining the legs separately would demand collateral for two independent dollar-risk positions. The joint worst case sees that they hedge, and asks for a fraction. That fraction is the real risk.
Cross-date netting → calendars hedge too. Extend monotonicity to the date axis: if the underlying touches K by July 4, it has necessarily touched K by July 5. So a calendar spread (long a strike at one expiry, short the same strike at a later one) cannot lose both legs. Folding all live expiries into one joint outcome space (ordered band-sequences across dates, sharing a single cash basis and a single solvency floor) only ever tightens the requirement relative to margining each date independently. A maker running a book of vertical and calendar spreads across the whole surface posts collateral for the residual risk of the whole structure, which is a small multiple of a single rung's risk rather than the sum over hundreds of cells.
The two-sided quote, and a correction. It's tempting to summarize all this as "a maker can quote both sides of a market on the capital of one side," and that's directionally right but needs to be clarified. Orders fill independently: a resting bid and a resting ask sit on opposite sides of the book at different prices, and an incoming order can only lift one of them at a time. The correct statement is the worst-case one. The maker's exposure is the maximum over disjoint fill paths, not the sum:
Margin( bid and ask ) = max( risk if only the bid fills , risk if only the ask fills ) ≤ risk(bid) + risk(ask).
You cannot simultaneously be maximally long (only your bid was hit) and maximally short (only your ask was hit). Those are different futures. The margin is the worst of them, and the netting calculus prices it that way automatically because both resting orders are folded into the same min-over-outcomes. That is why two-sided quoting costs roughly one side's capital. It is a statement about worst-case loss across joint outcomes, not about buys cancelling.
Put the three together and a maker can quote the entire ladder across multiple expiries on a small multiple of a single rung's capital. The capital that was frozen rung by rung is freed to deepen the book. That is the direct cure for maker capital inefficiency, and a partial cure for fragmentation.
Pillar two: Liquidity through implied and synthetic depth
Netting fixes how much capital a maker needs. The next problem is that even a well-capitalized maker's liquidity is still trapped in whatever cell they posted it. Implied liquidity unsticks it.
Futures exchanges have done a version of this for decades. NASDAQ and CME route "implied IN/OUT" orders, where an order in one contract is filled from a combination of orders in related contracts that together replicate it. I have not seen it applied to execution risks, and the laddered structure is ideal for it, because every rung is a clean linear payoff over the same outcome space.
Formalize it. Give each instrument i a payoff vector vᵢ in ℝ^|Ω|, its payout in each outcome. Resting orders let you buy or sell these vectors at their posted prices. An incoming order wants some target payoff u for a price no worse than p. A classic order book fills it only if some single resting order is the mirror image −u. Implied matching asks a better question: is there any non-negative combination of resting orders, across all strikes and all dates, that covers u for a total cost within p?
minimize Σₖ aₖ · πₖ subject to Σₖ aₖ · vₖ ≽ u , with all aₖ ≥ 0,
where πₖ are the resting orders' prices, aₖ the quantities pulled from each, and ≽ means "covers in every outcome." This is a small linear program over the ladder lattice, bounded by the number of live rungs, so it's cheap to solve on the hot path. The consequence is that liquidity posted anywhere on the surface is liquidity available everywhere it can be combined. The N shallow books stop being independent. They become one deep book viewed through N windows. Fragmentation dissolves.
And it hands back the curve school's headline feature for free. A synthetic rung is just a target payoff that no listed instrument provides but a combination does. Want to be long "BTC ≈ $67.5k" when only $65k and $70k are listed? That digital is, to a close approximation, a tight call spread between the two listed rungs, a payoff vector inside the span of what's already resting. The engine can fill it synthetically. So traders get continuous expression on top of binary contracts, the exact thing distribution markets had to redesign the instrument to achieve, without leaving the CLOB, without a new contract type, and without a new regulatory surface. Fixed bands dissolve too.
I want to be honest about the two real costs, because there is a reason this isn't already everywhere.
Counterparties aren't 1:1. When your order fills synthetically, there is no single trader who took the exact other side of your bet. Your position is collateralized by a basket of partial counterparties whose legs only jointly mirror you. The netting calculus keeps every leg properly margined, so the system stays solvent. But the clean "someone is short exactly what I'm long" mental model breaks, some participants care about that. Most importantly, regulators are cautious on this subject because of how quickly the underlying collateral can erode.
Priority becomes harder, so it must be open. Price-time priority is unambiguous in one book. Across a lattice of implied combinations, "who fills, from which combination, in what order" is a real allocation problem with more than one defensible answer. The rule has to be deterministic, fully specified, and published: reproducible from the order of events alone, so any fill can be audited and re-derived. Financial institutions are rightly wary of execution they can't reconstruct, and being clever here without being transparent is how you lose their trust. The mechanics can and should be open-sourced.
Pillar three: Atomic execution
The third gap is the one I find least defensible in the current generation of venues, and the easiest to feel as a trader.
Suppose you've decided to express a view across the whole BTC ladder: quote five rungs at three expiries, or take a synthetic position that needs three legs to assemble. You submit your orders. On a venue with no atomicity guarantee, which is roughly where Kalshi's best-effort batching sits, some of those legs land and some don't. You wanted a spread, and you got one naked leg and a rejection. You wanted to requote your surface, and half your old quotes got lifted before the new ones posted. For multi-rung structures, where the whole point is the relationship between the legs, partial execution isn't a minor annoyance. It's a different position than the one you chose, and often an unhedged one.
Atomic execution makes the multi-leg operation the unit. A multi-strike operation carries N legs spanning strike × date, plus a policy:
- All-or-none: a pre-check projects every leg against current depth. If every leg can fully fill within its own limit, and the total slippage stays within a stated cap, the whole basket commits. Otherwise the basket is rejected and nothing moves. You are never legged.
- Best-effort: fill whatever is available right now and cancel the remainder, but as one evaluated decision rather than a hopeful spray of independent orders.
The same primitive handles a maker's re-quote: cancel my old surface and post my new one as a single atomic step, so there is no window where I'm exposed with neither.
Here's the part that matters architecturally. Atomicity across the whole 4D object is nearly free when the exchange architecture is built on the right foundation. When the entire object lives in one thread, a multi-leg order is one command. It either applies in full or rejects: no locks, no two-phase commit, and no cross-shard coordination.
The obvious objection is throughput. Can one thread carry a real venue? Yes, and it isn't close. The 2D matching engine I built and demonstrated runs around 8 million operations per second on one core, already more than enough for a venue like Kalshi and comfortable for most equities venues. Going to 4D doesn't add a throughput wall. It adds addressing (which cell) and a bit of netting arithmetic (the bounded min-over-outcomes for a ladder), both small, cache-resident, sub-microsecond operations. The dimensions are cheap relative to the rewards. With atomic execution across the 4D surface, you expand the tradable instruments notably, I may write an article later on what this may look like.
The payoff: The book becomes the oracle
Everything above is, on its face, an argument about execution quality.
A laddered market is a measurement instrument. Each rung's mid-price is the market's estimate of P(underlying ≥ K by T), a sample of the implied cumulative distribution of the underlying. Stack the rungs across strikes and you get the whole implied distribution. Stack them across dates and you get its term structure. Run that through an estimation pipeline and the books become a live, forward-looking probability surface and an implied value.
So trace the causal chain. The quality of that signal is bounded by the quality of the rung prices it reads. And the three pillars are each, directly, a rung-price quality mechanism:
- Netting frees makers to quote the entire surface instead of a few rungs, so the distribution is sampled densely rather than sparsely.
- Implied liquidity fills the gaps between quoted rungs, including the synthetic strikes nobody listed, so the CDF is read at high resolution instead of at the creator's coarse grid.
- Atomic execution lets makers move their whole surface coherently as information arrives, so the prices stay consistent across rungs at every instant rather than getting transiently arbitraged into noise.
Denser, gap-filled, internally consistent rung prices are a higher-fidelity implied distribution, which is a better signal.
Coda
execution risks have outgrown their infancy as an instrument and stalled as an infrastructure. The binary contract is a genuinely good primitive, legible and liquid and legally tractable, and I don't think the path forward is to throw it out for something more exotic. I think the path forward is to take the plumbing seriously: to stop running each rung as an island and start treating the whole laddered surface as one object, in four dimensions, on one deterministic engine.
Do that and the three chronic problems invert into properties. Capital that was stranded rung by rung nets across the surface and frees up to deepen the book. Liquidity that was fragmented across N books becomes one deep book with N windows, and traders get continuous expression without a new contract. Execution that was best effort and leggy becomes atomic by construction, because a single writer has nothing to coordinate with. And the better prices that result feed the thing that actually matters: a truer picture of what the world believes.
This is part of our thesis at Route5, and it's being implemented as a core part of our exchange infrastructure.
Notes & references.
* Manski Bounds more accurately describes the binary market contract price as a traded price formed by beliefs, incentives, liquidity, risk preferences, and capital constraints. One contract partially reveals the underlying probability of the event. With laddered markets, interpreting the market properly involves looking at the entire distribution rather than treating one rung as the truth.
The "curve school" of continuous-distribution markets is best represented by Paradigm's Distribution Markets (D. White, 2024) and by Function Space's payoff-curve, self-liquidity design; this essay argues a complementary path that keeps the binary instrument. The netting, implied-liquidity, and atomic-execution mechanisms above are described at the level of general principles; production constants and the exact reserve and settlement formulations are out of scope here.