Nine dimensions. A risk matrix across six categories, a confidence tier for technical, investment, temporal, and reference value. Four separate tables. Every cell rendered. Every field empty.
The report consumed it as analysis.
That is the anomaly I want to dissect, and it is not a hypothetical. A due diligence pipeline accepted an extraction stage that had returned a structurally valid document containing zero information points β an empty array where the evidence was supposed to live β and emitted a downstream artifact indistinguishable, in layout and confidence, from a completed assessment. Nothing crashed. Nothing alerted. The only object that signaled failure was a prose section politely requesting the original text.
Silence in the report was the first warning sign.
Post-2024, crypto due diligence industrialized. The pattern is now familiar: a stage-one model extracts structured information points from a source document; a stage-two model expands those points across a fixed analytical framework β technical, tokenomics, market, ecosystem position, regulatory, team and governance, risk, narrative, transmission. The framework is the product. Sellable, comparable, slide-ready.
The architecture has a property that most operators never examine. Stage two is a pure function of stage one's output. Given the same information points, it produces the same analysis. This is by design β it makes the pipeline reproducible and cheap. But it also means stage two cannot distinguish between three radically different upstream states: the source said nothing; the source was never retrieved; and the extractor failed silently and returned a default template. All three collapse to the same bytes.
In typed systems this is impossible to ignore. Rust's Option and Result force the consumer to handle the empty case at compile time. In JSON β the actual substrate of nearly every research pipeline I have audited since 2023 β {"finding": "N/A", "evidence": null} is a well-formed string inside a well-formed object. The consumer never noticed.
A note on why this architecture keeps winning procurement. A framework with nine dimensions and four confidence tiers looks like rigor on a slide; it is almost impossible to falsify in a meeting; and it costs a fraction of one human analyst's week. In a market where hundreds of protocols ship per quarter, buyers optimize for coverage, not for the probability that any single assessment is correct. Coverage is precisely the property that survives an empty input β a shell renders all nine dimensions exactly as well as a real analysis does. Cheapness and coverage are the two incentives that select for fail-open design, and both are currently at maximum.
The proof is in the unverified edge cases.
Let me be precise about the failure mode, because "the AI hallucinated" is the wrong diagnosis and it is the one everyone will reach for. The extraction stage returned a conformant shell. Not a null, not an error code, not an HTTP 422 β a fully populated template in which every field carried a placeholder string and the information point list carried an empty array.
Downstream, the analysis stage received that shell and did something remarkable: it refused. Three times, explicitly. It declined to invent project names, declined to apply generic industry conclusions it could not tie to a source, declined to dress template language as findings. It then produced a recovery specification β a minimum viable information set β and enumerated the upstream conditions most likely to have caused the empty input.
That is correct leaf behavior. It is, frankly, a stronger epistemic posture than a substantial fraction of human analysts I have reviewed under NDA.
The problem is that the leaf does not control the transport. A refusal at the leaf is an error object. An error object inside a pipeline that expects a report is either dropped, retried, or β the common case β coerced into the report shape by an adapter written by someone optimizing for dashboard uptime. Once coerced, the distinction between "analyzed and found nothing" and "analyzed nothing" becomes unrecoverable by any downstream consumer, human or machine. The human sees "no findings" and reads it as "clean." The machine sees severity: null and reads it as zero. Both converge on the same wrong verdict. That is the blast radius. Retries make it worse rather than better: each pass re-persists the coerced report, so the artifact acquires a version history and, with it, the surface appearance of having been reviewed.
I have seen this structure before, and it is always the same structure.
Ronin did not fail; it was engineered to trust. Five of nine validator signatures, threshold math intact, consensus mechanism performing exactly as specified. The vulnerability lived in the off-chain signature verification path, where the absence of a check was functionally identical to a passing check. The system could not represent "this validator did not sign" as different from "this validator signed correctly," because no data structure in the path carried that distinction.
The Slasher audit I ran at 33 had the same shape, though it took me three weeks to see it. Proposer slashing conditions reverted state correctly on every enumerated path. The invariant held. It held because the undefined paths were undefined, not because they were defended. When I finally mapped the three state-reversion cases, none of them were bugs in the sense of "code did not do what it said." The code did precisely what it said. The specification had simply never said what to do when the evidence was absent.
Complexity is not a shield; it is a trap.
And the Curve dissection β the one where I built the simulation because I did not believe the forum models β made the same point in economic terms. The StableSwap invariant was mathematically sound. The fee adjustments were non-linear in a way that created arbitrage windows nobody had modeled, because the model everyone used assumed a linear response near equilibrium. When the math holds but the incentives break, the math is not the finding. The gap between the math and the world is the finding.
Here, the gap sits between schema validity and evidential validity. A document can be perfectly schema-valid and contain zero evidence. Every pipeline I have reviewed in the last eighteen months has a gate on the former and none on the latter.
The fix is not exotic. Three changes, in order of impact.
First, make the extraction stage return a hard failure on empty information points. Not a placeholder β a failure. The pipeline should treat information_points.count == 0 as an infrastructure error rather than a valid result, because in practice it always is one: articles shorter than a paragraph, paywalled sources, image-only posts, field-mapping drift between the fetch and the parse.
Second, content-address every claim. Each information point should carry a byte offset or a verbatim span into the source. A finding without an addressable span is not a finding; it is a sentence. This is the discipline I imposed on my own output after the Solana TPU stress tests in 2024 β if a reader cannot re-run my harness and reproduce my numbers, I have written an opinion, not a measurement.
Third, make the report re-derivable. Given the source and the pipeline version, the artifact should regenerate byte-identical. If it does not, something in the chain is improvising, and improvisation under an empty input is the failure mode we are discussing.
The reflex will be to blame the model. It is the wrong target, and pursuing it will make the problem worse. The model in this chain behaved correctly. It refused to fabricate under three separate temptations, each of which a human analyst under delivery pressure would have found plausible: invent a project narrative that fits the framework, apply generic sector conclusions that are true but unrelated, and deploy hedged template language that is unfalsifiable and therefore safe. Most template-driven research in this cycle is exactly those three things, performed by people, billed at analyst rates.
The failure lives one layer up, in a transport engineered to accept a conformant shell as evidence of work performed. That is not a model alignment problem. That is a design decision made by someone who wanted the dashboard green. Layer 2 is merely a delay in truth extraction β and this pipeline delayed it past the point where anyone would think to ask.
In a market where a hundred-million-dollar raise ships with a deck, a whitepaper, and an analyst note synthesized from both, the binding constraint is no longer analytical capability. It is the willingness to return an error. The next class of failure in this cycle will not be a contract bug or an oracle delay. It will be a decision made on a document that was schema-valid, confidence-scored, and empty β and nobody asked for the source. Which pipeline in your stack refuses to render when the evidence is absent?