A JSON object landed in my review queue this week. Twenty-seven fields. Every key present. Every value either "N/A" or "insufficient information."
The schema validated. No missing keys, no type errors, no exception thrown. The renderer downstream consumed it happily and emitted nine analytical dimensions, each one empty. Roughly three thousand words of output. Shannon entropy: approximately zero. It parsed perfectly and meant nothing at all.
I have a mental classifier for this failure mode, borrowed from contract work. In 2019 I traced the constant-product invariant in Uniswap v1's eth_to_token_swap_input by hand over three months and found an integer overflow the automated scanners had waved through โ not because they were wrong, but because their parser didn't recognize the function signature and returned an empty result set. The tool reported "no findings." Every word of that report was true. It was answering a different question than the one I was asking.
That gap โ between "no finding" and "no data" โ is the entire ballgame, and almost nothing in this industry's tooling distinguishes between the two.
Context: the pipeline contract.
A standard research pipeline is four stages with four contracts. Ingest and segment the source. Extract claim atoms. Classify those atoms into a fixed dimensional taxonomy. Score each dimension. Each stage hands the next a typed payload, and the type annotations are usually informal โ a JSON blob, a list, a dict โ which is where the discipline quietly evaporates.
The break happens at stage three. If extraction emits an empty list โ because the source text never arrived, because a paste truncated mid-document, because the parser silently failed on an encoding it didn't recognize โ stage four does not crash. It iterates zero times. It emits zero rows. The template then renders the default, and the default is the string "N/A," repeated nine times inside a framework that is structurally indistinguishable from a framework that had something to say.
The default is not the bug. The default is the feature that hides the bug. A crash surfaces in a log. A null pointer pages someone at 3 a.m. Instead the system produced a beautiful, well-formatted, entirely vacuous artifact, and the failure stayed invisible until a human read all of it end to end.
Contrast that with the type discipline a Rust developer takes for granted. A function that cannot produce a value must not return a value of that type. You return Option, and the compiler forces the caller to handle None explicitly. There is no silent coercion, no default zero, no accidental averaging of absence into a result set.
Solidity has no such mercy. Read an uninitialized mapping(address => uint256) slot and the EVM hands you a confident 0. Storage is zeroed at deployment, so the read succeeds, so the contract proceeds. This is the single most productive bug class in the history of on-chain finance: not reverts, not overflows, but polite zeros. A price feed that has never been written returns 0. A latestRoundData() call returns a stale updatedAt alongside a perfectly well-formed answer. Every serious integrator I've audited checks two things โ the timestamp delta against a staleness threshold, and whether the answer is exactly zero โ because zero is a valid price for precisely nothing, and a liquidation engine that trusts it will close every position in the book at a price that does not exist.
Every research stack in this industry is Solidity-shaped, not Rust-shaped. That is the structural observation, and it generalizes well beyond JSON.
Core: null propagation is the real protocol.
Here is the transmission path I care about. The scoring layer, unable to evaluate, assigns the lowest available rating. At this point two consumers diverge. A human reads "one star, cannot be evaluated" and understands the epistemic status. A machine reads {"technical_value": 1} and aggregates it into a mean. The human-facing string and the machine-facing integer were never the same object, and only one of them survived the pipeline.
So the failure isn't that the analysis was empty. The failure is that emptiness was encoded as a number.
This is not a formatting problem. It is a lossy encoding of a three-state system โ true, false, unknown โ into a two-state one. Null coercion is the classic trap, and it is the reason a page full of "not applicable" fields can propagate intact through six systems and arrive at a trading dashboard as a signal.
I keep returning to a data availability analogy I worked through in 2024, when I led analysis of Celestia's sampling mechanism. A light node samples a subset of erasure-coded blobs and receives a probabilistic guarantee that the full data exists and is retrievable. The Reed-Solomon math there is genuinely elegant; I spent weeks chasing a gRPC latency bottleneck in that path and proposed an optimization the team eventually adopted. But the guarantee is precisely scoped. Sampling proves availability. It proves nothing about meaning. You can erasure-code 128 kilobytes of zeros, distribute them across the network, sample them, and obtain a mathematically sound availability proof for a payload of pure nothing.
That is what this JSON is: a data availability proof for an empty blob.
Cryptographic proof systems are the most epistemically disciplined machinery humans have built, and they are disciplined precisely because of what they refuse to do. "Zero-knowledge isn't mathematics wearing a mask." A groth16 proof attests to one relation between public inputs and a private witness, and to nothing else whatsoever. You cannot ask it a question outside the statement and receive an answer.
In 2026 I audited an oracle network feeding AI-generated predictions on-chain. The model was non-deterministic. Consensus nodes could not independently derive the same output, so verification had no pathway that didn't terminate in a trusted third party. The interface had accepted a value it could not check โ and once an interface accepts an unverifiable input, it eventually treats that input as verified. Nine "N/A" fields are the same shape of compromise, one abstraction layer up.
Contrarian: the empty report is the most honest artifact in the stack.
Here is the part that should make people uncomfortable. The vacuous analysis refused to hallucinate. It tagged its own confidence as low. It carried a disclaimer. Compare that to what happens when the same pipeline is asked to be helpful โ when a language model is prompted to fill the nine dimensions from absent source text. It will produce three thousand fluent, well-structured words about a project that may not exist, complete with architecture diagrams and a token distribution table. Bolded insights. Clean subheads. And at a glance it is indistinguishable from a real analysis, because fluency is cheap and epistemics are expensive.
The defect lives on the demand side. Nobody pays for "cannot evaluate." Every dashboard wants a star rating. Ranking bots, indexers, and signal channels consume numbers, not epistemologies. A null that doesn't crash its consumer is a null that gets averaged into a score, and a score is a claim.
Code is law, but bugs are reality. The most expensive bug class in this industry is not the transaction that reverts. It is the function that returns zero politely, and gets integrated by something that never asked whether zero was an answer or an absence.
Takeaway.
Watch for the next generation of null-propagating tooling: research pipelines that carry Option semantics at every boundary, refuse to emit a numeric score without a resolvable citation, and treat missing data as a hard failure rather than a low grade. The question isn't whether this particular report was empty. The question is how many non-empty reports in your feed were built the same way โ schema-valid, fluent, and structurally incapable of being wrong, because they never committed to a claim in the first place.