Forty-three cells. Nine dimensions. Zero facts.
Last week, a crypto research pipeline returned a nine-dimension due-diligence report in which every substantive field carried the same value: N/A — insufficient information. Technical positioning: N/A. Token supply model: N/A. Howey test — money investment, common enterprise, expectation of profit, efforts of others — four rows, four N/As. The risk matrix had six rows; all six were blank. The competitive landscape table had two rows, "this project" and "competitor," and neither carried a single TVL figure.
The document ran for pages. It had headings, tables, confidence annotations, even a disclaimer. It contained no information whatsoever.
Most people who see that output delete it and rerun the job. I read it twice, because I have spent enough hours staring at stack traces to know that the most valuable thing a system produces is often the output it refuses to produce. A null result with a structured audit trail is not a failure. Sometimes it is the only honest artifact in the room.
To understand why, you have to understand how these pipelines are wired.
Nearly every LLM-based on-chain research tool shipping today runs a two-stage architecture. Stage one is extraction: it takes raw source material — an article, a whitepaper, a governance post, a thread — and decomposes it into a list of atomic, structured facts. Each fact carries a claim, usually a source, and a timestamp. In the trade we call these information points. Stage two is analysis: it takes that list and runs it through a fixed set of evaluation dimensions. Technical. Tokenomics. Market. Ecosystem position. Regulatory. Team and governance. Risk. Narrative. Industry transmission.
The critical property of this architecture is that stage two is a pure function of stage one. It has no other inputs. It cannot browse. It cannot remember yesterday's blog post. It cannot smell that something is wrong. Feed it twelve information points about an unlock schedule and it will produce a competent unlock analysis. Feed it an empty list and, if the code is written correctly, it produces nothing at all.
This is the same dependency structure as an oracle. An oracle does not generate truth; it relays a measurement some other process took. If the measurement never happened, the correct oracle behavior is to revert — not to return a plausible price. Every DeFi engineer knows why. In 2021 I spent three weeks inside Anchor Protocol's contracts after the UST collapse, tracing how a redemption path kept returning numbers that looked reasonable while the system underneath them was already insolvent. The lesson was not that the oracle was wrong. It was that a plausible value with no valid observation is worse than no value, because every downstream contract treats it as real.
The pipeline in question obeyed that rule. Its report states, plainly, that in the absence of an information point list, any substantive technical, tokenomic, or market analysis would constitute unfounded speculation. Then it stops. The refusal is the feature.
Now the forensics. Where does an empty information point list actually come from?
In my experience building and breaking these systems, there are exactly three failure modes, and from the output side they are indistinguishable.
Failure one: the source was never fetched. The URL returned a 403. The article sat behind a paywall or a consent wall. The page rendered its body in JavaScript and the scraper read the DOM before hydration finished, capturing a cookie banner and an empty tag. To the extractor, the page legally existed and legally contained zero sentences.
Failure two: the extractor ran and returned a valid empty array. This is the more insidious case. The model loaded, the prompt executed, the JSON parsed. The output was {"information_points": []}. No exception fired, no alert tripped. A retry would have succeeded; nothing retried, because nothing looked broken. Silent success on empty input is the most expensive bug class in any data pipeline, because every monitoring dashboard you own reports green.
Failure three: a schema mismatch. Stage one emitted info_points or key_facts; stage two read information_points. The value is present in memory, absent at the key. In TypeScript this fails loudly. In a chain of dict lookups with a default, it fails into that default — and the default is precisely the null that means "no data."
Notice what all three share: the pipeline cannot distinguish "the world contained no facts" from "I failed to look." Both arrive at stage two as the same empty list. The report you receive is identical either way. That indistinguishability is where I would start the audit — not with the model, but with the boundary.
Here is the code that matters, reduced to pseudocode.
def analyze(info_points):
if len(info_points) == 0:
return NullReport(reason="no input")
return model.run(DIMENSIONS, info_points)Versus the version that actually ships in most products:
def analyze(info_points):
return model.run(DIMENSIONS, info_points)The second version, handed an empty list, produces a document that looks exactly like a research note. It will tell you the tokenomics carry inflation risk, because tokens usually do. It will flag the team as anonymous, because many teams are. It will rate smart contract risk as medium, because everything is medium. Every sentence is locally plausible. Every sentence is unfounded.
I audited a portfolio-tracking product in 2024 with this exact structure, and I want to be precise about the damage. It was not that users got a wrong number. It was that they got a confident number with a citation attached — and the citation pointed to a page that had been deleted eleven months earlier. The model had learned the shape of a citation without the substance of one. A hallucination is not a lie. It is a schema violation rendered as prose.
The pipeline that produced the null report avoided this by asserting a constraint I wish more teams would write down: generating hidden information from no text input is equivalent to fabrication, and the framework declines to perform it. That is an engineering decision expressed as editorial policy. It is the correct one. Math doesn't negotiate — and neither should a schema. Zero inputs, zero outputs. There is no third option.
Here is the part non-engineers miss. The valuable section of that null report is not the N/As. It is the section at the bottom titled Request for Input. It enumerates a minimum viable input set: at least five structured facts with sources, at least one named project with a ticker, a one-line thesis plus the author's position, and a publication timestamp. Four required fields. Everything else — chain data snapshots, token allocation tables, funding history, governance records — is listed as optional, ranked by how much analytical power it unlocks.
That is a schema contract written in plain English. It tells the requester exactly what the pipeline needs, which makes the null report actionable rather than merely defensive. A refusal that names the missing dependency is a diagnostic. A refusal that doesn't is just a wall.
Zoom out to the market we are actually in. It is a bear market, and in a bear market the dominant failure mode of research is not missing a rally. It is holding a position whose risk you mis-modeled.
Over recent quarters I have watched protocols shed a third to a half of their liquidity, and in nearly every post-mortem I read, the analysts were surprised by something that was visible in the code long before it was visible in the price. A vesting cliff sitting inside an unlocked contract. A 2-of-5 multisig where two keys belonged to the same custodian — a pattern I flagged repeatedly while auditing institutional custodial setups after the 2024 ETF approvals, where the marketing claimed threshold security and the key-share distribution told a different story. A rewards schedule funded entirely by emissions with no protocol revenue underneath it. None of that requires a clever model. It requires a model looking at something real.
An analysis pipeline that fills silence with plausible text is, in a falling market, an active liability. It manufactures the exact feeling of diligence that precedes a bad position. I would rather run a tool that returns nothing and tells me why, than one that returns six paragraphs and a medium-risk rating.
The minimum viable input set is a decent floor, though I would tighten it. Five facts is thin justification for a nine-dimension report. My own rule, developed the hard way across more audits than I care to count: if a report's conclusions cannot be traced one-to-one to a specific information point with a live source, that conclusion does not belong in the report. Nine of ten dimension tables in commercial crypto research would go empty under that rule. Which is exactly what the null report is telling us.
The report's own risk section is where its author knows precisely what they are doing. Risk item one, rated high: analysis pipeline chain break — the upstream stage failed and the downstream stage idled. The recommended fix is not to prompt harder. It is to check whether the source text was retrieved at all, repair the extraction layer, and rerun from the top. Risk item two, rated high: AI hallucination risk, with the note that forcing output from no input produces content that appears professional and is entirely fabricated, and that the harm to the user exceeds the harm of no output. I have seen that harm priced. It shows up as a reader who trusted a rating, sized a position on it, and discovered eight weeks later that the underlying data was gone.
Now the counter-argument, because there is one and it is stronger than it looks.
A refusal is not proof of integrity. The null report and a broken job are, from the outside, the same artifact. Nothing in that document attests that stage one executed. There is no signed execution trace, no hash of the fetched page, no timestamp of the retrieval attempt, no log line proving the model saw an empty list rather than crashing before it looked. The report says the input was empty. It cannot prove the input was fetched.
That gap matters more in crypto than anywhere else, because we already solved this problem once in a different domain. When I worked on verifying off-chain AI model outputs in 2026, the entire difficulty was the same one: a claim about what a computation did is worthless without evidence the computation ran. We built circuits to prove that specific weights consumed specific inputs and produced a given output — not that the output was good, only that it was derived. The null report needs the same treatment. Privacy is a feature, not a bug, but so is provenance, and right now this pipeline's emptiness is unaudited. Until these systems emit attestations, honest silence and silent failure will remain indistinguishable. Code is law, but bugs are reality.
So my forecast for the next cycle of research tooling is not bigger models. It is attested pipelines: every report carrying a signed record of what was fetched, when, and whether the analysis ran on real inputs. The teams that ship that will look slower than the ones shipping confident prose. They will also be right more often — and in a bear market, being right and being empty amount to the same thing when the alternative is being wrong and loud.
The question is not whether your analyst can write. It is whether your analyst can tell you when it didn't.