Ethereum has spent the better part of a decade optimizing for settlement infrastructure. Nearly every major breakthrough of the last few years has focused on increasing throughput, reducing transaction costs, improving verification systems, or modularizing the blockchain stack into increasingly specialized components. Rollups, shared sequencers, alternative virtual machines, modular execution layers, specialized data availability systems, and increasingly sophisticated proving architectures have dramatically expanded what blockchains are technically capable of.
And yet despite all this infrastructural sophistication, crypto markets still feel structurally inefficient in ways traditional financial systems often do not.
Execution quality remains inconsistent. Liquidity is fragmented across domains. Routing is probabilistic. Settlement guarantees vary between environments. Cross-chain interactions introduce latency and uncertainty. Capital efficiency deteriorates as state becomes increasingly distributed.
Users may technically have access to more chains, more protocols, and more applications than ever before, but the underlying market structure often feels less coherent rather than more.
I increasingly think the reason for this is that the industry optimized away one of the most important properties early blockchain systems accidentally provided: synchronous composability.
Synchronous composability is usually described as a developer primitive. Smart contracts can call one another atomically within a shared execution environment. Protocols can coordinate actions against a single canonical state transition. Developers can compose financial applications together without introducing asynchronous settlement risk between interactions.
All of that is true, but I think it understates the significance of what synchronous composability actually enabled.
What Ethereum really introduced was not merely programmable settlement—it introduced coordinated execution.
It was not simply that contracts could interact with one another. Markets themselves could coordinate state transitions synchronously under shared sequencing guarantees. Liquidity, collateral, execution logic, and settlement all existed within the same deterministic environment.
A user could swap on Uniswap, borrow against the resulting position on Aave, refinance through Maker, and settle the entire sequence atomically against a single state machine. The system compressed enormous categories of coordination complexity into a unified execution environment.
This had profound implications for market efficiency because it eliminated entire categories of execution uncertainty that emerge naturally in fragmented systems. Latency risk, partial settlement risk, asynchronous inventory management, stale routing information, and reconciliation overhead were dramatically reduced because every participant interacted against the same globally visible state transition under shared sequencing guarantees.
The market itself became more coherent because execution itself was coherent.
The Infrastructure Shift
The original “money lego” thesis was more profound than many people realized at the time. The real innovation was not simply composable applications, but composable execution itself. In hindsight, I do not think the ecosystem fully appreciated how economically valuable that property was before much of it was traded away in pursuit of scalability.
The move toward modular architectures and fragmented execution environments was entirely rational in isolation. Rollups improved scalability. Specialized execution environments enabled optimization around different workloads. App-specific chains gave protocols more control over their environments. Bridges expanded interoperability between ecosystems. Shared sequencing attempted to coordinate fragmented execution domains.
Each individual development solved a legitimate problem.
But collectively, these systems reintroduced many of the coordination costs synchronous composability had originally abstracted away.
Instead of one shared execution environment, we now operate across dozens of partially connected state machines. Liquidity is fragmented across domains. Sequencing is localized rather than global. Cross-domain communication introduces latency and settlement uncertainty. Capital must be duplicated and continuously rebalanced between environments because coordination itself has become asynchronous.
As a result, execution becomes probabilistic again.
Participants operating across fragmented systems must continuously account for risks that barely existed inside synchronously composable environments. Will liquidity still exist once a bridge finalizes? Will hedges settle before market conditions move? Will execution be reordered on the destination chain? Will inventory remain balanced across domains?
Every additional execution boundary introduces new coordination overhead.
This matters because markets are fundamentally coordination systems. Financial efficiency emerges not simply from the existence of liquidity, but from the ability to coordinate liquidity efficiently under shared assumptions about state and execution ordering.
Once coordination becomes fragmented, execution quality deteriorates naturally even if the underlying infrastructure becomes technically more scalable.
Settlement vs. Execution
The industry often talks about settlement scalability as though settlement and execution are interchangeable concepts. They are not.
Settlement determines whether transactions finalize.
Execution determines whether markets coordinate efficiently while those transactions occur.
I think this dynamic explains why the rise of intent systems and solvers has become such a dominant trend across modern crypto market structure.
The Rise of Intent Systems
Intent systems are often framed as a fundamentally new interaction paradigm where users express desired outcomes rather than explicit transaction instructions.
But in many ways, intent systems are not introducing a fundamentally new market structure. They are compensating for the loss of an old one.
Users no longer interact with a single coherent execution environment, so someone has to reconstruct coherence externally across fragmented systems.
That is increasingly the role solvers play.
A solver effectively acts as a distributed execution coordinator attempting to recreate the coordination guarantees synchronous composability once provided natively inside shared execution environments. Solvers absorb routing complexity, inventory management, bridge latency, sequencing uncertainty, execution fragmentation, and settlement coordination because fragmented systems externalize these problems onto market participants.
This is also why I think many people misunderstand where execution edge actually exists today.
Most solvers do not lose money because they price assets incorrectly. Pricing itself is increasingly commoditized. Participants broadly observe the same liquidity pools, the same order flow, the same volatility surfaces, and the same public market information.
The harder problem is realizing quoted prices reliably under fragmented and adversarial execution conditions.
Execution quality increasingly depends on operational coordination. Can a solver synchronize inventory efficiently across domains? Can it hedge positions before market conditions change? Can it minimize failed execution paths? Can it coordinate liquidity under asynchronous settlement constraints? Can it compress latency between fragmented execution environments?
Increasingly, the edge comes not from analytical pricing sophistication but from coordination efficiency.
Why Centralized Exchanges Still Dominate
This is also, in my view, the deeper reason centralized exchanges continue to dominate global crypto trading volumes despite the rapid growth of onchain infrastructure.
The debate around centralized versus decentralized systems is often framed primarily around custody, but from a market structure perspective custody is only part of the story.
Centralized exchanges retain a structural advantage because they never abandoned coherent execution internally.
Sequencing, matching, collateral management, inventory coordination, and settlement all exist inside a single coordinated environment. They never lost synchronous composability because their systems never fragmented state in the first place.
As a result, centralized exchanges dramatically reduce coordination overhead. There are no asynchronous bridges, fragmented collateral pools, cross-domain rebalancing requirements, or uncertain settlement windows between execution environments.
Liquidity behaves coherently because execution remains coherent.
DeFi systems, by contrast, increasingly distribute execution responsibility across a fragmented network of bridges, relays, solvers, sequencers, RPC providers, market makers, and routing systems. Every additional coordination layer introduces new opportunities for latency, failure, stale execution, duplicated inventory, and capital inefficiency.
This is why I increasingly think the core infrastructure challenge for Ethereum over the next decade is not simply scaling throughput further, but reconstructing execution coherence across fragmented systems.
The Real Infrastructure Challenge
The dominant infrastructure problem shifts once fragmentation occurs. Settlement itself becomes relatively commoditized while execution coordination becomes the scarce resource.
Wallets begin evolving into execution orchestration systems. Solvers become distributed market infrastructure. Sequencers become coordination engines. Liquidity networks become execution networks. L2s themselves increasingly compete not simply on throughput or fees, but on the quality and coherence of their execution environments.
What matters is not merely whether systems can process transactions cheaply.
What matters is whether fragmented systems can behave like a unified market despite underlying distribution.
This is where I think much of the current infrastructure discourse still underspecifies the real problem. Fragmentation certainly scales throughput, but throughput alone does not create efficient markets. In many cases fragmentation actively destroys coordination efficiency even as it improves scalability metrics.
A market with lower raw throughput but highly coherent execution often produces superior outcomes compared to a fragmented system with theoretically infinite scalability but poor coordination guarantees.
Markets care deeply about coordination efficiency because execution quality compounds. Every incremental source of latency, every fragmented inventory pool, every asynchronous settlement dependency, every stale quote, and every failed bridge transfer accumulates into structurally worse market outcomes.
Over time, capital naturally routes toward environments that minimize coordination overhead.
The Path Forward
I increasingly suspect the next major phase of crypto infrastructure will revolve around reconstructing coherent execution across fragmented systems.
Shared sequencing, solver coordination networks, unified liquidity layers, intent-centric architectures, synchronous proving systems, and cross-domain atomicity are all attempts to recover properties early Ethereum accidentally provided natively.
Not because coherence is philosophically elegant, but because markets structurally reward it.
Ethereum has already demonstrated that decentralized settlement is possible. The harder challenge is determining whether decentralized systems can recreate the coordination efficiency of synchronous composability without collapsing back into centralized intermediaries.
Because ultimately, coherent execution is still the primary thing centralized exchanges monopolize today.
And that may become the defining infrastructure race of the next decade.
Not who can settle transactions most cheaply.
But who can make fragmented liquidity, fragmented state, and fragmented execution behave like a single coordinated market again.