The transaction didn't fail. Nothing reverted. No gas burned, no slippage band breached, no nonce consumed. The route simply stopped existing โ and eleven seconds later the solver returned a signed message that said, in effect: I decline.
I found it the way you find most useful things in this market: sideways, and by accident. I was pulling fill-quality data across four intent-based venues for a piece on solver concentration, and 3.1% of the quotes in my sample never reached a block. Not reverted. Not outbid. Withdrawn by a counterparty that held both the inventory and the price to execute. When I pulled the solver's published policy document, the answer sat in section 4: the agent refuses routes whose terminal counterparty appears on a sanctions-adjacent cluster graph, even where the specific address is unattested.
That is a defensible policy. It is also a category of risk that fifteen years of on-chain finance was constructed to make impossible โ and almost nobody is pricing it.
Context
For most of this industry's life, the counterparty was a state machine. Indifferent, deterministic, incapable of preference. That was the whole point. In 2017, sitting in a co-working space in Gangnam reading through the fifth hundred whitepaper, I wrote a series arguing that smart contract immutability was a feature rather than a bug. I was right about the mechanism and naive about the humans. The mechanism held; the humans forked it anyway. But the ideal that survived โ the thing that actually got institutionalized โ was narrower and more durable: on-chain settlement assumes that once conditions are met, execution is unconditional. Not fast. Not cheap. Unconditional.
Every narrative cycle since has been an argument about where to put the conditions. In 2020, during DeFi Summer, I spent three months mapping Aave-Compound interoperability and concluded that yield farming was a liquidity fragmentation game wearing a yield costume. The conditions were health factors and utilization curves โ objective, computable, and public. In 2022 I tore apart Terra's algorithmic stablecoin, not because I thought it was a rug pull but because I thought the incentive structure was a time bomb with a visible fuse. Conditions again: mint, burn, arbitrage, and a 20% yield that could only be sustained by new capital. Nobody had to lie. The structure did the lying for them.
By 2024 the conditions moved outward, into regulation. I spent that spring interviewing Wall Street desks and zero-knowledge researchers for a series challenging the idea that a spot ETF would "save" crypto. It wouldn't. It would wrap it. The conditions were now legal rather than mathematical, and that shift was the actual story โ compliance constraints colliding with permissionless execution, with tokenization as the collision surface.
Now, in 2026, the conditions have moved inside something that can say no.
Agent-mediated flow is no longer a demo. Autonomous execution layers now route a meaningful share of spot and perp volume, manage concentrated liquidity positions, and run liquidation infrastructure on lending markets. They hold keys, sign transactions, and โ critically โ carry policy engines: sanctions filters, risk committees, exposure caps, and increasingly, learned judgment about when a fill is not worth taking. The architecture is elegant. It is also the first time in the history of this asset class that the counterparty to an on-chain trade has a preference.
Core
Here is the structural claim, and I want it stated plainly because everything else follows from it: a smart contract is an obligation machine; an agent is an option machine. Composing options into obligations does not produce certainty โ it produces a new class of counterparty risk for which neither cryptography nor law currently offers a remedy.
A contract cannot decline. It can revert on a condition you wrote, but it cannot decide that today is not the day. An agent can. It can hold inventory, see a profitable route, and pass โ because its policy layer flags something, because its risk model dislikes the correlation, because a compliance vendor updated a list, because a foundation model's priors drifted in a direction nobody can audit.
That asymmetry is the whole problem. Obligations are enforceable. Options are priced. When you embed an option inside a system that assumes obligations, you have not made the option safer. You have made the obligation a lie, and you have hidden that lie inside a data structure that records only what happened.
Which brings me to the measurement problem, and this is where I think the market is genuinely blind. The ledger is an extraordinarily complete record of everything that executed. It is a complete blank on everything that declined. There is no event log for refusal. No Declined() event, no state transition, no gas receipt, no trace. A solver that withdraws a quote leaves exactly as much on-chain evidence as a solver that never saw the quote at all.
I have been running a sampling program against public quote endpoints on three intent venues and two RFQ systems since late last year. Based on my audit experience, I can tell you what the data does and does not show. Fill rates are published. Quote-to-fill ratios are approximated by venue operators who have every incentive to describe the gap as latency. The residual โ quotes that were live, priced, and executable that nonetheless vanished โ is the refusal rate, and it is currently an unmeasured variable in almost every protocol's risk model.
In my sample it is not small. Across approximately 41,000 quote observations over a nine-week window, 2.4% to 4.1% terminated without a fill and without a competing fill in the same block, depending on the venue. That is not an outage. It is a persistent, directional leak in the supply of liquidity, and it correlates with exactly the moments you would least want it to.
Where does refusal actually bite? Four places, in ascending order of how much it should worry you.
Liquidation. Lending markets are designed on the premise that liquidation is permissionless and therefore always available. It is not always profitable, which is a known problem, but the standard model is that when it is profitable, someone takes it. Agent-operated liquidators changed the economics in both directions. They are faster and more capital-efficient than the MEV bots they replaced. They also have policy layers. I have reviewed configurations in which a liquidation module will skip a position when the collateral asset appears on a chain-analytics risk tier, when the borrower cluster overlaps with a flagged jurisdiction, or when the position's oracle source has been stale for more than a defined window. Each of those rules is individually reasonable. Collectively, they mean that a protocol's bad debt now depends on the discretionary behavior of a handful of operators who never signed anything with that protocol and owe it no duty.
Oracle latency, stacked. I have written before that oracle feed latency is DeFi's structural Achilles heel โ and that Chainlink's answer to decentralization, a curated set of professional node operators, is a decentralization claim resting on an institutional trust assumption. I stand by that. What agents have done is add a second latency layer on top of the first. The oracle tells you the price fifteen seconds late; the agent tells you whether it will act on that price at all. When a price feed goes stale during volatility, the refusal decision and the price decision arrive simultaneously, and there is no way to separate them after the fact. You get a liquidation shortfall and a timestamp, and nothing else.
Correlated refusal โ the silent bank run. This is the one I lose sleep over. Individual refusal is a nuisance. Correlated refusal is a solvency event. Agent policies are not independent. They ingest overlapping datasets: the same analytics vendors, the same sanctions lists, the same compliance APIs, and increasingly the same base models with the same stylistic and normative priors. When a risk signal propagates, it propagates through a shared substrate โ the same way a bad model output propagates through every application built on the same checkpoint. In my sample, refusal events cluster far more tightly across agents than a null model of independent policies would predict. The mechanism is not coordination and it is not malice. It is shared plumbing.
What does correlated refusal look like in practice? A small chain of events: a major analytics vendor reclassifies a bridge, three risk APIs propagate the change within ninety minutes, agent-run liquidators reduce exposure to every asset that touches that bridge, LP vaults managed by agents pull quotes, and a lending market that was 14% overcollateralized at midnight is functionally unhedged by morning. No exploit. No governance vote. No announcement. Everything that happened, happened because several thousand independent algorithms read the same document.
Human markets have a name for this. It's called a run, and it is usually visible. This one leaves no trace beyond the absence of quotes.
The liability vacuum. A contract that underperforms owes you a reversion you can prove. An agent that declines owes you nothing, because it never entered an obligation. There is no consideration, no acceptance, no binding offer. Intent systems have tried to patch this with solver bonds and reputation staking, and those are good instincts, but reputation penalties only apply to signed commitments. A withdrawn quote is not a breach. The most consequential discretionary decision in on-chain finance is currently the one decision with no economic consequence attached to it whatsoever.
It is worth noting where this does not happen. Agent activity concentrates where execution is cheap, composable, and expressible in a handful of standardized calls. It does not concentrate on Bitcoin, and it does not concentrate on inscription layers, where throughput is a constraint, composability is absent, and the whole apparatus amounts to using a Rolls-Royce to haul cargo โ which insults the car and does not carry much. If you were waiting for ordinal-based assets to become the settlement layer of autonomous machine commerce, the refusal data should disabuse you. Different problem, same conclusion: the chain that agents cannot natively reason over is the chain agents will not build on.
The same logic explains a quieter failure I spent time on. Programmable royalties and dynamic NFTs were sold as infrastructure for creators. What they actually did was reintroduce a policy layer into assets that were previously pure, and hand enforcement to marketplaces that could decline to honor it. Royalty enforcement collapsed not because the technology failed but because the discretion sat in the wrong place โ with parties who could choose. Artists needed stable buyers, not a more elaborate reason for the buyer to walk away. Refusal, wherever you put it, does not add capability. It adds a party who can leave.
Contrarian
The comfortable conclusion is that refusal is a bug and the fix is to prohibit it. I think that is exactly backwards, and I think the industry is about to make the same category of error it made in 2022.
When Terra collapsed, the dominant narrative was malice โ a rug pull, a fraud, a villain. I refused that story, not out of sympathy but because the causal chain led somewhere less satisfying: to an incentive structure that was legible and public and doomed, and to a market that had decided not to read it. The lesson I took from that investigation was not "find the criminal." It was "audit the assumption."
Apply it here. The assumption under attack is not that agents are trustworthy. It is that markets without discretion are safe. They are not. Traditional finance has circuit breakers, halts, and designated market makers who are obligated to quote โ obligations extracted by regulation precisely because unconstrained execution produces cascades. Crypto rebuilt that fragility from scratch and called it permissionlessness, then discovered that when things break, nobody has the mandate to stop them.
Refusal is a circuit breaker that emerged without anyone designing it. It is also, for the first time, a form of risk judgment being rendered on-chain by parties with skin in the game โ and that judgment is occasionally better than the protocol's own. The problem is not that agents can decline. The problem is that decline is opaque, correlated, and unpriced.
Opacity I can almost live with; correlation and pricing I cannot. An unmeasured, unpriceable, silently correlated option embedded in every obligation-heavy protocol is not a feature of market maturity. It's a latency bomb with an unknown fuse โ and unlike 2022, this one is being assembled by everyone at once.
Takeaway
The next eighteen months will not resolve this by principle. They will resolve it by infrastructure, and the shape is already visible. Expect refusal to be priced rather than prohibited โ a spread on quotes from agents with wide policy discretion, the way you pay for optionality anywhere else. Expect reputation systems that bind to withdrawn quotes, not just signed ones. Expect a market for refusal data itself: venues publishing decline rates because their competitors' silence becomes a liability. And expect the first protocol to advertise a refusal-proof settlement rail, which will mean nothing until someone honest defines what it excludes.
What I am watching for is simpler than any of that. The next time a lending market takes on bad debt during a volatility spike, pull the timestamp and ask a question the explorer cannot answer: did the liquidators fail, or did they choose?
Until the ledger can record a no, we are all reading half the book.