On a Tuesday morning this spring, a research pipeline I had been asked to review returned a ninety-four-page diligence report on a freshly funded protocol โ every section formatted, every table populated, and every cell in those tables filled with the same three words: N/A โ insufficient information. The crawler upstream had died nine days earlier. Nothing in the report was false. It was the only honest document that team produced all quarter, and it will be the first artifact deleted when the budget review lands. In a market this euphoric, nobody pays for the absence of a conclusion; they pay for the shape of one.
That refusal to fill a void is the rarest primitive we have left, and we have almost no infrastructure to verify it. Absence, too, deserves a signature.
The protocol itself was unremarkable, which is the point. A nine-figure raise โ the kind of number that now arrives before a mainnet โ funded an agentic research layer that promised to compress diligence from weeks into minutes. Its architecture was the standard 2026 stack: ingestion from explorers and RPC endpoints, embedding into a vector store, synthesis by a hosted model, publication through a dashboard. Four stages, four vendors, zero cryptographic commitments between them. Each stage trusted the last one's output the way we once trusted whitepapers.
From the chaos of 2017, we forged a compass. I audited fifteen ICO whitepapers that year as a twenty-one-year-old cryptography candidate at UCL, and the lesson that survived every cycle since was not that founders lied โ most did not โ but that we had no mechanism to distinguish a lie from a copy-paste error, a stale oracle read, or a crawler that had silently stopped responding on a Tuesday. The whitepaper was never the system. We learned that the hard way, twice, and then built an institutional apparatus on the assumption that documents and execution were the same thing.
They are not, and the gap is where this spring's report was born.
Here is the technical core of it. When a pipeline ingests data, the honest primitive is a content-addressed commitment: hash the raw response, sign it, store the CID, and require every downstream stage to reference its parent's hash. This is not exotic; it is how git has worked for two decades. Yet fewer than a third of the research tools I have audited in eighteen months carry any parent-hash linkage, and almost none distinguish, at the schema level, between we fetched this and it was empty, we tried and the endpoint refused, and we never made the request. All three collapse into the same null. A language model downstream cannot tell the difference either, and so it does what such models do under pressure: it produces a plausible shape where a fact should be.
The fix is not better models. It is typed absence โ a schema in which every field carries a provenance state, so that N/A can never again mean four contradictory things at once.
Then comes the cost question, where most well-intentioned designs die. You cannot anchor every ingestion step on-chain, because blockspace is a metered resource with real scarcity โ and that scarcity is about to bite harder than most teams have modeled. Post-Dencun blob capacity has been filling steadily as rollups migrate their data availability, and the arithmetic is unforgiving: within roughly two years, demand will meet the cap, and rollup fees will double again, then again. Any verification architecture that assumes cheap permanent data availability is building on a subsidy, not a protocol.
So verification must be selective. The practical design I now recommend to teams is a three-tier commitment: content hashes for everything, on-chain anchoring only for the artifacts that gate money movement, and a zero-knowledge or TEE attestation for the thing that matters most in an AI-mediated pipeline โ proof that a given output was derived from a specific input by a specific model version. This is the work my team began last year under the Human-Centric AI Ledger banner, and the argument in "The Algorithmic Soul" still holds: if we cannot prove where a machine's conclusion came from, we have not automated diligence; we have automated deference.
What makes the null-input problem worse is that the industry's incentive gradient points the other way. Research is paid for in outputs โ threads, dashboards, conviction โ never in nulls. A team that publishes "we could not verify this" loses the deal to a team that publishes a confident paragraph. Filling voids is profitable; declining to fill them is a cost center. And once a market rewards shape over substance, it will invent reasons for you: notice how "data fragmentation" is now being sold to us as a crisis requiring new tokens and new layers, in the same register as the "liquidity fragmentation" narrative that has circulated for years with nothing behind it. Some fragmentation is real. Much of it is a product pitch wearing a problem's clothes.
The same instinct shows up in blockspace allocation, where we routinely spend the most expensive security budget in the world on the cheapest possible data. Watching ordinal and Rune inscriptions congest Bitcoin is like watching a Rolls-Royce haul gravel: the car is insulted, and the payload is trivial. If we cannot resist filling expensive space with filler, we should not be surprised when our research pipelines fill empty fields with fiction.
Here is the pragmatism test, and it cuts against my own instincts. Demanding full verification of every input is theater โ you cannot cheaply prove a negative, and a system that tries will either bankrupt itself or quietly stop verifying and start asserting. The report I opened with was honest, and useless: it marked N/A against fields that a two-minute call could have settled, and it drew no distinction between what was unknowable and what was merely unfetched. Honesty without granularity is just a different way of failing the reader.
The answer is neither maximal verification nor cheerful assertion. It is a narrower, more human discipline: verify what gates value, sign what you can, and record โ in a ledger people actually read โ who claimed what, and when. Trust is not a metric; it is a memory we share. Our industry has spent a decade building machines that compute, and almost no memory that remembers. Reputation, in the end, is just provenance with a longer retention window.
When the next nine-figure raise lands with a research dashboard attached, ask the only question that matters: if the crawler died on a Tuesday, would anyone in that building know?