A research pipeline produced a document this week. Nine analytical dimensions. A six-row risk matrix. A Howey test table. A token supply breakdown. Confidence annotations attached to every inference. Several thousand words of structured output, formatted to institutional specification.
The underlying fact base was an empty array. [].
The stage-one extractor had failed โ paywall, image-only body, parse timeout, the specific cause is irrelevant. It returned zero information points. Stage two received that array, did not halt, and emitted a report. The report names no project. It invents no TVL figure, no vesting cliff, no auditor, no team member. At the level of every individual cell it is scrupulously honest: each dimension reads N/A, each inferred signal carries [confidence: none], and the document states in its own prose that zero information and low-quality information demand opposite responses and that it cannot continue.
Then it continues. That contradiction is the artifact.
Every serious crypto research stack in 2026 runs the same two-stage topology. Stage one is extraction: fetch, parse, normalize into a claim list where each entry carries an identifier and a source pointer. Stage two is reasoning: take that claim list, walk it through a fixed analytical grid, produce a verdict. The contract between the stages is a JSON object with a field called information_points. Stage two's prompt assumes that field is populated. Nothing in the control flow enforces the assumption. A language model handed an empty array and a nine-section template will do the only thing it was trained to do โ complete the template.
What emerges is not a hallucination in the ordinary sense. It is a structurally valid document whose information content is zero, and the two properties are independent. Schema conformance is not semantic validity, and every downstream consumer that measures the first will mistake it for the second.
The closest analogue in my own discipline is the hollow ERC-20 return. A token contract implements transfer and returns true. No state changes. No balances move. The calling contract checks the boolean, sees success, and proceeds to credit a deposit that never arrived. The bug is not in the transfer logic โ it is in the interface, which promises a payload and delivers a flag. The failure here is identical in shape. The pipeline's interface promised a report. It delivered a schema-conformant token stream. To any consumer parsing headers and table counts, the two are indistinguishable.
Now consider what a human reader does with it. Nobody reads a risk matrix cell by cell. They scan the shape: six risk categories enumerated, each with a level, a probability, an impact, a mitigation column. Six rows of N/A register, to a reader in a hurry โ which is to say, to every reader โ as risk assessed, none identified. The document even ships a five-star rating block, with โโโโโ in all four rows for technical value, investment value, timeliness, and reference value. That is a rating of nothing, rendered in the native format of a rating. A reader who anchors on the heading Comprehensive Assessment has already absorbed a conclusion before reaching the disclaimer.
This is the mirror image of the whitepaper that claims 10,000 TPS with no benchmark attached. Both abuse the same cognitive shortcut. The most dangerous output is not the false claim; it is the true non-claim wearing the uniform of a claim.
The document is aware of the distinction it then violates. It correctly separates zero information from low-quality information: the first requires a halt, the second permits a conclusion with downgraded confidence. It applies that distinction to argue for its own termination. It then produces the conclusion anyway, because the template has a slot for one. Awareness of a failure mode is not a mitigation for it. I have watched audited protocols ship with a comment block above the vulnerable function describing the exact attack that later drained them.
Where the fix belongs matters more than what the fix is. The document's own recommendation โ insert a pre-flight gate that halts when the claim list length equals zero โ is correct and insufficient. Gates live in code the pipeline author controls. In an agentic stack assembled from third-party retrieval tools, a hosted model, and a prompt template versioned by whoever holds write access to the system message, the author controls none of those things reliably. The gate holds until someone adds a fallback path that "keeps the pipeline resilient."
The durable fix is on the consumption side. No claim renders without provenance. Every assertion must carry a pointer to a claim identifier and a source, and a null pointer must produce nothing โ not an N/A, not a placeholder, not an empty row. This is the discipline of requiring a Merkle proof instead of trusting the RPC's eth_getProof response. The RPC can lie. The proof cannot.
I learned this the expensive way. During the MEV-Boost audit cycle I found an integer overflow in a royalty splitter that let a caller drain accumulated fees; the team wanted a quiet patch. The page that mattered was not the one describing the overflow. It was the appendix stating that the fee recipient logic could not be verified because the deployment script was never provided. Institutions read appendices first. In the bank tokenization work I did in 2025, the compliance team's opening question was never is it secure. It was what did you fail to check, and why. A report with no declared gaps gets rejected on sight, because a clean audit is a claim about the auditor, not the code.
And note who governs the template. The nine-dimension grid is a prompt. Someone holds the write key to it. That someone is, functionally, a two-of-three multisig over what counts as analysis inside that shop. Upgrade rights decide what truth looks like. Code is law until the system message changes.
The prevailing anxiety about language models in research is fabrication โ invented TVL, invented audits, invented founders. That fear is overpriced. A fabricated number is falsifiable in ninety seconds against a block explorer. This failure is cheaper and it survives verification, because the model fabricated nothing. It refused, annotated its refusal, and the pipeline shipped the refusal as a deliverable. You cannot prove a null wrong. And the market does not pay for correct nulls. The document's closing request for more input is the right answer and the commercially worst one. Code does not lie, but it does hide โ and here it hid in the formatting. The best audit is the one you never see, which is precisely why nobody buys it.
Watch for provenance-gated rendering to become a procurement requirement in institutional crypto research before the end of 2026. Not better prompts โ better consumers, ones whose output is physically unrenderable when the evidence array is empty. The question every desk should answer this quarter is narrow and uncomfortable: if your model returned [] tomorrow morning, would a single person in the building notice?