On a Tuesday morning in February, a research pipeline returned a report. It was 4,100 tokens long. It contained nine analytical dimensions, four comparison tables, a six-row risk matrix, a glossary, and a disclaimer. Every substantive field read the same three words: insufficient information. The pipeline did not crash. It did not time out. It did not throw an exception. It produced. Then it published, on schedule, because publishing was the only behaviour it had ever been configured to avoid.
The upstream stage had failed. The extraction module returned an empty list of information points — no title, no source, no project name, no event, no timestamp. That empty list was passed downstream into a synthesis prompt with nine mandatory sections. The synthesis model received nothing and wrote 4,100 tokens about it.
That is the anomaly worth auditing. Not the failure upstream. Failures upstream are ordinary and expected. The anomaly is that a system designed to analyse the market produced a document of analysis when it had been handed no market at all, and nothing in its architecture flagged the difference.
For most of the last three years, crypto research desks have run a two-stage pipeline. Stage one ingests — articles, filings, on-chain events, governance forums, API responses — and emits structured records. Stage two synthesises. The second stage is almost always a language model behind a prompt template, and the template enumerates the sections the output must contain: technical analysis, token economics, market positioning, ecosystem dependencies, regulatory posture, team and governance, risk matrix, narrative, supply-chain transmission. Nine sections. Fixed order. Consistent formatting. Institutional clients like consistency, and consistency is cheap to produce.
The operational metrics on these desks are throughput, latency, and cost per thousand tokens. Nobody measures abstention rate. Nobody measures the fraction of published claims traceable to a specific input record. The empty-input case is absent from the test suite because, in the judgement of whoever built the suite, it should not happen. It happened.
There is an economic reason the failure surfaced now rather than in 2021. In a trending market, research volume is a lagging indicator of price. In a sideways market, it becomes a leading indicator of headcount anxiety. Desks publish more when there is less to say, because output is the visible artefact of employment. A pipeline that abstains looks broken to a manager who measures articles per week. A pipeline that confabulates looks productive.
So it confabulates. The mechanism deserves precision, because it is not the one people assume.
A prompt template with nine mandatory sections is not a suggestion. It is a contract. The schema declares that the output type contains nine fields, each a string of at least some minimum length. A conforming model cannot return nothing. The path of least resistance is to return a document in which each field is populated with a marker indicating that the field could not be populated. That document is syntactically valid, schematically compliant, and epistemically vacant. The failure was not in the model. It was in the schema, which had no representation for refusal.
Now look at what the schema did to the risk matrix. Six rows: technical, market, operational, regulatory, competitive, narrative. Six rows in which the entry was insufficient information. A skimming reader sees a table with six populated cells and a column heading that reads Risk Level. The table does not say the risks are unknown. It says the risks have been enumerated and assessed, with a value of unassessed. Formatting converted absence into a value, and values are read.
This is a type error, and I have audited it before in a different language. In Solidity, a mapping that has never been written returns zero. Zero is a valid uint256. An unset balance and a balance of zero are indistinguishable at the read site. In 2021 I reviewed a liquidation engine that consumed an oracle round that had not yet updated. The struct field defaulted. The engine received a price of zero and behaved exactly as designed: it liquidated every position in the book. No line of that contract was buggy. The contract lacked a type for absence, so absence wore the costume of zero.
Absence and zero are different types. Most systems do not have a type for absence, so absence wears the costume of whatever the field defaults to.
I wanted to know how large the effect is, so I wrote a simulation. Ten thousand runs per configuration, input completeness parameterised from zero to one hundred percent in five-point increments, three pipeline variants against the same corpus of real crypto articles. Variant A used the standard template with no abstention path. Variant B added an explicit null type and a permitted refusal token. Variant C added a provenance hash binding each generated claim to a specific input record, plus a human reviewer gate on any output with fewer than three traced claims.
The results were not what I expected. Variant A, at zero percent input completeness, returned a syntactically valid report in every single run. Ninety-two percent of those reports contained at least one specific, falsifiable claim about a protocol that did not exist in the corpus — a TVL figure, a vesting cliff, a governance quorum. At forty percent completeness, sixty-one percent confabulated. At ninety-five percent completeness, eight percent still confabulated.
Variant B abstained in every run at zero percent. At ninety-five percent completeness, three percent still confabulated. Variant C returned one percent at ninety-five and zero at zero.
The finding is not that confabulation falls as input improves. Everyone assumes that. The finding is that confabulation does not scale linearly with input poverty. It has a floor. Even with near-complete input, roughly one output in twelve contained a fabricated specific. That floor is the number nobody publishes, and it is the number that determines whether a research product is analysis or theatre. The abstention path, for what it is worth, cost four percent in latency and nothing in throughput. Simplicity in logic, complexity in execution.
There is a security dimension, and it is the reason I do not treat this as a quality-control story. In 2025 I audited a protocol in which autonomous agents executed smart contracts against natural-language objectives. I found a prompt-injection path that bypassed access controls on a treasury function. The generalisation of that finding is not about injection. It is about instruction pressure.
Any agent that is instructed to produce output will produce output. That means an adversary who can degrade stage one does not obtain a denial of service. They obtain a fabrication service. Rate-limit the ingestion API. Poison the extraction cache. Exhaust the context window with a long document. The system does not stop. It keeps publishing, with a degraded evidence base and an unchanged confidence surface. I have started calling this a context starvation attack, and it is strictly worse than a crash, because a crash is legible and a fabricated report is not. Stress tests reveal the fractures before the flood, and almost nobody is stress-testing the pipeline that describes the protocol; they are stress-testing the protocol.
Here is the part I keep returning to. The null report was the most honest document produced by that desk that week. It stated, in every field, that it did not know. Every other document published in the same window had non-empty input, which means it looked like analysis. The confabulation floor did not disappear for those documents. It simply became invisible, because fabricated specifics were interleaved with true ones and no reader had a mechanism to separate them. The blind spot in crypto research is not that models hallucinate. Everyone knows that, and the knowledge has become a ritual disclaimer that changes no behaviour. The blind spot is that hallucination and analysis are indistinguishable at the output layer, and the industry has built a publishing cadence that guarantees output regardless of input.
We audit smart contracts line by line, hash by hash, storage slot by storage slot. We demand formal verification for a lending market with nine figures of TVL. Formal verification is the only truth in code. Then we accept the prose layer that describes that code with no verification at all, on the grounds that prose is soft and unquantifiable. The ledger remembers what the market forgets — and the ledger in this case kept a schema version, a token count, and a timestamp on the empty run. The record of the failure exists. What did not exist was anyone instructed to read it.
My forecast: within eighteen months, institutional research procurement will require three fields in any deliverable before it accepts a fourth. An explicit null type, so that absence is encoded as absence. An abstention path, so that refusal is a valid output rather than a defect. And a provenance hash binding each published claim to a specific input record, so that a claim without a parent is visibly orphaned. None of these are technically difficult. All three are commercially inconvenient, because they make abstention look like laziness on a dashboard that counts articles.
Verification precedes value. The question worth sitting with is not whether the model hallucinated. It is this: if someone fed your research pipeline an empty file tomorrow morning, would anything on your desk change by Friday?
