Last month, a due-diligence report crossed my desk. Nine analytical dimensions. A risk matrix across six categories. A four-axis value rating. Forty-one named assertion fields in total. I counted how many contained a single observation.
Zero.
Every row returned the same string: insufficient information. The report did not crash. It did not throw. It returned forty-one nulls, a composite judgment block, and a rating table with five empty stars on every axis. Then it asked for more input, politely, in five bullet points.
I have spent nine years reading protocol code, and I have seen this exact failure mode precisely once in production: an oracle that serves a stale price instead of reverting. The contract keeps executing. The position keeps opening. The number on the screen looks fine. Nothing in the system's behavior announces that the input never arrived.
A null dressed as a value is more dangerous than an error, because an error halts execution and a null does not.
Context: the two-phase architecture and where it breaks
The report was the output of a two-stage pipeline, which is now the default shape of institutional crypto diligence. Phase one extracts discrete information points from a source: title, publisher, claims, referenced addresses, numbers. Phase two applies a fixed evaluative schema — technical, tokenomic, market, ecosystem, regulatory, team, risk, narrative, supply-chain — and scores each dimension.
This is a sound architecture. I use something like it myself, and I have since 2020. Splitting extraction from evaluation keeps the evaluative layer stable while sources change. It lets you run the same grid over a whitepaper, an audit, a governance forum thread. It is reproducible, which matters when your output is consumed by a committee rather than by you.
The defect is in the coupling. Phase two validates the presence of the schema, not the sufficiency of phase one. Give it a document and it scores nine dimensions. Give it an empty document and it still scores nine dimensions — because the schema is the contract, and the contract was satisfied. The evaluation layer has no require statement on its input.
In Solidity terms, this is a function that returns a default value rather than reverting. It is try/catch with an empty catch block. It is an address(0) check that was never written. The function is callable, gas is spent, state is written, and the caller receives a struct that is well-formed and wrong.
Core: forty-one slots, zero claims
Let me be precise about what the report actually contained, because the arithmetic matters.
The document enumerated nine dimensions. Within those, it specified four technical indicators, a five-row supply table, a four-element Howey test, a six-row risk matrix, a three-column expectation gap table, and a four-axis value rating. Rounded down, that is forty-one fields designed to receive a fact.
Forty-one fields. Zero facts. One conclusion — that no conclusion was possible — expressed in the same typographic register as a conclusion.
Completeness of form is not completeness of knowledge, and the difference is invisible to any system that validates shape.
What makes this more than an anecdote is the rating table. Every axis — technical value, investment value, timeliness, reference value — received the same score: five empty stars. The scoring mechanism executed. The score is absent. Read quickly, that table says rated. Read precisely, it says unrated. Two readers, two opposite takeaways, one artifact.
I encountered the prototype of this bug in 2017, in the Golem Network presale contracts. I spent about forty hours tracing the ERC-20 distribution logic against the whitepaper's economic model, and the problem was not that a function was missing. The problem was that a function existed, accepted an input outside its intended domain, and returned a number that fit the expected shape. The integer overflow produced a plausible output for an impossible input. Nothing reverted. The code was, in the narrow sense, working.
That is the class of defect I now look for first, in code and in prose. Not absence of logic. Logic that runs on inputs it was never designed to see, and reports success.
In 2020, during the DeFi Summer composability crunch, I spent weekends simulating attack vectors against Aave's flash-loan aggregator interfaces. The lesson that survived that exercise was not about reentrancy. It was about assumption laundering. Protocol A assumes its input is well-formed. Protocol B assumes Protocol A validates. Protocol C consumes both and assumes the pair is coherent. Each layer is individually defensible. The composition is not. Nobody wrote the bad assumption. Everybody inherited it.
Research pipelines have the same property. The extraction layer assumes the source contains claims. The evaluation layer assumes the extraction layer found claims. The reader assumes that a structured document was structured around something. Three assumptions, all reasonable, all unverified, and a null travels the length of the chain wearing a schema.
The deeper issue is that most analysis systems cannot distinguish zero from null. In code, the distinction is load-bearing. Zero is a claim: this protocol has no revenue. Null is an admission: I did not measure revenue. One is a finding. The other is a statement about the analyst. Collapse them and you get a report that scores a protocol's revenue as zero because it never read a financial statement — and that score will be consumed by a human, or by a model, as information.
Here is the tell in the report I received. It refused to hallucinate. It labeled every absence explicitly, dimension by dimension, and it ended by listing the five input fields it needed. That is the correct behavior under uncertainty, and it is rare enough that I want to name it: the pipeline reverted instead of returning a default.
It reverted — but inside a container that looked like an answer.
Contrarian: the problem is the demand curve, not the template
The obvious critique is that this is a bad report. I think that critique is misaimed, and the misdirection is the interesting part.
The empty report is the honest output. The dangerous artifact is its sibling: the one that receives the same empty input and returns three and a half stars on technical value because the schema wanted a number and the model supplied one. That artifact is indistinguishable in form from the one I received. Same nine dimensions, same forty-one fields, same typesetting. It simply isn't guarded by an explicit null.
Certainty is manufactured exactly where measurement is unavailable, and the manufacturing cost is near zero.
Now follow the incentive. Nobody subscribes to a research product whose output is insufficient information. Nobody forwards it. Nobody puts it in the deck. In a bear market the pressure intensifies, because the question readers are actually asking — is my capital safe here — is precisely the question that cannot be answered without data, and the moment when data is scarcest is the moment willingness to pay for an answer peaks.
So the selection pressure runs against epistemic honesty, systematically and by construction. The pipeline that reverts on empty input produces unreadable output. The pipeline that fabricates produces marketable output. Both are equally cheap to run. Over enough iterations, the second one wins, and it wins by becoming standard.
The report I received is therefore not a bug. It is a fragile feature — an invariant that holds under low commercial pressure and that I expect to be removed as soon as the product needs retention.
And there is a second-order exposure almost nobody is pricing. These reports are increasingly consumed by other machines: risk engines, delegated due-diligence agents, allocation heuristics, monitoring dashboards. The instant a research output is wired into an automated decision, it stops being a document and becomes an oracle. At that point a null-valued report is not an editorial failure. It is stale price data entering a position-sizing routine.
Fragility is the price of infinite composability. The research layer inherited the property the execution layer already had: every component is trustworthy in isolation, and the assembly is only as strong as the weakest unvalidated assumption between them.
Takeaway: where the next exploit lands
I do not expect the next material failure in this cycle to be a bridge or a lending market. Those have auditors, insurance markets, and post-mortems with named authors. The information layer has none of that, and it is now load-bearing.
Watch for provenance attestation inside research pipelines — signed source custody, so a claim can be traced to the document and timestamp that produced it. Watch for explicit revert semantics: a scoring function that refuses to emit a value when its input set is empty, and logs the refusal. And watch for the difference between zero and null in every dashboard you consume.
Hype creates noise; protocols create history. The analysis layer has spent four years producing noise at industrial scale, and it now feeds capital allocation. The question is not whether these reports are accurate. The question is what your risk engine does when it reads one that says insufficient information. Does it revert — or does it open the position?