Over a 72-hour window last quarter, an AI risk agent wired into a $5M book I was responsible for reported the same thing every four hours: no anomalies detected.
It was right about the arithmetic. It was wrong about the world.
The upstream indexer had stopped returning pool-depth data. Not degraded โ stopped. Every field came back as null. The model, sitting on a pipeline where missing values had been coerced to zero for two years by an engineer who had since left the team, scored zero-depth as zero-risk. Zero-risk as no-action. No-action as a clean report.
Meanwhile, three of the pools in that book had lost roughly 40% of their LP depth. Two were already past the point where a $250k exit would move price more than three percent.
We traded sleep for alpha, and alpha for scars. That part is normal. But this wasn't a market loss. It was a plumbing loss โ the only category of loss that is entirely preventable, which is precisely why it keeps happening.
The bottom of the stack is where the trust actually lives
The 2025-2026 narrative sold you a reasoning engine. What you actually bought was a data acquisition problem with a language model bolted on top.
Here is the architecture nobody puts in the pitch deck. At the top sits the agent โ portfolio rebalancer, risk scorer, execution router. Below it, a thin glue layer. Below that, the model endpoint. Below that, the feature store. And at the bottom, holding up the entire thing: RPC nodes, indexers, subgraph queries, oracle feeds, websocket streams, and whatever CDC pipeline someone stood up in a sprint eighteen months ago and stopped looking at.
In my audit work across roughly two dozen agentic risk and execution frameworks over the past year and a half, I have never โ not once โ traced an incident back to the model's math. Every single failure originated in the data layer or in the glue between it and the model.
And here's the part that should unsettle you: trust is distributed inversely to where failure probability actually sits. We audit the model. We benchmark the model. We red-team the model. Then we point it at a feed that has been silently returning nulls since a JSON Schema change on a Tuesday and call the output a signal.
Traditional trading desks solved a version of this in the 1980s. Risk systems fail closed. If the price feed dies, positions don't grow โ they flatten or shrink. There are circuit breakers, limit-up/limit-down bands, pre-trade risk gates that don't consult the fancy model at all. The yield was real; the trust was phantom. Nobody in DeFi ever built those walls for the analytics layer, because the analytics layer doesn't lose money on a screen. It loses money three days later, somewhere else, and gets attributed to "market conditions."
A taxonomy of silence
Chaos is just a pattern waiting for a label. So let's label the pattern.
Null-as-zero coercion. The single most expensive three characters in crypto analytics are or 0. In any dynamically typed pipeline, payload.get("depth") or 0 collapses null, 0, empty string, and empty list into the same integer. Which means a genuinely drained pool โ depth of exactly zero, a real market event โ is byte-identical to "we couldn't reach the node." One of those is a liquidation cascade. The other is a Tuesday. Your risk engine cannot tell them apart, so it assumes the boring one.
Stale-as-fresh. Websockets disconnect quietly. The reconnect logic replays the last known value so the dashboard doesn't flicker. The number looks alive. The timestamp is forty seconds old. In 2020, during DeFi Summer, I ran an arbitrage across three DEXs involving unstable LP tokens โ 400% in six weeks โ and twice came within a hair of a margin call because a price feed was stale and my model read it as current. That was the lesson that rewired me: the timestamp is the only field in the payload that matters, and it's the one nobody charts.
Schema drift. Upstream renames reserveUSD to reserve_usd. Pipeline doesn't throw. It returns None. And None, per the first item, becomes zero. Your monitoring is green because monitoring checks whether the job ran, not whether the values were real.
Reorg-orphaned state. The chain reorganizes. Your indexer has already written state derived from a block that no longer exists on the canonical chain. A nightly reconciliation job catches it twelve hours later. For those twelve hours, your risk engine is pricing a version of reality that was retracted. This isn't exotic. On some chains it's weekly.
Decimal and unit collapse. Six-decimal USDC, eighteen-decimal WETH, eight-decimal WBTC. One missing normalization step is a 10^12 error. In a raw P&L it would be obvious. In a 0-100 risk score, it surfaces as a number that looks plausible enough not to alarm anybody โ which is the worst possible outcome. An obviously wrong number gets fixed. A plausibly wrong number gets traded.
Circular data. This is the one that matters most, and it has a name and a date. Terra. The dashboard showed UST at $1.00 for months, because the price source was UST's own Curve pool, and the pool was being defended by the same entity reporting the price. A risk model whose data source is the system it is measuring is not a risk model. It is a mirror. Ninety-nine days of green followed by eleven hours of nothing, and the feeds never went red because the feeds could not go red. I had flagged similar peg architectures as structurally unfalsifiable โ meaning the mechanism contained no state in which its own failure was observable from inside. Institutional walls don't fall from a single well-argued memo. They fall when someone is right twice in a row, with data, in front of witnesses.
LLM summarization of empty result sets. This is the new failure, and it is the most dangerous because it produces fluent garbage. A traditional pipeline returns null and something breaks loudly. A 2026-era agent handed an empty result set writes you a paragraph. "Liquidity conditions appear stable with no significant withdrawals detected during the review period." Every word of that is true. There were no withdrawals detected. There was also no detection.
An empty result set and a clean result set are not the same object โ but they are identical to every language model ever trained on prose that describes clean results.
That sentence is why the AI-plus-crypto narrative is quietly destroying alpha right now. We shipped reasoning engines before we shipped epistemics. The models can synthesize anything. They cannot tell you they have nothing to synthesize.
What fail-closed actually looks like
The primitives exist. They're just unglamorous, which is why almost nobody implements them.
A freshness gate: if now - timestamp > threshold, the value does not exist. Not imputed. Not carried forward. It ceases to be a number. In my own book, the threshold was tighter than most people find comfortable โ eight seconds on primary feeds, sixty on secondary โ and when the gate tripped, position sizing halved automatically without asking the model.
An empty-set halt: empty must be a distinct type from clean, enforced at the schema level, not documented in a README. If the query returns zero rows, the pipeline should refuse to emit a score rather than emit a favorable one.
A schema contract: a renamed or removed field is a build failure, not a null. Contracts get versioned. Nulls get ignored.
Two-source reconciliation: no single feed, no matter how trusted, can move a risk limit on its own. This is the cheapest insurance in the entire stack and the least deployed.
And the hardest one, which is cultural rather than technical: an explicit "insufficient data" state that the system is permitted to output, and that humans are trained not to punish.
Everyone builds the abstain state. Nobody lets it fire, because a report that says "I don't know" gets escalated in a Monday review, and a report that says "conditions stable" does not. We have engineered an entire organizational incentive structure that rewards confident fabrication over honest silence. The models are just downstream of that.
It's worth naming a live example. Intent-based architectures have moved MEV extraction off-chain into solver networks โ and solver fill data is largely self-reported through APIs that no third party validates. When a solver dashboard shows zero volume for an hour, is that genuinely no flow, or a broken endpoint? It's the same null-as-zero bug wearing a new coat, and it now sits underneath a growing share of routing volume. Nobody is going to tokenize the fix. There is no airdrop for null-handling.
The report I've been circling โ a two-stage analysis pipeline that received empty input โ did the rarest thing in this industry. It refused. Forty-one fields marked N/A. A written request for the missing inputs: title, information points, protocols involved, time sensitivity. An explicit statement that any plausible-looking analysis produced under those conditions would be more misleading than no analysis at all.
That is a risk officer's document, not an analyst's document. It is also the correct shape of output for a bear market, where the reader's real question is not "what's the upside" but "is my capital still there."
The contrarian read: stop blaming the model
The consensus explanation for AI-driven trading losses is that the models are wrong. That's lazy, and it's dangerous, because it points the fix at the wrong layer.
The model is a function. You fed it zero. It returned a confident zero. It performed exactly as specified. The bug is that nobody owns the layer between the source and the model โ because that layer has no narrative, no token, and no conference keynote. Data engineering is unglamorous, so it is underfunded. Agents are glamorous, so they are overfunded. The spending ratio across the industry runs roughly a hundred to one in the wrong direction, and every dollar of that gap is a null waiting to be coerced.
The second contrarian point cuts against the obvious remedy. More data is not the answer. More data multiplies the number of feeds that can fail silently while adding near-zero explanatory power. The fix is not ingestion volume. The fix is refusal frequency. A system's quality should be measured by how often it declines to answer โ and in a bear market, it should decline constantly.
Which brings us to the third thing, and the one I'd tattoo on the inside of a new junior's monitor. An honest N/A is a position. It's flat. And flat, held deliberately through a drawdown, outperforms long-and-wrong by a wide margin over any horizon that matters. Hope is a terrible hedge against a black swan. So is a dashboard.
Three checks you can run this week
If you are running any agentic risk or execution stack right now, do three things before you allocate another dollar to it.
First, plot a histogram of your feed timestamps, not your feed values. If the distribution is a spike rather than a spread, you are dead and don't know it. Every field in your pipeline should have a timestamp you can chart. Fields without timestamps are not data. They're rumors.
Second, instrument null counts as a first-class metric. Not error rates โ null rates, per field, per source, per hour. Null rate is the leading indicator of every plumbing incident I have ever investigated, and it is almost universally unmonitored, because a null doesn't throw an exception and doesn't page anyone.
Third โ and this is the one that will tell you the truth about your architecture โ deliberately return an empty result set to your agent and read what it prints. If it prints a paragraph of prose, you have your answer. If it prints an abstention, you have something rare.
The bear market will not be won by the desk with the largest model. It will be won by the desk that knows, at all times and with precision, which of its numbers still exist. Everything else is a story we tell ourselves while the LP depth quietly bleeds to zero โ and the report keeps coming back clean, every four hours, on the dot.