Last month I ran a nine-dimension analytical pipeline against a crypto research input. The output was flawless.
Every field was populated. Every section header was present. Every risk-matrix cell contained the string "insufficient information." The document ran to several thousand words. It had a compliance disclaimer, a confidence-labeling scheme, and a glossary of professional terms. And its total information content was zero bits.
This is not a hypothetical. It is the natural terminal state of a class of systems we have quietly industrialized across the crypto research stack: multi-stage language-model pipelines that convert raw text into structured analysis. When the first stage returns nothing, the second stage does not crash. It formats the nothing. It produces a perfectly well-formed document whose payload is the absence of payload.
I have spent the better part of fifteen years auditing smart contracts, which is to say I have spent fifteen years watching systems behave correctly while producing nothing of value. The empty report is the analysis-layer equivalent of a rollup that posts an empty blob to a data availability layer: structurally valid, economically wasteful, and precisely the sort of thing that looks like success on a dashboard.
What follows is an audit of that failure mode. Not of one pipeline, but of the architectural assumptions that make it inevitable.
Context: The Industrialization of Research
The modern crypto research stack has three stages. Stage one extracts. Stage two analyzes. Stage three distributes. Each stage is a transformation from one representation to another, and each stage assumes the previous stage produced a valid input.
Stage one is the most fragile. It takes a raw article — a news piece, a governance forum post, a whitepaper, a tweet thread — and decomposes it into a list of atomic facts. I call these information points. Each information point is supposed to be independently verifiable: a claim, a number, a named entity, a date. The entire downstream analysis inherits the epistemic status of this list. If the list is empty, the analysis has no ground truth to stand on.
Stage two is the reasoning layer. It takes information points and maps them across fixed analytical dimensions. My own framework uses nine: technical, tokenomics, market, ecosystem niche, regulatory, team and governance, risk, narrative, and supply-chain transmission. The dimensions are rigid by design. Rigidity is a feature when the input is rich, because it forces coverage. Rigidity becomes a liability when the input is empty, because it forces output.
And stage three distributes the result as if it were signal.
Here is the structural problem. A pipeline optimized for coverage will never learn to abstain. Coverage metrics reward a fully populated template. Abstention — returning "I cannot analyze this" — scores as a failure against every coverage metric ever defined. So the pipeline learns, through its reward structure, that the correct behavior under sparse input is to produce a well-formed document describing the sparseness. The document is not wrong. It is worse than wrong. It is valid.
This is the crypto research equivalent of an unintended consequence in protocol design: you optimize for the metric you can measure, and you get the behavior you measured for, not the behavior you wanted.
The temptation, at this point, is to blame the language model. That is a category error. The model is doing exactly what a generative system does under underspecified input: it generates the most probable continuation. Given a template with empty slots and instructions to fill them, the most probable continuation of each slot is a placeholder that satisfies the format. The model is not hallucinating a fact. It is hallucinating structure. And structure is far more dangerous to detect, because structure looks like work.
Core: Anatomy of Formatted Emptiness
To understand why this happens, you have to look at the data path the same way you would look at a settlement path in a smart contract. Trace the state transitions. Find where the invariant breaks.
The Silent-Failure Boundary
Consider stage one as a function. Its contract is:
extract(raw_text) -> list[InformationPoint]Its precondition is that raw_text is non-empty and parseable. Its postcondition is that the returned list is non-empty and each element carries a provenance tag.
What happens when the precondition fails? Three possible behaviors:
- Loud failure — raise an exception, halt the pipeline.
- Silent failure — return an empty list, continue.
- Substituted failure — return a plausible list derived from the schema rather than the text.
The first is safe. The third is a hallucination and is at least auditable, because the fabricated points will not match any source. The second is the dangerous one. It is the failure mode that propagates cleanly through every downstream stage, because an empty list is a valid list. No type error. No exception. The pipeline flows.
I have seen this pattern in on-chain systems more times than I care to count. A price oracle returns zero. The zero is a valid uint256. The lending contract does not revert. It liquidates every position at a price of zero. The failure is not in the oracle. The failure is that the consumer never checked the invariant.
In the analysis pipeline, the invariant is: a downstream reasoning stage must not be permitted to produce dimensional output from a null-dimensional input. That invariant was never asserted. So stage two received an empty list and did what any rigid, coverage-optimized system does: it filled all nine dimensions with the only true statement available, which is that there is nothing to say.
The Density Metric
Here is where I diverge from most people who write about this. The problem is not that the report was empty. The problem is that we have no metric for density.
We measure reports by length, by section count, by dimensional coverage. None of these capture whether the report reduced uncertainty. A 3,000-word document that says "insufficient information" across nine dimensions and a blank page carry identical information. The first one costs more to produce, more to read, and more to mistake for analysis.
Define density as information gain per unit of reader attention. A good report compresses many verifiable claims into a small space. A null report compresses one claim — "we don't know" — into a large space. The ratio is inverted. Formatted emptiness is negative-density output: it costs attention and returns nothing.
If you have ever tried to evaluate a rollup, you have seen this metric. The DA debate is full of protocols that consume an entire blob's worth of availability guarantees to post a few kilobytes of transaction data. The availability cost is fixed. The payload is trivial. The density is near zero. I have argued for two years that the dedicated-DA thesis is overbuilt for exactly this reason: the marginal rollup does not produce enough data to justify the cost of a dedicated availability layer. The same arithmetic applies to research pipelines. A dedicated nine-dimension analytical scaffold is overbuilt for the modal research input, which is two paragraphs of unverified rumor.
The mismatch is the root cause. The scaffold was designed for the dense tail of inputs and is applied to the median input. The output reflects the scaffold, not the input.
Why "N/A" Is the Correct Primitive
Let me defend the empty report, because it is the only part of this story that was done correctly.
Given genuine null input, the correct output is a refusal. "Insufficient information" is not a cop-out. It is the accurate description of the epistemic state. A model that fabricates a plausible-looking tokenomics table for a project it cannot identify is a model that has violated the truth function. The refusal is the integrity-preserving behavior.
In smart contract terms, this is the require() statement. A well-written contract reverts on invalid input rather than proceeding with garbage. We celebrate this. We call it fail-fast. We do not accuse the contract of being unhelpful when it reverts on a bad argument.
The empty report is a revert. It is the pipeline saying: the precondition was not met. The correct engineering response is not to make the revert more verbose. The correct response is to fix the caller.
This is why the "N/A" output is worth studying rather than dismissing. It is a rare, observable instance of a generative system declining to confabulate. Most systems do not decline. They confabulate at the boundary, and the confabulation is invisible because it is embedded in an otherwise-correct document.
The 1% Gap
Here is the finding that actually concerns me.
The fully-empty report is easy to detect. A human reader immediately recognizes that nothing was said. The dangerous case is its complement: a report that is 99% grounded and 1% fabricated, where the 1% is the load-bearing conclusion.
I have audited enough protocol economics to know the shape of this. A tokenomics table where every number is traceable to the docs except the vesting cliff. A risk section where every item is sourced except the one that would have killed the investment. A team section where every founder is verifiable except the one who is a sock puppet. The user of the report cannot distinguish the 99% from the 1%, because both are rendered in the same font, with the same confidence, in the same tidy table.
The empty report is honest about its emptiness. The near-full report is not honest about its gap. Given the choice, I would rather ship a thousand null reports than one report with an undetectable 1% gap, because the null reports are self-labeling and the near-full report is a silent failure that passes every downstream check.
This is the unintended consequence of confidence-labeling schemes done badly. We added "confidence: high/medium/low" tags to our outputs to communicate uncertainty. But confidence tags are compositional, and composition does not preserve honesty. If nine of ten claims are high-confidence and one is fabricated, the fabricated claim inherits the aura of its neighbors. The label was supposed to localize uncertainty. It localized it onto the wrong node.
Orcales and the Grounding Problem
What would fix this at the architectural level?
The core requirement is that every claim in the output carries a verifiable binding to a source span in the input. Not a citation in prose. An actual pointer — a character offset, a hash, a Merkle leaf — that a reader can dereference to confirm that the claim is present in the source.
This is the same primitive as a data-availability commitment. When a rollup posts a blob, it posts a commitment — a Merkle root — and the guarantee is that the underlying data is retrievable. If the data is not retrievable, the commitment is fraud, regardless of how valid the batch header looked.
The analysis equivalent: every sentence in the report should commit to a source span. If a sentence has no valid commitment, it is downgraded to an explicit inference, marked as such, and excluded from any conclusion that depends on ground truth.
I have been building toward this for a year. The verifiable-inference work I shipped last cycle is, at its core, an attempt to make the reasoning trace auditable rather than the output plausible. The trace is the commitment. The output is the batch. You verify the trace, not the output. The output being well-formatted is irrelevant if the trace does not resolve.
The empty report is what you get when the trace is empty and the system, instead of halting, summarizes the emptiness. It is an oracle problem in disguise: the pipeline is an oracle that reports on its own internal state, and it reported in a schema that made a valid-shaped answer indistinguishable from a true-shaped answer.
The Economics of Coverage
The reason pipelines do not implement source-span commitments is the same reason liquidity mining programs do not stop when TVL is organic: the incentive is misaligned with the objective.
Research pipelines are built by teams who are measured on coverage. How many articles processed? How many reports generated? How many dimensions populated? Every one of these metrics rewards the null report, because the null report is a completed unit of work. It fills nine dimensions. It generates a distributable artifact. It scores.
A pipeline that abstains produces nothing measurable. Abstention looks like downtime. So no team instrumented for output volume will ever invest in abstention, regardless of how epistemically correct it is.
This is the same dynamic I documented in DeFi incentive design. A liquidity mining program that measures success in TVL dollars will attract mercenary capital, because mercenary capital is the cheapest way to move the TVL number. The capital leaves the moment the emission stops, and the number reverts. You optimized the metric and you got the metric, and the metric was never the thing you wanted. The teams that survived the last cycle were the ones that stopped measuring TVL and started measuring retained fee-paying users — a metric that mercenary capital cannot fake.
The analysis equivalent is to stop measuring reports-per-day and start measuring information-per-report, verified against source spans. It is harder to instrument. That is why almost no one does it.
A Taxonomy of Empty Outputs
To make this auditable, name the failure modes. I use three.
Type I — Explicit Null. The pipeline correctly identifies null input and refuses to analyze. Output is a structured refusal. Status: correct behavior, poor UX, safe. The report is self-labeling. The reader knows within one paragraph that there is nothing here.
Type II — Substituted Null. The pipeline receives null input and fabricates a full analysis from the schema's priors. Output looks like a report and is entirely ungrounded. Status: hallucination, dangerous, but detectable because no claim resolves to a source span. This is the loud failure.
Type III — Diluted Null. The pipeline receives sparse input and produces a report that is mostly grounded but carries one or more ungrounded claims rendered at the same confidence as the grounded ones. Status: the silent failure. Indistinguishable from a Type I downgrade without trace-level verification.
My pipeline produced a Type I. That is the good outcome. The fact that Type I and Type III are textually similar — both are long, both are formatted, both carry the same section headers — is the design flaw that makes this work urgent. The reader cannot tell a correct refusal from a confident fabrication by looking at the surface, because the surface is generated by the same template in both cases.
Contrarian: The Formatting Is the Bug
Everyone who looks at this problem focuses on the emptiness. I think that is the wrong target.
An empty report is a correct output. The template that rendered it is the actual defect. A system that can produce a flawless nine-dimension structure for null content has been optimized for the wrong objective, and the null report is merely the clearest evidence of a preference that is present in every report it produces.
Consider the near-full report again. It is generated by the same template, through the same coverage-optimized path, with the same reward for filling every dimension. Its 99% is real, and its 1% gap is generated by the identical mechanism that filled the null report with N/A strings. The mechanism did not change. The input changed. The output changed shape but not nature.
This is the unintended consequence of building analytical infrastructure around fixed dimensional scaffolds. The scaffold guarantees coverage. Coverage guarantees that every input, however thin, emerges as a complete-looking document. Completeness is the enemy of calibration. A system that is always complete is a system that is never calibrated to say "less."
The deeper point is about what we actually want from an analysis layer. We do not want coverage. We want reduction of uncertainty under adversarial conditions. Those are different objectives, and they are optimized by different architectures. Coverage is optimized by a template with many slots. Uncertainty reduction is optimized by a system that can abstain, that can commit claims to sources, and that can represent "I do not know" as a first-class output rather than a filled slot.
I have watched the same tension play out across a decade of protocol upgrades, always with the same unintended consequences. Teams add features because features are measurable. They resist abstention because abstention looks like regression. And then the system degrades gracefully into a state where it produces maximal output and minimal signal, and everyone downstream mistakes the output for the signal because it is well-formatted.
Takeaway: Commit, Then Verify
The forward-looking question is not how to fill the empty slots. It is whether we can build analysis layers whose every claim is a committed, dereferenceable pointer to a source span, and whose null outputs are structurally distinct from their full ones.
That is a solvable engineering problem. It requires source-span commitments, confidence tags that do not compose into false authority, and an architecture that treats abstention as a successful output rather than a failed one. The teams that ship this will not look impressive on a coverage dashboard. They will look impressive the moment one of their reports is load-bearing — and holds.
The null blob problem was never about the empty report. It was about the discovery that a system can produce the shape of knowledge without its substance, and that we cannot, at a glance, tell the difference. The next decade of crypto infrastructure will be decided by who builds the tools that resolve that ambiguity, and who keeps shipping documents that hide it behind a perfect template.