The report came back clean. Nine sections, forty-seven fields, every one of them populated with a value of "N/A โ insufficient information."
No invented TVL. No token allocation table pulled from a deck that never existed. No founder pedigree assembled from a LinkedIn profile and a conference panel appearance. Forty-seven blanks, each one labeled honestly.
Most desks would file that as a failed run. I logged it as the most interesting artifact I have read this quarter โ because the system that produced it was built to produce something else.
The architecture was conventional. Stage one extracted facts from a source document. Stage two analyzed those facts across nine dimensions: technical, tokenomic, market, ecosystem position, regulatory, team and governance, risk, narrative, and supply-chain transmission. Stage one returned nothing. Stage two, correctly constrained, returned nothing back. The pipeline had been given an empty document, and it declined to convert that emptiness into prose.
That is not a normal outcome. It is not normal because abstention is not what these systems are paid to do.
By early 2026, a significant share of institutional crypto diligence flows through an automated extraction layer before a human ever reads the source. The economics are straightforward. An analyst who files "insufficient information" gets a conversation with the PM. An analyst who files nine populated dimensions gets a promotion โ until the position unwinds. The same gradient is baked into the models themselves. They are trained on text in which documents get answered, not declined. Completion is the default state. Abstention has to be engineered, tested, and defended.
Which brings me to the interesting part.
The blockchain solved this problem once already, and then forgot it solved it.
In August 2022, the Nomad bridge lost roughly $190 million in a few hours. The root cause was not reentrancy and not oracle manipulation. During a routine upgrade, an initialization routine marked the zero hash as a confirmed Merkle root. Proofs that resolved to that empty root passed validation. From that moment, any message could be submitted and accepted as proven. The first attacker's transaction was copied by hundreds of others who simply changed the recipient address. The drain became a free-for-all within minutes.
Read that mechanism again, because it is not a bridge bug. It is a class of bug. A system that checks only for error will read absence of data as success.
The EVM carries the same property at a lower level. A low-level call to an address with no deployed code returns true. The call "succeeded." Returndata is empty. A require(success) passes. No function ran at all. This is precisely why OpenZeppelin's SafeERC20 inspects returndatasize() rather than trusting the boolean โ because tokens like USDT return nothing, and a naive require(token.transfer(...)) reverts on a perfectly valid transfer while a naive call sails through against a target that does not exist. SWC-104, unchecked low-level calls, remains one of the most reliable ways to lose money in this industry.
I built the wrong version of this in 2020. My first liquidity-depth model for Compound and Uniswap V2 treated a missing pool record as zero depth rather than as a missing record. Zero depth and unknown depth produced identical output. It took a week of backtested anomalies before I traced the divergence to that single conflation. The fix was eleven lines. Finding it took six weeks.
The research layer has no `returndatasize()` check.
Here is what the check looks like when you actually write it down. At the boundary between extraction and analysis, the pipeline must assert on the cardinality of its own input, and it must propagate the failure as a typed value rather than as an exception that some upstream handler catches and swallows:
def analyze(stage1_output):
facts = stage1_output.get("facts") or []
if not facts:
return NullReport(reason="no_extracted_facts")
...That part is trivial. What is not trivial is the downstream design decision: a NullReport must be a first-class return type, not an error state. Error states get retried, logged, and eventually silenced. A typed null result survives all the way to the reader.
The second check matters more. Every claim in an analysis should carry an evidence pointer and a confidence value, and the gate should refuse to emit a report whose evidenced-claim count falls below a floor:
CONFIDENCE_FLOOR = 0.35def gate(claims): supported = [c for c in claims if c.evidence_uri and c.confidence >= CONFIDENCE_FLOOR] if not supported: return NullReport(reason="no_evidenced_claims") return supported ```
Two numbers fall out of that structure, and they are the only two I now ask for when someone hands me a diligence product. The abstention rate โ null fields divided by total fields. And citation density โ distinct primary sources divided by confident claims. A report with a zero percent abstention rate and citation density under 0.5 is not analysis. It is a completed form.
There is an on-chain analogue, and it is the one I trust most. Oracle staleness windows. Aave and Compound do not merely ask whether a price feed answered. They ask how long ago. A stale price that returns successfully is more dangerous than a feed that reverts, because reverting halts the protocol while staleness silently misprices every position that depends on it. During the Terra collapse I traced exactly this sequence โ feed delays compounding into liquidation cascades โ and the lesson was never really about algorithmic stablecoins. It was that a fresh-looking answer and a correct answer are different objects, and only one of them is checked by default.
Now the contrarian part, because the easy conclusion is wrong.
The obvious read of an empty input producing an empty report is that the model failed. It did not. The model abstained, which is correct behavior, and it did so because someone constrained it to. The real problem is that most pipelines in production are tuned so that a null result never reaches a human. Not through malice. Through incentive. Output volume is measurable. Abstention looks like laziness. A PM who receives nine N/A fields escalates. So the threshold below which a system should say "I don't know" gets quietly lowered until it disappears โ and nobody versions it, tests it, or writes it down anywhere.
Be precise about causation here, too. Empty inputs do not cause fabrication. Fabrication is caused by a reward function that penalizes abstention. Empty input is merely the stress test that exposes it. Run the same completion-biased pipeline against a full document and it will over-read instead โ extracting a partnership from a logo wall, inferring a roadmap from a hiring post. That failure is quieter, and therefore more expensive.
So here is next week's signal. Take any research product you receive, internal or vendor, and compute the two ratios. Then run the empty test: feed the pipeline a blank document and see what comes back. If it returns nine populated dimensions, you have found the bug before the market prices it for you.
When code speaks, we listen for the discrepancies. When it says nothing at all, we should listen harder.