An analysis framework that returns nothing is more dangerous than one that returns wrong answers. Wrong answers can be falsified. Nothing reads like patience.
Last week a nine-dimension diligence pipeline โ the kind now bolted onto the front of every serious crypto research desk, and onto the back of every AI agent that advertises "asset analysis" โ completed a full run and returned forty-seven fields of N/A. Technical maturity: not available. Vesting schedule: not available. Voter concentration: not available. Streaming risk. Sanctions exposure. Contract audit status. Every risk-matrix cell, every competitor comparison row, every allocation percentage. The framework did not crash. It did not throw. It did not return an error code. It produced a document with headers, tables, a risk matrix, four composite scores, a professional-terms glossary, a disclaimer, and a closing section titled "Follow-Up Action Recommendations."
Four composite scores is the part worth sitting with. Technical value, investment value, timeliness value, reference value โ each rated one star out of five. A null result was silently coerced into a minimum score. In a dashboard, one star does not read as "unknown." It reads as "bad." Somebody downstream will eventually read that as a cautious bearish signal and act on it.
I have spent twenty-four years watching systems convert absence into value. This is the most expensive conversion I have seen in crypto research, and almost nobody audits it.
The Industrialization of Diligence
In late 2017 I audited the Ethereum congestion caused by CryptoKitties from inside a major exchange. Gas fees had spiked roughly 400 percent, and transaction processing stalled for twelve hours. The methodology was primitive by any modern standard: I pulled blocks, read bytecode, measured gas per call path, and wrote a post-mortem with fifteen concrete optimization suggestions for the ERC-721 standard. Three early layer-2 teams cited it. The reason it was useful was not that I was smart. It was that I had the raw data, and I had it at the resolution the problem required.
In June 2020, during DeFi Summer, I built a risk assessment for Curve Finance governance by hand. Eleven tabs. Proposal history, whale wallet behavior, liquidity pool concentration, voting-power decoupling scenarios. I identified a mechanism by which large holders could manipulate pool incentives, and I predicted a 30 percent drawdown in TVL if governance remained coupled to voting weight. That work took three weeks. It was shared by more than five thousand community members, and it moved my own thinking from yield farming to protocol economics. The point of the anecdote is the cost: three weeks, one protocol, one question.
In November 2022, after FTX filed, I did a forensic reconstruction of the balance sheet and identified roughly $8 billion in unbacked liabilities. I had already moved assets to self-custody on hardware wallets, so I avoided the 80 percent loss that hit a lot of people around me. The essay I wrote afterward argued that trust must be replaced by code, not by better intermediaries. What made that piece land was not the thesis. It was the arithmetic. The inputs existed. They were concealed. The concealment was the finding.
In May 2024 I spent three weeks mapping the SEC's approval criteria for the spot Ethereum ETF โ fifteen distinct hurdles across market-manipulation safeguards, custody structure, surveillance-sharing agreements, and creation/redemption mechanics. I combined legal-text analysis with on-chain volume data and put the probability of approval by Q3 at 65 percent. The timeline held. The model worked because the input was dense: statute, precedent, filing amendments, order-book depth. Every dimension of that analysis was backed by a document somebody had signed.
Then in January 2026 I led a pilot integrating AI agents with decentralized payment rails. Ten thousand micro-transactions per day, zero human intervention, roughly a 40 percent reduction in friction costs for data access. The architecture question we solved was trustless coordination โ how an agent pays for a resource without a platform in the middle. What we learned about failure modes was less comfortable. Agents fail loudly at the transaction layer: reverts, nonce collisions, gas estimation errors, all of it visible in a block explorer. Agents fail silently at the cognition layer. A revert is a feature. A null is not.
So when I say the diligence layer industrialized, I am describing something I watched happen from the inside. The nine-dimension template โ technical, tokenomics, market, ecosystem positioning, regulatory, team and governance, risk, narrative, supply-chain transmission โ became the de facto schema because funds, DAOs, and exchanges all needed comparable output. Comparability beats correctness in procurement. Once comparability is the requirement, the schema freezes. A frozen schema becomes a checklist. A checklist becomes a form. A form gets filled.
The economics sealed it. A human associate produces one credible report per day on a good day. An agent produces ten thousand. The marginal cost of the ten-thousand-and-first report converges on the price of electricity. Under that cost curve, nobody instruments the sensor, because the sensor belongs to somebody else's budget line. You ship the pipeline first and the data layer never. That is not negligence in the ordinary sense. It is a rational response to a market that pays for throughput and reviews for prose.
Nine Dimensions, One Dataset
The reason all forty-seven fields failed at once is the reason the framework is architecturally wrong, and the failure pattern is the proof.
These nine dimensions are not nine analyses. They are nine projections of a single underlying dataset โ an entity graph that spans on-chain state and off-chain documents. Technical maturity is a projection over commit history, bytecode, test coverage, upgrade authority, and incident logs. Tokenomics is a projection over the vesting contract's storage slots, emission schedule, and treasury addresses. Market structure is a projection over order-book depth, funding rates, and venue concentration. Ecosystem position is a projection over integration manifests and indexer output. Regulatory posture is a projection over jurisdictional filings and legal opinions. Governance health is a projection over proposal history and voter concentration. Risk is a derived view. Narrative is a projection over a social graph. Supply-chain transmission is a projection over a dependency graph.
Nine GROUP BY clauses. One fact table. If the fact table is empty, every view returns empty, and they all return empty simultaneously. That simultaneity is the diagnostic signal, and it is being read as an analytical result.
Real analytical failure is ragged. When I assessed governance risk on protocols in 2020, the data gaps were specific: I could get proposal counts but not delegate intent; I could get voter addresses but not their off-chain commitments; I could get TVL but not the composition of the liquidity behind it. Ragged gaps are what an honest analysis looks like. Uniform null is not analysis at all. It is an empty join.
Here is the part that should worry anyone running one of these pipelines. The framework validated types. Every field was a string. Every string matched its enum. Every table rendered with rows. Schema validation passed cleanly. What the framework did not validate was provenance โ whether a single source document existed anywhere in the process. The pipeline checked the shape of the answer and never checked whether there was a question.
That is the oracle staleness problem wearing a research costume. Any serious price-feed design separates two questions: is this a well-formed number, and is this number fresh. A feed returning zero passes the first test and destroys the protocol on the second. The heartbeat pattern exists precisely because the designers of those systems understood that a type-valid value is not a valid value. Diligence pipelines almost never carry a staleness heartbeat on their own corpus. They should. A report whose inputs are older than the protocol's last upgrade should refuse to render.
The deeper failure is downstream of that. First-stage deconstruction extracted zero information points. Zero. That is not a measurement of the asset. That is a measurement of the fetch layer, and it is a defect report. It means the parser encountered something it could not read: a scanned PDF with no text layer, a JavaScript-rendered page behind a headless-browser wall, a language it did not handle, a paywall, a chart image with the actual numbers baked into pixels. Something in the ingestion path broke.
And the framework's response to "I could not read the source" was to write nine chapters about the asset.
I have run enough post-mortems to recognize this shape. In 2017 the exchange I worked at had a market-data handler that would silently substitute the last known good price when a feed dropped. It never alerted. It never logged. It just kept producing numbers, and the numbers looked exactly like numbers that came from the exchange. The bug survived three audits because audits check the output format, not the provenance of the output. We found it when a trader noticed a spread that should not have existed. The fix was not a better handler. It was a freshness field and an alert on its absence.
Now consider the second-order problem, the one that actually costs money. The four composite scores came back at one star each. In a database, NULL means unknown. Zero means measured and none. Collapsing them is a semantic error, and in financial systems that specific collapse has a history. A lending market whose oracle returns a zero for a missing price will liquidate every position that references it. The protocol does not get destroyed by a market move. It gets destroyed by a type coercion.
NULL to zero is the most expensive type conversion in crypto, and research pipelines perform it by default. One star. Four times. In a dashboard, four one-star ratings are indistinguishable from a verdict. Nobody reading a summary cards view will hover over the field and discover that the underlying value was "we could not determine whether a question existed."
Go dimension by dimension and the absurdity sharpens. The regulatory section listed primary jurisdiction as not available, and then produced a Howey analysis anyway. All four prongs โ investment of money, common enterprise, expectation of profit, reliance on the efforts of others โ returned not available, with a composite of not available. On its face that is correct behavior; you cannot assess securities law without knowing which regulator is asking. But producing a four-prong legal test on top of an absent jurisdiction is not caution. It is the appearance of legal analysis. Anyone who has sat through a real securities review knows the difference between a lawyer saying "we cannot opine" and a form saying "we cannot opine." The first is a professional judgment with a signature on it. The second is a template with a hole in it.
Governance is worse, because governance data almost always exists. A protocol with four hundred on-chain proposals, a published timelock, and a delegation system has a fully queryable governance record. If a framework returns null on governance health for that protocol, it is not facing a data gap. It is facing a query that was never written. Distinguishing "the data does not exist" from "I did not look" is the entire job, and it is the one distinction the template cannot make.
This is where I have to be blunt about the RWA narrative, because it is the clearest victim of the pattern. Three years of tokenizing real-world assets has produced an enormous volume of null reports about real-world assets, and the industry keeps reading those nulls as an implementation problem on the chain side. They are not. The inputs โ legal title, custody arrangements, servicing rights, payment waterfalls, covenant packages โ do not live in a format that any pipeline can read, and they never will, because the institutions that hold them have no incentive to make them machine-readable. Institutions do not need your public chain, and they do not need your research agent. They need a legal opinion and a custodian, and both of those are documents with no API. Every RWA analysis that returns null on the legal dimension is telling you the truth, and the truth is being filed as a placeholder.
What the Null Is Actually Protecting
The obvious reading of all this is that AI is failing at research. That reading is wrong, and it is wrong in a way that lets everyone responsible off the hook.
The framework behaved correctly given its specification. It was told to produce a nine-dimension report. It produced a nine-dimension report. The specification error is human: we asked for a document when we should have asked for a data contract. A document is prose with a cover page. A data contract has preconditions, and its first precondition is that input exists. The correct output of this run was one line โ INPUT EMPTY, REFUSING TO ANALYZE โ and an HTTP 400. Instead the run produced a deliverable, because deliverables are what get bought and what survive a procurement review. Nobody buys a 400 status code.
Now the uncomfortable version. Strip the rhetoric out of a typical sell-side crypto note and you find the same structure: nine sections, no primary data, a price target derived from sentiment, a risk section that lists risks without assigning probabilities, and a disclaimer that retroactively voids everything above it. The agent did not invent the emptiness. It made the emptiness machine-readable. That is progress, and progress is frequently humiliating.
Here is the pragmatism test. What breaks first?
Right now, null reports are read by humans who apply judgment. The human sees forty-seven N/As and either asks the obvious question or quietly sets the document aside. Judgment is the last line of defense, and it is being removed from the loop deliberately, because the entire economic case for automating research is that humans are the bottleneck. The moment agents consume other agents' output โ as input to an allocation model, as a training signal, as a signal in a scoring function โ the null propagates. Inference over empty input, fed back as input, produces a market that moves on nothing. We have already watched smaller versions of this. One mislabeled data point becomes a trend, becomes a narrative, becomes a funding rate, becomes a liquidation cascade. The mechanism does not require bad actors. It requires a pipeline that cannot tell the difference between unknown and zero.
Code is law until the economy breaks it. A research pipeline is a law. This one had no penalty for producing nothing, so it produced nothing at scale, and the nothing was formatted to look like work.
The Input Becomes the Product
In the January 2026 pilot, the failure mode we could not live with was an agent paying for data it had not actually received. The transaction layer was fine โ 10,000 settlements a day, clean finality, no human in the loop. The cognition layer was the problem, because an agent that transacts against a null is worse than an agent that does nothing. So we added a precondition: the agent had to hold an attestation that the input existed and matched a committed hash before it could spend against it. The moment the input had a provenance requirement, we started measuring the input. Not the model. The input.
That is where this goes, and it is not a research-tooling story. It is a data-availability story. Within a few years, "was there an input" will be a consensus question rather than a logging question โ attested corpora, signed payloads, receipts for documents, the same primitives we built for rollup data availability applied to the corpus that agents reason over. The protocols that win the agent economy will not be the ones with the best models. Models are converging. They will be the ones whose nulls are loud, whose schemas reject emptiness, and whose fetch layers carry an economic cost of failure. Decentralization is a governance problem before it is a coding problem, and this is governance: who signs the input, who gets paid for it, and who is liable when it is absent.
So when your analyst โ human or otherwise โ hands you a report with forty-seven empty fields, four one-star ratings, and a glossary of terms it never got to use, the useful question is not what the asset looks like.
The useful question is what happened to the page.