On a Tuesday morning, a research pipeline returned HTTP 200. Status: parsed. Fields declared: eleven. Fields populated: zero. The payload was a valid JSON object whose information_points key held [].
The system reported success. Every downstream consumer โ the dashboard, the alerting layer, the analyst who would later screenshot it โ read that as "we have data, it is just thin." Nobody read it as "we have nothing."
This is not an AI problem. It is the oldest problem in the EVM. A call to an address with no code returns (true, 0x). Solidity's low-level call hands you success = true and an empty byte string. The compiler cannot distinguish "the function executed and returned nothing" from "there was never a function." This is why safeTransfer exists. This is why extcodesize checks exist. And this is why, in 2026, we are still writing the same check at a higher layer of abstraction and still forgetting to.
I have spent nine years telling people that the dangerous bugs are the ones that pass the type check. I did not expect to be saying it about a text pipeline.
Context
The industry now runs on automated analysis. Sentiment scrapers feed risk desks. Language models summarize governance proposals before a token holder votes. Autonomous agents โ the class I wrote about in 2025 under the heading of semantic drift โ execute contract interactions based on parsed intent. The volume of machine-generated research entering the market is, by any measure, larger than the volume of human-reviewed research, and the ratio is widening every quarter.
The architecture is almost always identical. Ingest. Parse. Structure. Analyze. Publish. Five stages, each with an implicit type contract passed to the next. The failure surface is not evenly distributed across them. It clusters at the boundary between parse and structure, where a parser can return a well-typed object carrying no semantic content whatsoever.
Consider what the pipeline in question actually emitted. A nine-dimension analytical framework โ technical, tokenomics, market, ecosystem, regulatory, team, risk, narrative, supply chain โ with every cell filled by the string "N/A - insufficient information." Four thousand words. Zero facts. It included a risk matrix in which all six rows read "cannot assess," and a summary table scoring five categories of information value at zero stars out of five. It even assigned itself a confidence level of "none."
Now ask the question the pipeline did not ask: is that document a failure or a success? The schema is intact. The formatting is impeccable. A reader skimming it would see a structured, sober, professionally hedged report. The hedging is what makes it dangerous. "Insufficient information" reads as diligence. It is not diligence. It is the appearance of diligence, which is cheaper to produce and considerably more convincing.
The same defect lives in the agent layer. An autonomous execution agent that parses an ambiguous instruction and acts on it deterministically has not solved the ambiguity โ it has laundered it into a transaction. The parse succeeded. The intent did not. Nobody checks the intent, because the parse returned a green tick.
Core
Let me be precise about the failure taxonomy, because "the AI hallucinated" is the wrong diagnosis and produces the wrong fix.
Failure class one: fabricated content. The model invents facts. This is loud. It produces specific, checkable claims that can be falsified. Expensive, but self-limiting โ someone eventually checks, and the check terminates the argument.
Failure class two: silent success. The model produces a well-formed structure containing no facts. This is quiet. Nothing in it can be falsified, because nothing in it is asserted. It is unfalsifiable by construction, and therefore it survives review. It survives audit. It survives the screenshot.
The second class is strictly more dangerous, and the industry has its priorities inverted. Every safety discussion I attend is about hallucination. Almost none are about the empty payload.
The math is straightforward. Let a pipeline be a function f: Document โ Report. We validate the output with a type predicate T. A well-designed system requires T(f(d)) = valid. But an empty report satisfies every reasonable type predicate. [] is an array. "N/A" is a string. The type system admits the empty case because a type system describes shape, not content. A schema is not a proof. It is a promise about structure, and structure is precisely the thing that survives when content dies.
There is a second-order trap here that almost nobody names. An analysis with no inputs has zero variance. Some scoring systems read zero variance as maximum confidence, because confidence intervals are computed from dispersion and dispersion is absent. The emptiest possible report scores as the most certain. Monotonicity fails in the wrong direction: adding "N/A" cells increases apparent completeness while adding no information, so any metric that rewards coverage rewards padding.
The correct construction requires a second predicate โ a non-emptiness invariant โ enforced before the report enters the publish stage. Not after. Placement matters more than the check itself, because a check after publication is a log entry, not a control.
The pipeline in question got this right, eventually. It validated, found zero information points, and refused to continue. It failed closed.
That is the single most important architectural decision in the entire stack, and it is almost never made deliberately. Fail-open is the default. Fail-open is what you get when the parser throws a warning instead of an exception, when the schema validator logs instead of rejects, when the dashboard renders an empty chart rather than an error state. Fail-open is a design choice made by omission, and omissions are how infrastructure dies.
I have a specific memory here. In 2020, auditing Compound's cToken interest rate model, the interesting edge case was never a bad calculation. It was oracle latency โ the window in which the price feed returns a stale but valid number. The system had no mechanism to distinguish fresh from well-formed. Every downstream consumer treated a stale price as a true price, because the type was correct. The liquidation threshold logic was sound. The assumption was not.
Assumptions are just risks wearing disguises. The assumption in 2020 was that a returned price is a current price. The assumption in 2026 is that a returned report is a report about something. Same bug. Different layer. Fourteen years of distance and the shape is identical.
Now the deeper structural point, the one that makes this more than an anecdote.
The document correctly identified that "unanalyzable" and "low risk" are different states. That distinction is the entire game. It is three-valued logic in a two-valued world. In the EVM, this is the difference between a call that reverts and a call that returns false โ and the reason the distinction matters is that a reverted call propagates automatically, while a false return must be checked by every caller, individually, forever. The first is enforced by the machine. The second is enforced by discipline. Discipline does not scale. This is why the ERC-20 transfer returning bool was a mistake that safeTransfer had to patch, and why tokens returning nothing at all โ USDT among them โ broke every integrator who assumed a boolean was coming.
The empty return is not an edge case. It is the default state of any system that has not been asked to prove anything.
Translate that to the analysis layer. A pipeline emitting "N/A" across nine dimensions has produced a false return. It has not reverted. It has told every downstream consumer, in a perfectly valid format, that there is nothing to check โ and left the checking to them. Most will not check. Most will read "nine dimensions assessed" and file it.
And here is the part that should worry anyone running capital against these systems: the report's own risk assessment concluded that the only confirmable risk was an "information vacuum," and then declined to assign it a rating. Which is technically correct, and which is exactly the failure. An unrated risk is an unhedged risk. The document was honest about its own uselessness in paragraph forty, after thirty-nine paragraphs of formatting that implied otherwise.
Provenance is a story we agree to believe in. So is "the analysis completed."
Contrarian
Here is what the automation bulls get right, and it is more than the skeptics concede.
A machine that fails closed is strictly superior to a human analyst who fails open. I have watched humans do exactly what this pipeline refused to do. Given an empty brief and a deadline, a human will fill the gap with plausible narrative โ a comparable, a precedent, a "sources suggest." The human failure mode is not an empty array. It is a confident paragraph built on nothing, delivered with the cadence of authority. Machines at least have the decency to emit [].
The refusal, in other words, was the correct behavior. The system did the hard thing. It stopped. That deserves stating plainly, because the reflex is to treat any empty output as a pipeline defect when the defect is usually the opposite: a pipeline that would not have stopped.
But I will not let the framing pass unchallenged. The output was still a four-thousand-word document. It consumed a slot in someone's attention. It has a title, a structure, a disclaimer, and a recommended remediation checklist. It is, functionally, a product. And products get screenshotted. A screenshot of nine dimensions with a professional layout communicates competence regardless of what the cells contain. The format itself is the hallucination. Zero knowledge dressed in the clothes of a comprehensive assessment is not honesty โ it is honesty wearing a suit that makes it look like work.
The second thing the bulls get right: this failure was caught. That is not luck. It is architecture. The pipeline had a validation gate at the boundary and the gate held. Most do not. Most pipelines I have reviewed in the past eighteen months have no non-emptiness check at all, because the check is boring, and boring checks lose funding fights to feature work every single quarter.
Takeaway
So here is the metric I would put on every risk desk by end of quarter: silent-failure rate. The fraction of pipeline runs that return a schema-valid, semantically empty result and are not flagged downstream. Measure it before you measure accuracy. Accuracy computed over a corpus you cannot confirm was populated is a number about nothing โ a correlation with an empty set, dressed as signal.
Correlation is the comfort of the unprepared. The exit liquidity is someone else's regret โ and here the exit is a decision made on a report that contained no information, formatted so that nobody noticed. Count how many of those crossed your desk last month. Then count how many you actually caught. The gap between those two numbers is your real risk budget, and almost nobody has written it down.