Everyone's building agents and wallets. Almost nobody's asking whether the transactions land.
Agents are already paying for things on Ethereum. Not in a demo. x402 turned HTTP 402 into a live payment flow, and agent wallets now ship with keys and spending limits. Teams are building on the assumption that a machine can settle its own obligations without a person nearby.
The industry moved fast to give agents the means to pay, but what it skipped is the part underneath. A payment rail assumes the payment goes through, and Ethereum was never built on that assumption. Inclusion is best effort: you submit, and you hope it lands in the next block. A human can work around that by watching a transaction stall, bumping the fee, and retrying. You can build an agent to do the same. What you can't build is certainty: a retry is the same gamble placed again, into a market that already moved.
None of this matters much at one transaction. It matters enormously at ten thousand a day, when every action is waiting on the one before it.
Ethereum settles value. It does not yet schedule it.
On Ethereum, blockspace is allocated through a live auction that resolves roughly every twelve seconds. When you submit a transaction, you aren't buying a guaranteed place in the next block. You're entering a competition, and its outcome, both whether you're included at all and what you ultimately pay, stays unknown until it's already over. That design is elegant for a permissionless network. It's also foreign to how institutional finance works.
Institutions are already on Ethereum. What they can't do is run the strategies that need guarantees. When a desk can't know in advance whether a transaction will execute in time or what it will cost to get there, it can't put size behind it, so that activity stays off-chain or moves somewhere that will make the commitment.
For years the answer to Ethereum's limits has been throughput: more transactions per second, more rollups fanning out demand. Throughput is a measure of how much. It says nothing about when. That's a problem of time, not space, and adding more space doesn't solve it.
Closing the gap
Several approaches are now entering implementation, each tackling a different layer of the problem.
Preconfirmations let a proposer commit to including or executing a transaction before the block is finalized. That is the most direct answer to the timing problem: the agent no longer has to submit and hope. But the commitment has to mean something. It needs broad validator participation, credible economic backing, and enforceable consequences when a proposer fails to deliver. Systems that pair preconfirmations with staked collateral and slashing conditions turn a promise into an accountable obligation.
Inclusion lists work at the protocol level, constraining what a builder is allowed to leave out. That makes them a powerful tool against censorship. But they solve a different problem: making a transaction harder to exclude is not the same as committing to when it will execute. An inclusion list sets a floor. It does not set a schedule.
Forward markets extend that schedule further into the future. They let institutions and applications reserve blockspace before they need it, the way energy, bandwidth, and computing capacity are contracted ahead of demand. That turns future capacity into something a buyer can plan around rather than compete for in real time. The design questions here are about market structure: transparent access, validator-accountable delivery and mechanisms that keep capability from being cornered by a small number of large buyers.
Each approach may have constraints that need to be designed around. Together, they form the shape of a market agents and institutions can actually build against: proposer commitments that mean something, protocol-level guarantees against exclusion, and forward capacity that scales to institutional demand. Individual approaches have design questions to solve. The direction is clear.
An agent unwinding a position across two venues has to know the second leg will land before it commits to the first. Without that, it isn't running a strategy. It's placing a bet and waiting to see.
Ethereum has already built credible settlement. The next challenge is making access to that settlement programmable in advance. If agents are going to coordinate capital at machine speed, blockspace cannot remain something they merely bid for and hope to receive. It has to become something they can schedule.