The Empty Information Point: Anatomy of a Silent Pipeline Failure

On a Tuesday morning in March, a nine-dimension analysis report arrived in my queue. It ran to roughly four thousand words. It carried tables, a risk matrix, confidence labels, a glossary, and a disclaimer. Every substantive field in it read the same three characters: N/A. Technical positioning: N/A — insufficient information. Token type: N/A. Regulatory posture: N/A. Composite risk rating: N/A. The document was not corrupted. It was not truncated. It parsed cleanly, rendered correctly, and passed every schema check its authors had written. It simply contained nothing. The cause was not subtle once you found it. Stage one of the pipeline — the extraction layer that is supposed to decompose a source text into atomic, checkable facts — had returned an empty list. Zero information points. Stage two, handed a void, did what a well-behaved program does. It propagated the void through every branch, labeled each terminus honestly, and shipped a complete artifact that described nothing at all. I have spent thirteen years reading infrastructure failures. This one is worth writing down, because it is the failure mode that bull markets hide best. Most analysis pipelines in production today are not single programs. They are protocols — a sequence of stages that pass messages under an agreed contract. Stage one ingests raw text and emits structured facts. Stage two consumes those facts and emits judgments. Stage three may consume those judgments and emit positions, alerts, or trades. Each handoff is defined by a schema. The schema says: the output of stage one is an object with a field named information_points, whose type is an array. The schema is precise about shape. It is silent about content. An array with forty well-formed entries and an array with zero entries are, to the schema, the same kind of thing. Both are arrays. Both validate. This is not a design flaw in the schema. It is a property of schemas in general. A type system can tell you that a value is a list. It cannot tell you that the list is worth anything. Reconstructing the protocol from first principles makes the boundary obvious: validation lives at the transport layer, and meaning lives somewhere the transport layer cannot see. The interesting question is not why the extraction stage returned empty. Upstream failures are ordinary — a malformed source, a parsing timeout, a model that declined to commit. The interesting question is why the downstream stages did not stop. There is a reason these pipelines are built to always produce something. The economics of automation reward throughput. A pipeline that halts on ambiguous input is a pipeline that leaves a human with a decision, and a human with a decision is expensive. So the stages are written to be total — to always return, never to refuse. The empty report is what total systems look like when their inputs vanish. They do not fall over. They keep going, and they keep going quietly. Consider the EVM, because the EVM solved this problem decades ago and the solution is instructive. In the EVM, every storage slot has a value. An untouched slot is not undefined; it is zero. A CALL to an address that holds no code does not fail. It returns success. A SLOAD on a slot nobody ever wrote returns zero, and the transaction continues as if zero were a legitimate answer, because within the machine's model it is one. This is not sloppiness. Determinism requires total functions. If the machine had to distinguish "empty" from "zero," every consensus path would fork on the ambiguity. So the machine is total. It answers every question. And the burden of meaning shifts entirely to the caller. The EVM will happily tell you that the balance of a contract is zero. It will not tell you whether the contract exists. Protecting the user means knowing the difference. That is exactly the shape of the pipeline failure I was handed. The extraction stage returned an empty array. The reasoning stage read the array, found no entries, and — because the schema demanded a complete report — emitted the complete report. Every dimension came back filled, and every fill was null. The machine was total. The output was valid. The output was also worthless. There is a name for what the pipeline did, and it comes from distributed systems rather than language models. Null propagation. A null enters at the edge, and because every downstream function is written to be total — to accept whatever it is given — the null flows through every transformation without ever raising. Each stage does its local job correctly. The aggregate result is a report that is formally complete and informationally empty. Shannon gives us the sharper version of the point. Information is the reduction of uncertainty. A message that tells you what you already knew carries zero bits, no matter how long it is, no matter how carefully it is formatted. A field that reads N/A tells you only that the upstream produced nothing — which you could have inferred from the upstream's own empty output. The report added no information. It added structure. Those are different commodities, and only one of them is worth paying for. Here is what a correct trace looks like, reconstructed: stage_one(source) -> [] assert len(points) > 0 // MISSING stage_two([]) -> report(all_fields=N/A) The assertion is the entire fix. One line. It is the line that was never written, because nobody specified what the pipeline should do when the source carried no extractable facts, and the default behavior of a total system is to continue. The deeper issue is that the pipeline had no representation for "I could not do this." It had a representation for "the answer is null," which is a value, and it had a representation for "the answer is X," which is another value. What it lacked was a representation for refusal — for the machine declining to proceed because the preconditions were not met. In the EVM this is the REVERT opcode, and it exists for exactly this reason: to let a computation say "I will not answer" and unwind. Solidity's require() is the same idea wearing friendlier clothes. The most important function in a contract is often the one that stops it. Here is the part that matters. A well-formed output is not a correct output. Structural validity and semantic validity are different properties, and most production systems test only the first. The report I received had a confidence column. It graded its own confidence as "high" on the conclusion that it could not conclude anything. That is, in a narrow sense, correct — high confidence that the input was empty. But a reader skimming the table sees the word "high" next to a verdict and does not parse the qualifier. I have seen this precise pattern before, in code that was not a language model at all. In 2020, working through Curve's stableswap invariant with a small security team, I traced a rounding error in the virtual price calculation. The function did not revert. It returned a number — slightly wrong under high volatility, wrong in a direction that quietly leaked value from liquidity providers to arbitrageurs. There was no exception, no alert, no failed transaction. There was a correct-looking integer. The most expensive bugs are the ones that return a plausible value instead of an error. The Terra collapse in 2022 was the same failure at protocol scale. I spent six weeks reverse-engineering the stabilization mechanism, tracing recursive debt accumulation through the contract calls. The mint-and-burn loop returned success on every iteration. The peg held, on paper, right up until the liquidity assumption underneath it inverted. The system never threw an error. It just ran out of the thing it had assumed was infinite. The ledger remembers what the narrative forgets — and in Terra's case the ledger recorded a long sequence of perfectly valid, perfectly fatal transactions. And in 2024, reviewing the EIP-7702 account abstraction path ahead of Pectra, I found a reentrancy window in the signature validation logic — a state change that could slip through under particular gas pricing conditions. Again: no revert. The validation returned true. The condition was narrow, and we patched the testnet client quietly before mainnet activation, because that is the work. But the lesson repeats. Validation returning true is not the same as validation being sound. Now bring it back to the empty report. The pipeline's downstream stages treated "no information points" as a content problem rather than a control-flow problem. A human analyst handed a blank source document would not produce a nine-dimension report. They would stop and ask for the source. The machine did not stop, because nobody had told it that an empty input is a reason to halt rather than a value to process. The schema said the field was an array. The array was empty. The machine proceeded. The fix is not exotic. It is a guard clause: if the information-point count is zero, raise. Fail loudly, upstream, where a human can see it. This is the difference between a system that is total and a system that is honest. The EVM must be total. A reporting pipeline does not have to be. When you have the freedom to revert, taking it is a discipline. Here is where I part company with most of the commentary I read on this class of bug. The industry is obsessed with hallucination. Every conference talk is about the model inventing facts, confabulating citations, asserting things that are not true. That fear is real, but it is the loud failure. The quiet failure — the one the empty report illustrates — is vacuous compliance: an output that satisfies every formal constraint while carrying no information whatsoever. It is harder to catch because it never lies. It never contradicts itself. It passes every test you wrote, because you wrote your tests against the schema, and the schema is a description of shape, not of truth. Vacuous compliance is everywhere once you start looking for it. It is an audit report that passes because the auditor tested nothing and wrote down that nothing was found. It is a governance proposal that reaches quorum with forty wallets and zero deliberation — the vote is valid, the signal is empty. It is an oracle that publishes a price that is signed, fresh-looking, and three hours stale, because the feed's schema had no field for staleness and the consumer's schema had no field for doubt. In each case the artifact is well-formed, the process reports success, and the information content is zero. The empty report was, in an odd way, the honest one. It refused to invent. A less careful pipeline — and most production pipelines are less careful — would have been handed the same empty array and would have filled the nine dimensions anyway, because the model's strongest prior is to complete patterns. It would have written a confident technical assessment of a project it had never read. The dangerous output is not the one that says N/A. It is the one that says "promising" when the input was blank. The report that admits its emptiness is the safe one. The report that hides it is the weapon. The next generation of these systems will not have a human in the loop. I ran a pilot in 2026 integrating AI agents with ZK-proof verification for autonomous transactions — ten thousand signed, circuit-verified operations, zero failures. The whole point of the cryptography was that a verifier downstream could check the work without trusting the agent. But a proof of execution is not a proof of meaning. You can prove that a pipeline ran and produced a signed output. You cannot, with the tools we ship today, prove that the output contains information. That is the primitive we are missing. Not faster models, not larger contexts — an information-content proof. A way for a downstream consumer to ask not "was this signed?" but "does this say anything?" Until we have it, every schema in production is a promise about shape, and shape is the easiest thing in the world to fake. Stability is not a feature; it is a discipline — and the discipline here is knowing when to revert.