A due diligence report crossed my desk last week. Forty-one fields. Nine analytical dimensions. Every field, every dimension, returned the same value: insufficient information.
It was formatted correctly. Headers, tables, a confidence-calibration section, a risk matrix, a closing disclaimer. By every structural measure, it was a finished document. It contained zero findings. It was not flagged as a draft. It had cleared the layer above it and arrived as a deliverable.
The pipeline did not crash. That is the entire problem.
Automated research pipelines have quietly become the backbone of crypto due diligence. Between 2024 and 2026, funds that once staffed six junior analysts replaced four of them with an LLM chain: scrape, parse, extract information points, run a nine-dimension framework, emit a formatted report. The economics were irresistible. Cost per report fell by an order of magnitude. Volume — the metric everyone actually measures — tripled.
What did not triple was verified information. Nobody changed the metric.
The incentive design is the root cause, and it is not subtle. Every pipeline in production is scored on completion rate: the share of inputs that yield a formatted output. Not one of them is scored on information gain per document. When you optimize a system for output that can be counted rather than output that can be trusted, you build a factory for documents nobody reads.
When a human analyst writes a report, the report carries a cost: the hours it took, the questions that had to be answered before anyone started typing. When a pipeline writes one, that cost collapses toward zero. The system can now produce the form of diligence faster than any team can produce the substance. Damage accumulates inside that asymmetry.
Two weeks ago I asked a fund's operations lead how many reports their pipeline produced in Q1. He knew instantly: 1,143. I asked how many had been read end to end. He did not know. Neither did anyone else.
The failure deserves a contract term: missing revert.
In Solidity, a function that fails silently — no require, no revert — does not stop the caller. It returns a default value, usually zero, and execution continues. The caller sees a successful return. Nothing on the surface distinguishes "the answer is zero" from "I never computed an answer."
I have watched that pattern drain a protocol. In 2018, auditing the 0x v2 exchange, I spent four months on the maker fee calculation and found an integer overflow with no guard. The math was not wrong. The math was unchecked. Under specific input magnitudes the fee would wrap, and an attacker could pull liquidity from the pools at effectively zero cost. I filed seven issues. The mainnet launch moved two months.
An unchecked answer and a correct answer look identical until the exact moment they don't.
The pipeline received empty inputs. It did not error. It emitted the default template — every field stamped insufficient information, every table rendered empty but present, every heading intact. Exit code zero. HTTP 200.
Failure mode one is architectural: fail-open design inside a system that must fail-closed. A research pipeline whose input validation asks "did we receive bytes" rather than "did we receive findings" will eventually emit an empty document that looks complete. No exception is thrown. No alert fires. The output is a valid instance of the schema.
Failure mode two is what actually lets empty reports into decision flows: schema theater. A nine-dimension framework with all fields populated is indistinguishable from a completed analysis at the interface layer. A risk matrix implies risks were assessed. A confidence-calibration section implies confidence was calibrated. Structure becomes a proxy for process, and proxies are what compliance buys.
I have seen this substitution before, in token governance. A project publishes a DAO with a Snapshot page and a quorum rule, and the existence of the machinery gets treated as evidence of decentralization — while the foundation wallet holds 34% and the top ten addresses control the vote. The structure is real. The function is decorative. Audit the promise, not the poster.
Failure mode three is provenance. Last year I audited an AI-agent platform using crypto rails for autonomous service execution. The contracts were clean. The accountability trail was not. When an agent made a decision, no legible record existed of the model version, the inputs, or the weighting. Immutable settlement layered on top of opaque reasoning.
This report shares that defect. It carries no model version, no input hash, no operator signature, no timestamp anchored to anything external. It is not reproducible. Ask whether it read a single line of source material and there is no way to answer. Reproducibility is the only honest form of a conclusion; this document is unreproducible by construction.
In 2022, reconstructing the Terra collapse, I tracked more than $40 billion in panic selling across a handful of days. The numbers were public the entire time. What was missing was anyone reading them at the right speed. That failure was not hidden data — it was unread data. The distinction matters here. This pipeline did not conceal a finding. It produced a document whose every line announced that no finding existed, and the document advanced anyway.
Run the arithmetic. If a pipeline emits 1,143 reports a quarter and reviewers process them at an average of nine minutes each, that is 171 hours — roughly four working weeks for one person. No fund budgets four weeks of senior attention for a queue it believes is automated. The queue grows. Review depth per document collapses. An empty report does not need to fool a careful reader. It only needs to reach a tired one.
Stack the three failure modes and you get a document that fails without signaling, impersonates completed work, and cannot be audited after the fact. Every layer of the pipeline did what it was asked. Every layer reported success. Code does not lie; people do — and so do pipelines that were never instructed to tell the truth.
Here is what the pipeline's defenders get right, and they get more right than the critics admit.
The model did not hallucinate. Confronted with empty inputs, it refused to invent a project name, refused to write "L2 competition is intense," refused to fill gaps with plausible industry noise. Most systems in that position generate. Refusal is the correct behavior and it is rare. A fabricated analysis would have been more dangerous than an empty one, because fabrication survives review — it reads like work.
The failure belonged to humans, twice: once for shipping an unlabeled hazard downstream, once for building a process in which nobody held the authority to stop it. Human-in-the-loop without authority is theater. A reviewer who can only append a comment to a formatted report is not a control. He is a signature block.
An empty report is the lesser evil. It is not a safe default — lesser evil and safe default are different objects. High yield is a warning, not a welcome. So is a report that looks finished and took zero seconds to produce.
The uncomfortable corollary is that the empty report was, in one narrow sense, the most honest document that pipeline produced all quarter. It stated, in every field available to it, that it did not know. That is a claim most of those 1,143 reports could not have made.
The fix is a gate, not a lecture. If the information-point list is empty, the pipeline reverts. Non-empty inputs become a precondition, not a field to be filled with "N/A." Exit codes get logged. Reports get input hashes. The count of unread reports gets posted next to the count of produced ones.
One question I would put to every fund running one of these systems: how many documents formatted exactly like this one are sitting inside your decision flow right now — structurally complete, substantively hollow, signed by nobody?