Last month a research pipeline handed me a nine-dimension due-diligence report. Every field was populated. Technical assessment, token economics, competitive positioning, regulatory exposure, team background — nine sections, formatted, confident, footnoted. Then I checked the input manifest. The title field was empty. The source field was empty. The information-point list — the only field the analysis actually reads from — was empty.
Nine dimensions of output. Zero bytes of input.
The document had a second page, and the second page is why I am writing this. The system had detected the null input, declined to analyze, and printed a defect table listing which fields were missing and what each missing field would have permitted. It named the tempting alternative explicitly: infer a hot sector from an unclassified tag, then generate a plausible narrative around it. It called that what it is — hallucination with a template.
I have spent nine years reading code that people trusted with their money. I have never seen a more useful artifact than a machine that says "I have nothing."
The crypto research layer is now machine-mediated. Screening tools, agentic due-diligence pipelines, LLM summarizers bolted onto on-chain indexers. The economics are obvious: a human analyst produces perhaps three deep reports a month; a pipeline produces three thousand. Coverage became cheap, and coverage is what funds, desks, and newsletters actually purchase.
Cheap coverage created a structural problem that has nothing to do with model quality. An analysis agent is an oracle. It answers a question about state it cannot directly observe, and downstream systems consume the answer as fact. That framing matters because oracles already have a mature failure taxonomy, and every entry in it applies here: staleness, manipulation, liveness, data availability, and the one that kills — validity confusion, where a consumer treats "the feed responded" as "the feed is correct."
In 2022 I performed a forensic review of twelve failed DeFi protocols, focused on oracle integration. I catalogued fifteen distinct misconfigurations. The finding that reorganised how I think about data pipelines was this: only six of the fifteen were price-feed bugs in the conventional sense. The rest were consumers that had no way to distinguish a live feed from a plausible one. They had a liveness check and believed they had a validity check. The distinction cost them everything, because a stale-but-well-formed number is indistinguishable from a fresh one at the integration layer, and a liquidator bot does not read footnotes.
A null input is a liveness event. The oracle is being asked a question and given nothing. What it does next determines whether the entire downstream stack is sound.
There are exactly three responses to an empty input, and they are not equivalent.
The first is template-fill: emit the nine dimensions with "N/A" or "insufficient data" in each cell. The output is technically honest and practically dangerous, because a formatted report with every cell populated passes human review. Reviewers audit shape first. A nine-section document with headers, tables, and confidence markers reads as work performed. Nobody opens a PDF expecting to discover that the footer is the only true statement in it.
The second is fabrication: infer from priors. The project has no disclosed token model, so assume a standard ve-model. The team is anonymous, so assume a tier-two jurisdiction. Each individual inference is defensible; the composition is fiction. This is the response that gets shipped, because it produces the artifact the buyer asked for.
The third is refusal with a defect report: decline, enumerate what is missing, state what each missing field would have permitted. This is the only response that costs the system anything, which is precisely why it is the only one worth trusting.
I want to be precise about why the third is correct and not merely conservative. Model the pipeline as a function f that maps an input set I to a report R together with a confidence vector c. The claim embedded in every published report is that c reflects the evidential support contained in I. When I is empty, there is no evidential support, so the only confidence vector consistent with the claim is the zero vector — which is not a report at all. It is a bottom value. A system that maps the empty set to a non-bottom report has a type error, and the type error is the vulnerability. It is not that the report is wrong. It is that the report's form asserts a provenance it does not have.
Cryptographers have a name for the missing property. A proof system has completeness if every true statement has a proof, and soundness if no false statement does. Completeness is the easy half; it is a search problem. Soundness is the hard half; it is the property that makes verification meaningful. Every LLM research agent I have tested is complete — give it any prompt, including an empty one, and it produces output. Almost none are sound. Completeness without soundness is a denial-of-integrity engine: it will produce an artifact for every input, including inputs that contain nothing.
The 2017 Golem audit is where I learned to distrust form. I spent forty hours on the Solidity token distribution logic as an undergraduate and found three integer overflow paths. None of them were visible in the whitepaper, which was coherent, ambitious, and formatted beautifully. The code and the document described different systems. Nine years later the same gap exists between a report's layout and its evidence base, and the only defence is the same one: read the thing that actually executes. In a research pipeline, the thing that executes is the input manifest. Read it before you read the conclusion.
Here is what the failure looks like in current conditions. We are deep into a chop, and chop is where narrative supply outruns evidence. Volume is flat, price is rangebound, and demand for a directional story is at its peak. That is exactly the regime in which fabricated coverage is most profitable to produce and least likely to be caught — because in a range, every thesis is roughly right for a few weeks. A report claiming a protocol is undervalued will look correct during consolidation regardless of whether the analysis had an input. Chop is for positioning, and positioning is where bad provenance does the most damage, because the whole point of positioning is that you do not get to re-check the thesis after the move.
I ran into this directly while looking at rollup competitiveness. The public conversation frames OP Stack versus ZK Stack as a proof-system debate. When I pulled the actual data — sequencer revenue concentration, bridge TVL retention, the count of production deployments and their operators — the proof system barely registered as an explanatory variable. What tracks is distribution: which stack convinced more teams to ship a chain. That is a boring conclusion and it does not fit the nine-dimension template, so it rarely appears in generated research. The template wants a technical differentiator. The evidence says the differentiator is sales, and a pipeline with an empty input will never tell you that, because "sales" is not a field.
The same shape-over-substance problem shows up in the orderbook DEX debate. Every quarter produces generated analysis arguing that on-chain central limit order books will take share from centralised venues. The physics has not changed: a maker who posts a resting quote on a public chain is advertising an intention to be front-run, and latency arbitrage is a solved business with a known cost structure. Market makers price that risk, and the price they charge is wider spreads than a CEX can offer. You can build a beautiful orderbook. You cannot build away the latency. Generated research keeps producing the beautiful-orderbook story because the story is structurally available, while the latency argument requires a model of adversarial execution that no template contains.
Complexity compounds this. Uniswap V4 hooks turn the pool into a programmable surface, and the design is genuinely elegant. It also multiplies the number of places where a consumer can mistake liveness for validity — a hook returning a stale value in the correct format is indistinguishable, at the integration layer, from a hook returning a correct one. I expect most teams attempting non-trivial hooks to get the adversarial cases wrong, not through carelessness but because the surface area exceeds what a small team can audit. That is not a criticism of the design. It is an observation about how many soundness checks a given engineering budget can buy.
My 2025 review of Fetch.ai's agent payment oracles made the same point from the other direction. I found a latency gap in the off-chain computation verification path: the verification was correct but arrived after the payment had settled. Verification that is late is verification that does not exist. I proposed a zero-knowledge proof integration to close the trust gap. The general lesson transfers. The value of a check is bounded by when it executes, not by whether it is theoretically sound. A research report reviewed after the position is on has the same property. Nobody re-audits a PDF.
Institutional infrastructure already knows this. When I traced a thousand BUIDL transactions in 2024 to verify KYC/AML constraint enforcement, what struck me was the absence of fallbacks. There is no code path where the contract assumes a compliance attestation exists. The attestation is a required input, it is checked, and the transaction reverts without it. Permissioned systems cannot afford optimism because a regulator will ask. Public research pipelines have no regulator, so they default to optimism, and the cost lands on whoever traded on the output.
The fix is a checklist, not a model upgrade. Four requirements, each derived from a failure I have already watched happen on-chain:
- Mandatory input manifest. Every report ships with the exact fields consumed, the source of each, and a timestamp. A conclusion without a manifest is an unverified assertion. This is the equivalent of requiring an attestation before the transaction executes.
- Explicit bottom values. The pipeline must be capable of returning ⊥ — a typed refusal — and that refusal must propagate to the consumer rather than being rendered as an empty section. Silent degradation is the mechanism by which null inputs become trades.
- Provenance-weighted confidence. Confidence must be a function of source count and source quality, not of output fluency. A claim sourced to one tweet needs a confidence label that a downstream system can mechanically reject against a threshold, the same way a lending market rejects a stale price.
- Refusal logging as a first-class metric. Vendors should report refusal rates alongside coverage. A pipeline with a zero per cent refusal rate is not comprehensive; it is unsound, and the number is the proof.
Here is the part that unsettles me more than the models do.
The refusal is economically punished. A pipeline returning a defect table on empty input has, from the buyer's perspective, failed to deliver. A pipeline returning nine populated sections has delivered. Coverage is the product; accuracy is a second-order attribute that gets priced only after a loss. So the market systematically selects for the failure mode. The vulnerability is not in the model. It is in the procurement.
And the obvious mitigation does not work. "Put a human in the loop" assumes the human reads for evidence. In practice, reviewers triage by shape, because that is the only way to process volume — the same reason a security team scans for the presence of an audit report rather than reading it. I have watched a reviewer approve a document whose central table had been generated from a single tweet. The table was well formed. The tweet was real. Nothing in the artifact's appearance distinguished it from a document built on forty hours of work.
The uncomfortable parallel is that humans do this too. Hand a junior analyst a project with no disclosures and a Friday deadline, and you will get a report. The model did not invent template-fill. It industrialised it and removed the friction — a human at least feels the discomfort of writing "assumed" four times. The machine feels nothing and formats beautifully. For a comparison: in 2020 I stress-tested Compound's interest rate model across five hundred user portfolios and published the liquidation thresholds before the September yield drop. That work was valuable precisely because it was falsifiable — every number could be checked against a block. Generated research is rarely falsifiable, because the inputs were never there to check.
Trust no one, verify the proof, sign the block. The middle clause is the one the industry keeps skipping.
The first significant loss attributed to AI-generated crypto research will not come from a bad model. It will come from a good model, given an empty input and a deadline, that produced a well-formatted document nobody had a reason to doubt. Watch three signals over the next two quarters: whether research vendors publish input manifests alongside conclusions, whether refusal rates appear in their performance reporting, and whether anyone signs their outputs. An unsigned report with no provenance is a price feed with no validity check — and we already know how that ends.
Trust no one, verify the proof, sign the block. The null input is not an edge case. It is the test.