Every Cell Said N/A. It Passed Review.

A nine-dimension due diligence report on a mid-cap DeFi protocol crossed my desk in April. Technology. Token economics. Market. Ecosystem position. Regulation. Team and governance. Risk. Narrative. Supply-chain transmission. Forty-one table cells across the framework.

Every one of them returned the same string: N/A — insufficient information.

The document ran forty pages. The formatting was immaculate. The headings were correct. The risk matrix had the right five columns and the right six rows. The Howey test section listed all four elements in the correct order.

And it contained zero facts.

It passed internal review. Not because the reviewer was lazy. Because the renderer did not distinguish between a placeholder and a finding. The file was schema-valid. It was semantically empty. Nobody had written the assertion that would have caught the difference.

That is the most expensive failure mode in this industry right now. Not bad data. Absence of data, dressed in the costume of analysis, moving through a process designed to read the costume and not the body.

The Industrialization of Diligence Theater

Between 2021 and 2025, crypto due diligence became a product. That is the context. This is not a story about one broken report. It is a story about an industry that built factory machinery for a process that does not industrialize well.

Consider what a fund actually needs before it writes a check. Five things. What is the protocol doing. Who controls it. Where does the money come from. Where does it go. What breaks first. Four of those five are not obtainable from a template.

But templates are cheap, and analysts are not. So the market produced templates. Nine dimensions, twenty-two sub-sections, weighted scoring rubrics, red-amber-green heatmaps. The pitch was consistency. The deliverable was a PDF that looked like the last PDF, which looked like the one before it.

The second wave was automation. Scrape the docs. Parse the contracts. Pull the on-chain data. Push it all through a scoring engine. Fill the template programmatically. This cut the cost of report production by roughly an order of magnitude, and it introduced a new failure class that nobody priced.

When a human analyst faces missing information, they feel discomfort. They write "data unavailable" and they flag it. The discomfort is a control. When a pipeline faces missing information, it does not feel anything. It writes the null. It continues. The schema was satisfied. The job returns exit code zero.

The costs of that asymmetry are now visible on-chain, in governance forums, and in the deal memos of funds that will not be named here. I have read research from three separate desks in the last eighteen months where the "Team" section was populated entirely by scraped LinkedIn titles with no employment verification, and where the "Risk" section listed "smart contract risk" as the mitigation for "smart contract risk."

The template did not fail. The template worked. It produced exactly what it was specified to produce: a document whose shape resembles diligence.

Trust is a bug, not a feature. That applies to your own pipeline before it applies to anyone else's protocol.

Null Propagation: Valid Data, Empty Meaning

Here is the mechanical core of the problem, and it is worth being precise about it, because the imprecision is where the money leaks.

A JSON object with forty-one null-valued keys is valid JSON. A CSV with forty-one empty fields is a valid CSV. A markdown table where every cell reads "N/A" is a valid markdown table. Every validator you have will accept it. Every linter will pass it. Every downstream consumer that checks types rather than semantics will ingest it without complaint.

This is not a hypothetical. In 2024 I sat in a design review for a portfolio monitoring system. The ingestion layer had twelve validators. Nine checked schema conformance. Three checked numeric ranges. Zero checked whether the value was semantically meaningful. A feed emitting apy: 0 and a feed emitting apy: null were indistinguishable to the risk engine, which then computed a weighted average that understated exposure by a factor of six.

The failure propagated silently for eleven days before someone noticed that the blotter and the dashboard disagreed.

There are three structural reasons this recurs, and they compound.

First, nulls are absorbing. A null multiplied by anything is still null, but a null coerced to zero is zero, and zero is a number that does arithmetic. The moment your pipeline coerces for convenience — and every pipeline coerces somewhere — you have converted an epistemic gap into a quantitative fact. That fact will then be aggregated, averaged, and reported upward with a confidence interval attached.

Second, missing data and zero data look identical at the boundary. A protocol with no users and a protocol whose user metrics failed to load both return an empty DataFrame. The first is a finding. The second is an outage. Your code cannot tell the difference, and neither can the analyst reading the automated output at 9 a.m. on a Monday.

Third, the pipeline is rewarded for completion and never for abstention. This is the incentive layer, and it explains everything downstream of it. A report that says "I could not assess this" is a failed deliverable. A report that says "N/A — insufficient information" in forty-one cells, wrapped in nine headings and a disclaimer, is a completed deliverable. It ships. It bills. It gets filed.

The correct design is obvious and almost nobody implements it. Assert non-null at the gate. Fail loudly. Refuse to emit a document in which the information-point list has length zero. If your framework requires a source field on every claim, then a document with no source fields cannot be generated — not because a human declined, but because the schema rejected it.

I have written about this before in the context of the 0x Protocol v2 review in 2018. Three logic flaws in signature verification had survived prior audits because the auditors validated the shape of the code and not its semantics. The functions compiled. The tests passed. The signatures were checked. The checks checked the wrong thing.

History repeats, but the gas fees change. The failure mode in 2018 was a verifier that verified the wrong property. The failure mode in 2026 is an analyzer that analyzes nothing and reports success.

The Hallucination Gradient

Now the part that most people get backwards.

The conventional worry is that an AI model, starved of input, will invent output. That is true, and it is the less dangerous half of the problem.

The more dangerous half is that a model given no input, but asked to complete a template, faces a gradient. On one side: produce an empty report, get rejected as useless. On the other side: produce a plausible report, get accepted, get shipped, get paid. The gradient points at fabrication every time. And fabrication is not even a lie in the model's frame — it is the completion of a pattern it was trained on. A senior analyst writing a technology section writes sentences like these. So the model writes sentences like these.

A senior analyst writing a technology section also verified them. That step is not in the pattern. It is in the person.

I have now reviewed four reports produced under this structure. The tell is consistent and it is easy to detect once you know it. Fabricated sections have no units, no hashes, no dates, and no counterparties. They describe architectures without naming contracts. They describe teams without naming employers. They describe unlocks without naming cliffs. They are grammatically confident and referentially empty. You cannot check any claim in them, because no claim in them points anywhere that exists.

The remedy is not better models. The remedy is a required evidence field per assertion, and a hard block on any assertion whose evidence field is blank. One of the desks I advise now enforces this, and its report output dropped by 60% in volume and rose by roughly an order of magnitude in usefulness. Six out of ten template cells were not being filled with evidence because they were never fillable.

That ratio should alarm you. Six out of ten columns in a standard diligence template were structural decoration.

Four Exhibits From the Chain

Everything above is abstract. Here is what it looks like when the null is not in a report but in a dataset the report was supposed to describe.

The availability layer that measured the wrong thing.

In 2024 I audited a rollup's data availability dashboard. It reported 100% availability for ninety consecutive days. Impressive, until you check what the metric counted. It counted sequencer liveness — the fraction of blocks produced on schedule. It did not count committed bytes.

I pulled the blob counts directly. The median daily commitment was under 0.2 MB. The chain was posting less data in a day than a single Ethereum block carries in calldata. The dedicated DA layer was contracted, paid for, and doing almost nothing.

This is the pattern across the category, and it is why I have been unenthusiastic about the DA market for three years. The pricing assumes a demand curve that does not exist yet. Most rollups do not generate enough data to need a specialized availability layer. They need a reliable one, which is a different purchase, at a different price, from a different vendor.

The dashboard was not lying. It was answering a question nobody had asked. A metric that measures uptime will report 100% on a chain that is running and empty.

The liquidity program whose TVL was its own treasury.

A gauge-based incentive system, 2021 vintage. Reported TVL of $310M. I ran the wallet-level decomposition.

$186M traced to nine wallets. Four were treasury multisigs belonging to the protocol itself. Two were deployer test wallets that had never been rotated. Net external capital: $118M. Annualized incentive spend at the peak: $41M.

Run the division. The marginal cost of external TVL was roughly $347 per thousand dollars held, per month.

When the emission schedule was cut 60%, TVL fell 71% in eleven days. The lag between the cut and the collapse was not demand decay. It was the unbonding period. The capital had been waiting at the door the entire time.

This is the arithmetic that the APY number conceals. An APY is a price the protocol pays for a balance sheet entry. It is not a return to a user, and it is not evidence of product-market fit. When a program can only be sustained by emitting its own token into its own pool, the honest label is not "yield." It is "recirculation."

The five-party verifier set with one funder.

A cross-chain bridge, reviewed late last year. The architecture diagram showed five independent verification parties across four jurisdictions, with a threshold of three.

I traced the funding. All five verifier addresses were funded from the same deployer wallet, in sequence, within four blocks of each other. Two of the five had never signed a message that was not a test vector.

That is not a decentralized verification layer. That is a signature with a diagram attached. The threshold of three existed on paper and was satisfied by one entity's operational convenience.

The trust assumption in every bridge of this design is the same: you are trusting an oracle and a relayer to not collude. The decentralization claim is a statement about how many entities you would need to compromise. If the answer is one, the marketing is not describing the system. It is describing the intent. Code is law; intent is irrelevant.

The compliance section where all four cells read "cannot assess."

A token review, 2023. Howey test, four elements applied to the distribution history.

Money investment: yes, but the allocation was never disclosed. Common enterprise: the distribution was private and the cap table was not public. Expectation of profit: the marketing materials used the word "yield" fourteen times across two pages. Efforts of others: the team held an unrestricted admin key over the token contract.

Every cell of the analysis returned "cannot assess." The correct output was a red flag with a stop recommendation, because the inability to assess the securities question is itself the securities question. An undisclosed distribution with an admin key and yield marketing is not an ambiguous case. It is an unexamined one.

The produced output was "proceed with caution."

Four nulls, aggregated, produced a recommendation to proceed. That is how the null propagates all the way into a position.

What the Automation Bulls Got Right

I should be fair to the other side of this, because the other side has a real argument and dismissing it would be sloppy.

Manual diligence is not a control group. It fails constantly. The audit industry's own track record is the evidence. Protocols with three audits have lost user funds to reentrancy. Protocols with formal verification have lost user funds to a misconfigured admin key. A human reviewer at 11 p.m. on a deadline writes confident prose about code they skimmed. The intuition that "a person would have caught it" is partly nostalgia for a form of diligence that was never as rigorous as its reputation.

The automation advocates are right about three specific things. Machine extraction catches inconsistencies across a large corpus that no human reads in full — the disclosed unlock schedule that contradicts the GitHub vesting contract, the team member listed in two jurisdictions with incompatible claims, the TVL figure that does not reconcile to the sum of pool balances. Those catches are real and they are frequent. Second, machine output is auditable in a way human prose is not. A pipeline that logs its inputs can be replayed. A partner's memory cannot. Third, the cost collapse is genuinely welfare-improving when the output is honest, because it moves baseline screening from "not done" to "done cheaply."

The disagreement is narrower than it looks. The automation argument is correct about coverage and wrong about termination. More extraction does not fix a null. It multiplies it. A pipeline that scrapes forty sources and finds nothing has produced forty nulls and a stronger impression of thoroughness. The failure is not that the machine looked insufficiently hard. The failure is that the process had no path for reporting that it found nothing, and so it reported something else instead.

The correct framing is not "fix the pipeline." The pipeline worked exactly as specified. The specification was wrong. It permitted an empty result to masquerade as a completed one, and it paid out on completion.

Accountability

The forward-looking question is not whether your model hallucinated. It will. The question is whether your review process was designed to notice, and the honest answer for most desks is that it was designed to read the header, check the length, and confirm the sections exist in the right order.

Three things to change this quarter. Put a non-null assertion at the schema gate, so a document with zero information points cannot be emitted. Require an evidence pointer — a hash, a contract address, a dated filing — on every assertion, and let blank evidence block publication. And log the input alongside the output, so that when a report is challenged you can replay what it actually saw rather than what it claims to have seen.

The ledger does not lie, only the interpreters do. Forty-one cells reading N/A is not a failure of analysis. It is analysis reporting the truth. The failure was that the truth was formatted to look like something else, and the process that should have read the content read the formatting instead.

Ask your diligence vendor one question this week. What does your report say when you find nothing? If the answer is anything other than "nothing," the report is not a document. It is a liability with a cover page.