A deep-analysis report landed on my desk last week. Forty-seven fields. Nine sections. Technical, tokenomics, market, ecosystem, regulatory, team, risk, narrative, supply-chain transmission.
Forty-seven nulls.
Not errors. Not exceptions. Not a timeout. Every cell was present, correctly formatted, and marked "insufficient information." The pipeline had not crashed. It had behaved exactly as designed. The upstream extraction stage returned nothing, and the downstream reasoning stage — being a well-behaved piece of software — propagated that nothing through every branch and emitted a perfectly valid document.
I have spent four hundred hours inside a Cairo proof verifier, and I have never seen a failure mode that clean.
Two-stage research pipelines are now standard infrastructure in crypto. Stage one is extraction: pull the project name, the contract addresses, the token supply schedule, the funding rounds, the timestamps, the source quality. Stage two is reasoning: apply a fixed analytical schema, compare against competitors, score risk, produce a verdict.
The design is sound. Splitting retrieval from reasoning keeps a model from inventing facts it never retrieved. It is the same discipline as separating the sequencer from the prover, or the lexer from the optimizer. Each layer does one thing and does it well.
Teams adopt the split because it is auditable. When a claim in the final report turns out to be wrong, you can ask whether retrieval missed it or reasoning mangled it, and the blame lands in exactly one place. That property is worth more than raw accuracy, at least in principle.
The trouble lives in the contract between the two stages. Stage two was instructed to produce a complete report. It received an empty input. It did not refuse. It did not escalate. It filled the frame it was given, because the frame was the only instruction it could satisfy.
Every dimension came back clean. Innovation versus competitors: unresolvable. Security assumptions: unresolvable. Supply structure, team allocation, Howey test elements, contributor counts, DAU/MAU, funding rounds — all unresolvable. The risk matrix had six rows, and every row said "cannot judge." The composite rating was, correctly, "cannot be rated."
Reading it, I felt something I rarely feel looking at crypto research: respect for the machine. It knew what it did not know, and it said so forty-seven times.
Core
Here is the mechanical detail that matters more than the philosophy. The output schema used a single sentinel token, "N/A," to cover at least four distinct states: not applicable, not retrieved, retrieval failed, and retrieval returned a value the validator rejected. Code does not lie, but it rarely speaks plainly, and a schema that collapses four states into one token has discarded the only information an operator actually needs.
This is structural, not accidental. Extraction stages are usually built to fail soft. If a source is down, a scraper returns an empty list rather than an exception, because an exception upstream kills the whole batch. So an empty result and a genuinely empty category arrive at the reasoning stage looking identical. The reasoning stage then has no basis to choose between "this protocol has no token" and "we could not find the token." It picks the neutral phrasing, because neutral phrasing is the only wording defensible under both readings.
Beneath the friction lies the integration protocol. It is not a defect in the language model. It is a contract that was never written down: extraction promises "a list, possibly empty," reasoning hears "a list, possibly empty," and neither party ever agreed on how to distinguish empty-because-nothing from empty-because-broken.
There is a second-order effect, and it is worse. Because the downstream schema is fixed, an empty input still produces a full-length deliverable. Length is preserved. Structure is preserved. Section headers, tables, comparison matrices — all intact. A reviewer skimming for completeness sees a complete document. Nothing in the artifact itself signals that the entire basis of the report is one failed fetch.
I have watched the identical pattern at the protocol level. In the Base interop tests I ran through mid-2024, message passing would occasionally fail to finalize inside the expected fifteen-minute window under congestion. The bridge did not revert. It waited. And waiting looked, from the outside, exactly like working. A finality delay that never resolves is a liveness bug. A finality delay that resolves late is invisible. The failure stayed silent until someone measured the timestamp delta on both sides of the call.
Contrarian
Now the part that should worry you more than the empty report.
An empty report is honest. It wastes a reviewer's time, and it announces, loudly, that the input is missing. It is the safest failure available. It also cannot be monetized, which is precisely why it keeps getting fixed upstream and quietly reintroduced downstream.
The dangerous artifact is the one where extraction half-succeeded. Where the project name came through, the ticker came through, the funding round came through — and the TVL figure came through six months stale, or the supply schedule attached itself to the wrong token, or the comparison table silently reused a competitor's numbers because the schema demanded a number and a number was the only thing on hand.
I have pulled those apart before. During my zkSync Era audit work, three of the four issues I submitted were not exploits. They were gas inefficiencies that mattered only because a downstream integrator would eventually price them into a product. The flaw was never in the contract. It was in the assumption the integrator made about the contract.
A reasoning layer handed partial data and asked for a complete verdict will fill gaps with the most probable value. That is what probability does. And in a bull market, the most probable value for any small-cap metric is the bullish one, because most published metrics for small caps are written by the people selling them.
Takeaway
The fix is not a better prompt. It is a schema with explicit state separation: retrieved, absent, failed, rejected. Four values, never collapsed. Plus a provenance hash on every field, so a reviewer can see at a glance which cells trace to a live source and which trace to nothing.
A null you can audit beats a number you cannot. By the end of 2026 I expect analysis integrity to become a purchasable property — not "how much did the model find," but "how much of what it printed is traceable to a source that existed when it was written."
The open question is whether anyone will pay for that while the numbers are still going up.
