Nine dimensions. Zero data points. Full format compliance.
That was the output I pulled last week from a crypto research pipeline running the standard two-stage architecture โ deconstruct, then analyze. Stage one returned an empty object. Stage two, handed nothing, produced a document with nine analytical sections, six risk-category rows, four supply-distribution bands, a Howey test matrix, and a regulatory disclaimer. Every substantive field read N/A. Not "unavailable pending review." Literally N/A, in every cell, across every dimension, from technical architecture to governance concentration.
I found it in a routine spot-check, not an incident review. Nobody flagged it. There was no incident.
Nothing errored. Nothing timed out. The schema validated. The formatting was clean. The document was, by every automated quality gate the operator had installed, a success.
I've been stress-testing agent pipelines since early 2026, when I put a small position of real capital into an AI-driven oracle network to measure attestation latency and verification failure. Same signature. Null propagation. Silent, type-valid, and at the file level completely indistinguishable from work.
Null propagation detected. Run.
Crypto research infrastructure went agent-first faster than any other vertical in this industry.
2023 was LLM-assisted summarization โ models reading governance forums and turning them into prose. 2024 was retrieval pipelines bolted on top of on-chain data, with vector stores indexing everything from GitHub commits to Dune dashboards. 2025 was multi-stage decomposition: one model extracts structured facts, a second model reasons over the structured output, a third writes. By 2026 most desks I talk to run some version of that stack, and the ones that don't are running it by Q3.
The pitch is unit economics. One analyst supervising twenty pipelines beats twenty analysts, at a tenth of the cost, with no vacation days and no equity cliff.
I run a newsroom. I've made the same trade. So nothing below is written from the outside.
Here's the architectural detail that matters. When you separate extraction from analysis, you create a formal contract between the two stages. Stage one promises a typed object: title, source, information points, core thesis, domain tags, involved protocols, time sensitivity, source quality. Stage two trusts the shape of that object. It does not verify the contents.
Trust the shape and you build a system that cannot distinguish "we retrieved nothing" from "there is nothing to retrieve."
That distinction is the entire product. Everything a research desk sells is the difference between an absence of evidence and evidence of absence. Collapse it and you aren't selling analysis. You're selling output.
Concretely: a validator checks that source is a string. An empty string is a string. It checks that information_points is an array. [] is an array of length zero, and length >= 0 is a tautology. Every gate passes. The pipeline reports green, the queue advances, and a document enters the publishing stack carrying the full authority of a system that has never once been wrong about its own formatting.
A bear market makes this worse, and not in the way people assume. Research budgets compress before trading budgets. Headcount goes before infrastructure, because infrastructure bills are small and monthly, and layoffs are expensive and immediate. So the pipelines keep running with fewer humans watching the boundary between stages โ exactly the boundary where a null needs a human to notice it.
Gas spike detected. Run. That's the on-chain instinct โ we've all internalized it. Nobody applies the same instinct to a JSON payload.
Let me lay out the forensics properly.
Failure signature one: the placeholder cascade. A pipeline engineered for honesty handles empty input by refusing. A pipeline engineered for schema compliance handles empty input by filling. Null coerces to a string. An empty array satisfies every length check. A missing source field becomes "unverified." A missing timestamp becomes null, which serializes cleanly, which passes validation.
The system never lies about a fact. It fabricates the container the facts were supposed to sit in โ and the container is what the reader actually sees.
I instrumented this at the stage boundary across eleven research pipelines over four months. Seven of eleven emitted a fully-formed downstream document when stage one returned an empty object. Two raised exceptions. Two halted and paged a human.
For context on the sample: three were in-house builds at trading desks, four were commercial research vendors, four were open-source frameworks anyone can fork. The commercial vendors were the worst offenders โ three of the four filled. They have customers, contracts, and uptime guarantees. A null exit is hard to sell in a renewal meeting. A formatted document that reads like it worked is not.
The seven had something else in common: the most polished output formatting in the sample. That's not a coincidence. Formatting is what gets optimized when formatting is what gets measured, and dashboards measure formatting because formatting is measurable.
Failure signature two: the confidence ritual. The placeholder documents carried confidence labels. Low confidence, appended to every inferred claim, in every section. That reads like epistemic humility.
It isn't.
If every claim in a document is tagged low-confidence, the tag carries zero bits of information. It's a uniform distribution wearing a lab coat. Real calibration requires variance โ a high-confidence claim that occasionally turns out wrong, a low-confidence claim that occasionally turns out right. Variance is what a signal looks like. A constant is not a signal, it's a font.
And the uniformity here is diagnostic. It means the confidence score is derived from the absence of retrieved evidence, not the quality of the retrieved evidence. Those are different functions with different inputs. One measures the world. The other measures the pipeline's own emptiness and files a report about it. You cannot calibrate the second one, because the second one isn't about anything.
Failure signature three: the integrity theater. The document I pulled announced, in its own closing section, that it refused to speculate, declined to fabricate, and was maintaining analytical honesty at the cost of completeness. Every word of that was true.
It also consumed a request, produced a complete nine-dimension framework, and delivered zero verifiable claims. That isn't integrity. That's unfalsifiability. The output is immune to correction because it asserts nothing โ and an assertion that cannot be wrong cannot be right either.
It's the research equivalent of a bridge that has never been load-tested because it was never built. Nobody can prove it fails. Nobody can use it either. But it photographs well.
Now the on-chain contrast, because this is where my bias sits and I'd rather name it than let you infer it.
When a Solidity call fails, it reverts. State rolls back. You get a receipt with a status of zero, and you burn the gas anyway. That's deliberate. Atomicity is a safety property. Ethereum's entire security model leans on the proposition that a half-executed contract is worse than no execution at all โ because a half-executed contract produces state that looks valid.
Research pipelines have no revert. There is no state rollback when stage one returns nothing. The document posts. The reader cannot tell. Nobody burned gas.
The absence of an error is not evidence of correctness. In a typed pipeline, it's evidence of nothing at all. And the crypto stack is now densely packed with typed pipelines.
Numbers, because this is the part people skip.
In my 2026 oracle test, I deployed a small position into a network where autonomous agents posted price and event attestations, and I logged source block height alongside every value. Median attestation latency was fine โ 340 milliseconds at the 50th percentile. The tail was not fine: the 99th percentile blew past 11 seconds, which for a feed that triggers liquidations is the difference between a signaling layer and a liability.
But latency wasn't the real finding. The real finding was abstention behavior. When agents had no fresh data, they did not abstain. They reposted the last known value with a fresh timestamp.
Twelve percent of attestations in my sample were stale-value reposts wearing current timestamps.
I caught it because I was logging the second field. Any consumer reading the feed without source block height would have seen a clean, continuous, plausible price series. Perfect shape. Empty content. And the feed's own documentation advertised "continuous coverage" as a feature.
Same bug, different costume. Downstream trust in upstream shape. No revert.
The fix is structural, not prompt-level. Nothing you write into a system prompt survives contact with a stage boundary, because the stage boundary doesn't read prompts โ it reads schemas. Prompts are persuasion. Schemas are enforcement.
Any pipeline whose output can influence a capital decision needs a witness requirement. No claim ships without a resolvable anchor: a transaction hash, a block height, an event log, a source URL that returns 200. Something the reader can independently dereference without asking the author, on infrastructure the author doesn't control.
No witness, no publish. Not "low confidence." Not "N/A." Refuse the document and return a null exit code.
The two pipelines in my sample that halted and paged a human got this right, and they were structurally identical: stage two was not permitted to run unless stage one returned a non-null witness count above zero. Not a heuristic. A hard gate. Both were in production. Neither had a formatting layer worth screenshotting.
I've run that rule on my own desk since March. Publication volume dropped 31% in the first month. Correction rate dropped 84%.
The 31% was never output. It was null propagation with good typography.
The entire discourse on AI in crypto research targets hallucination. Wrong target.
Hallucination is loud. It manufactures confident specifics โ a fake TVL number, an invented audit date, a wallet address that doesn't resolve. Confident specifics are cheap to falsify. One block explorer lookup and they're dead. Hallucination gets caught in production precisely because it produces claims, and claims are auditable.
Null propagation produces no claims. It produces structure. Structure is what reviewers skim. A document with nine headers and a risk matrix reads like diligence the way a filled spreadsheet reads like accounting โ right up until somebody asks which cell contains a number.
And here's the half nobody wants to say out loud. "I refuse to fabricate" has become a marketable posture. Vendors sell it. Frameworks advertise it. It ships in changelogs as a compliance feature and gets cited in procurement decks.
But a pipeline that consumes a request, emits fully-formed empty scaffolding, and grades its own output as format-complete has fabricated something. It fabricated the impression that an analysis occurred. It billed for attention and returned a filing cabinet with the drawers pulled out.
ERC-20 rush vibes. Proceed with caution.
The honest failure is a null exit code. Everything else is expense.
Watch for the first crypto data vendor to ship revert semantics โ a hard null exit when upstream extraction returns empty, priced, logged, and visible to the consumer rather than hidden in an operator dashboard.
Whoever ships it first will look slower than the competition for about two quarters. Their dashboards will show gaps. Their competitors' dashboards won't.
Then the market will figure out which of the two was quietly passing nulls the whole time.
The question isn't whether your agent hallucinates. It's whether your agent can tell you it has nothing.