Public order books were built for humans. AI traders need a different market structure.

For about a decade, the question of how on-chain markets should be structured has been answered by humans, for humans. Open order books, public AMMs, transparent mempools, manual cross-chain bridges with retry buttons. Every choice in that stack assumes the trader at the keyboard is a person, working at human speed, with human patience for partial failures.

That assumption is on the way out.

The dominant on-chain trader of the next decade is going to be an autonomous agent — sometimes wrapped in a human-feeling chat UI, increasingly running headless against a strategy. And once you accept that, the architecture we built for humans starts to look like the bottleneck rather than the foundation.

This post is the thought-leadership version of that argument. The companion piece — how to wire an MCP-capable agent into the protocol — went up yesterday. Today's post is about why this matters at all.

The features of public order books are bugs for agents

Three properties of the standard DeFi venue look fine if you assume a human trader. They look terrible if you assume a software one.

Quotes are public. A market maker who posts a tight bid on a public book is announcing intent to every other participant. Faster bots reprice off it. Toxic flow targets it. The MM responds rationally: widen the spread, post less size, and let the trader pay the bid-ask premium. A human trader in this game accepts that as the price of liquidity. An agent running thousands of trades against the same regime is bleeding alpha to a structural feature, not a market move.

Intents leak to the mempool. Every public-book trade goes through a stage where the user's intent is visible to anyone watching pending transactions. MEV searchers compete to extract value from that visibility — sandwiches, frontruns, backruns — and the user pays for the privilege of having broadcasted what they wanted. The MEV tax is small per-trade, large in aggregate, and trivially scaled with trade volume. An agent that's running a strategy with a positive but thin edge will see that edge eroded by the leakage, not by competition.

Settlement is one-leg-at-a-time. Cross-chain swaps that go through bridges, wrappers, or trusted intermediaries are exposed to a class of failures that a human can recover from with a support ticket and a patient afternoon. An agent operating unattended cannot. A half-completed cross-chain swap, with funds locked on one side and the bridge offline on the other, is an unrecoverable loss for software that doesn't have the social graph to escalate it.

A human trader has learned to route around all three. They use private order flow, MEV-protect endpoints, and they pick chains where the bridges have a reputation. None of those workarounds scale to an agent placing hundreds of intents an hour across five chains.

What an agent-native market structure looks like

If you start from "the trader is software" and design forward, you get a different stack. Three primitives matter.

The first is sealed-bid RFQ. The trader declares an intent — what they want to swap, in what size, on what chains — and the network of market makers prices it privately. Each market maker sees the intent but not other market makers' quotes. The trader picks the best one. No public order book, no public visibility window, no mempool exposure. The bid-ask premium that public books charge for adverse selection collapses, because the adversarial selection isn't possible.

The second is HTLC atomic settlement — Hash Time-Locked Contracts. Both sides of a cross-chain trade lock funds against the same hash. The first claim publishes a preimage that the counterparty needs to claim their leg. The settlement guarantee is a property of the math, not of a bridge operator's uptime. Either both legs complete, or both legs refund after the timeout. There is no state where one side has been paid and the other hasn't. For a software trader, this is the difference between a recoverable error and a write-off.

The third is agent-native interface. The protocol exposes itself as an MCP server — Model Context Protocol — so any MCP-capable agent runtime can call it directly. There's no scraping a web UI, no glue code translating REST into intent, no per-runtime SDK to maintain. An agent built on Claude calls the same tools as one built on a custom orchestrator.

Each of those three is a feature on its own. Together they describe a venue that an agent can actually operate without human supervision: private quoting, atomic cross-chain settlement, native agent interface.

The compounding argument

The case isn't "human traders will disappear." Plenty of trading is going to remain human, and the venues that humans love — visible books, social signals, the satisfaction of a manual fill — will keep existing.

The case is that the cost structure of running software against human-designed venues compounds in a way that doesn't matter at one trade per hour but does matter at one trade per second. A 30-basis-point MEV tax on every fill is rounding error for a person making a few decisions a day. It's a death-by-a-thousand-cuts margin compression for an agent running a continuous strategy. A one-leg-failure rate of 0.1% is a story over coffee for a human; it's an unrecoverable expected loss line item for software.

When the marginal trader becomes the agent, the venue that costs them the least linearly wins the volume.

What this changes about how protocols compete

The implication for protocol design is the same as the implication for any infrastructure question: the consumer of the API gets to define what good looks like. For most of DeFi's history that consumer has been a human looking at a chart. The migration toward agent-driven trading flips that. Spread tightness, MEV exposure, atomic-settlement guarantees, and clean machine interfaces — these become the things a venue is benchmarked on, because those are the things the marginal trader cares about.

You can already see the early version of this happening. Protocols that look great in a UI but expose noisy or non-atomic surfaces are losing share to ones that look spartan to humans but feel deterministic to agents. RFQ-based venues are taking volume from public-orderbook DEXs in the size buckets where the trader is sophisticated enough to care. The trajectory of the next several years is more of that, not less.

Where Hashlock Markets fits

Hashlock Markets is built on those three primitives — sealed-bid RFQ, HTLC atomic settlement, and an MCP server interface — for exactly the agent-native trading environment described above. The protocol is live across Ethereum, Bitcoin, and Sui, with Solana and Arbitrum on the roadmap. Authentication is SIWE, so an agent never holds a long-lived secret; it signs with the wallet you delegate, and you revoke access by rotating the key. Tools are stable and well-documented, and the npm package is published as hashlock-tech/mcp (scoped on npmjs).

The protocol home is at hashlock.markets. The canonical repository is github.com/Hashlock-Tech/hashlock-mcp.

The takeaway

Whether you're building a strategy, a market-making operation, or just plugging an agent into a wallet to handle treasury swaps, the venue you pick is going to matter more as the trader on the other end becomes more software-shaped. The properties that matter — privacy of intent, atomicity of settlement, clean machine interfaces — aren't optional features. They're the basic structure of a market that software can actually operate in.

The next decade of on-chain trading is going to be driven by agents. The protocols that win that volume will be the ones that stopped pretending the trader is a human a long time before everyone else figured it out.