Last month I ran a controlled experiment that I did not expect to work. I fed a crypto research agent a deliberately empty payload โ no title, no source, no information points, nothing but a schema full of null fields. It returned three thousand words. The prose was clean. The structure was flawless. There were risk matrices, a Howey analysis, a tokenomics table, a governance score, even a disclaimer at the end. Every claim in it was fabricated, and none of it was flagged as such. The agent did not fail. It failed silently, which is worse.
I have spent enough time inside systems to know that silent failure is the expensive kind. Loud failure tells you where the boundary is. Silent failure hides the boundary and lets you walk straight past it. This is the empty-input problem, and it has become the dominant failure mode of crypto's fastest-growing content layer โ the automated research pipeline that produces the protocol analyses, tokenomics breakdowns, and risk scores that now fill our feeds. In a sideways market, where every participant is hunting for the one signal that separates the next Layer 2 from the last one, we have quietly outsourced the generation of that signal to systems that cannot distinguish "no data" from "data that says nothing."
The distinction matters more than any of us want to admit. So let me do something specific. Not relitigate whether AI can write โ it can, that question is closed. Instead, I want to trace the exact mechanism by which an empty input becomes a confident output, and then map that mechanism onto systems we already know how to reason about: consensus, state transitions, data availability, proofs. Because the empty-input problem is not really an AI problem. It is a determinism problem wearing an AI costume.
The pipeline nobody audits
Walk the architecture. A modern crypto research agent is a five-stage pipeline, and four of the five stages are deterministic. Ingestion pulls bytes from RSS feeds, on-chain indexers, governance forums, and price APIs. Parsing extracts entities โ protocols, tokens, wallets, events, timestamps. Retrieval embeds the parsed text and queries a vector store for the context that will ground the final answer. Inference runs a language model over that retrieved context. Generation writes the output and hands it to a distribution layer.
Trace where an empty input goes. Ingestion returns nothing, because there is nothing to return. Parsing returns an empty entity set. Retrieval queries the vector store and gets back an empty set of documents, because you cannot retrieve context for a query with no content. Every one of these stages behaves correctly. None of them raises an exception. The failure lives in the fourth stage, inference, and it is not a failure of execution. It is a failure of refusal. When retrieval returns nothing, the model does not halt. It samples from its prior โ the compressed residue of every crypto article, whitepaper, and thread it was trained on โ and produces text that is statistically indistinguishable from a grounded analysis. The output is not random noise. It is the mode of the training distribution, which is exactly why it reads as authoritative.
I have seen this shape of failure before, in a different guise. In 2021 I spent six weeks tracing the composability between Lido's stETH and Aave's lending markets. The finding that stuck with me was not about the yield curve. It was the discovery that a system can be fully operational โ prices updating, liquidations executing, dashboards green โ while resting on an assumption that no participant had actually audited. Liquid staking derivatives looked permissionless. The permissionlessness was borrowed, not owned, because the node operators held a censorship lever nobody had priced. The empty-input problem is the same shape in a new domain. The output looks researched. The research is borrowed from a prior, and the prior has no source.
The market context sharpens the stakes. We are in consolidation. Volume is thin, narratives are exhausted, and the marginal reader is desperate for a differentiated take. That desperation is itself a market signal: it tells every content pipeline that output will be rewarded regardless of input. When demand for signal exceeds the supply of real signal, the gap does not stay empty. It fills with the cheapest available substitute, and today the cheapest available substitute is fluent fabrication.
Why the mechanism cannot self-correct
Be precise about why the failure is structural and not incidental.
A language model is a conditional probability distribution over token sequences. Given a prompt, it produces the most probable continuation under its training distribution. When the prompt is empty, the most probable continuation is not "insufficient data." It is the weighted average of everything the model has ever read. For a crypto-trained model, that average is a confident, well-structured analysis of a generic protocol. The output is not a bug in the sampler. It is the mathematically correct output of the function. That is precisely what makes it dangerous: the mode of a well-trained prior is fluent, plausible, and entirely ungrounded.
I built a minimal version of this reasoning in Rust two years ago, while studying the groth16 proving system and the computational cost of elliptic curve pairings. The lesson I carried out of that exercise had nothing to do with pairings. It was about the difference between a proof and an assertion. A zk-SNARK is valuable precisely because it refuses to be satisfied by anything short of a valid witness. There is no "close enough," no partial credit, no fluent-sounding substitute. The verifier either accepts a proof that a specific computation was executed on specific inputs, or it rejects. The language model has no such verifier. It accepts an empty witness and returns a proof anyway, because the two operations โ proving and asserting โ look identical from the outside.
This is where the blockchain analogy earns its keep. A blockchain state transition is deterministic: given the same state and the same transaction, every honest node computes the same result. Consensus is not agreement in the social sense. Consensus is reproducibility. If two nodes disagree, one of them is wrong, and the network can prove which by re-executing and comparing state roots. Language-model inference has none of these properties. It is non-deterministic across sampling temperature, across floating-point non-associativity, across hardware differences. Run the same prompt twice and you get two different articles. There is no state root to compare. There is no way for a second node to say "I computed a different answer, and here is the proof that yours is invalid." The system has outputs but no verdicts.
I flagged this in 2026, when I audited an oracle network that claimed to feed AI-generated predictions on-chain. The claim collapsed under its own weight. To put a model's output on-chain, you need every validator to reach the same conclusion about a non-deterministic function. You cannot, not without a trusted third party. So the project faced a fork: either run the model once off-chain and let a privileged signer attest the result, which reintroduces the exact centralization the chain was built to remove; or invent a new consensus layer for probabilistic verification, which nobody had and nobody was paying for. The project had chosen the first path and described it as the second. The empty-input problem is the same bug in the content layer. The pipeline hides a trusted step โ the model's prior โ behind the appearance of a deterministic process, and the appearance is all most readers ever see.
The trade-off matrix, where theory meets its latency
I prefer to work in trade-offs, because a trade-off matrix forces an abstraction to meet its constraints. Here is the matrix for verifying model output, framed the same way we would frame any consensus design.
| Verification approach | Trust assumption | Latency | Cost | Output fidelity | |---|---|---|---|---| | Full zkML (proof of inference) | Cryptographic | Very high | Very high | Exact | | Optimistic ML (dispute window) | 1-of-N honest | Medium | Medium | Exact after challenge | | TEE attestation | Hardware vendor | Low | Low | High, not provable | | Stake-based sampling | Economic | Low | Low | Probabilistic |
The pattern is familiar from every scaling debate we have already had. Full verification is the theoretical maximum and the practical minimum โ almost nobody ships it, because the latency is measured in minutes per inference and the cost in dollars per token. Optimistic verification is the honest compromise: publish the output, open a challenge window, slash the liar who cannot defend it. TEE attestation is what most teams actually deploy, because it is fast and cheap and the trust assumption is buried in a vendor datasheet. Stake-based sampling is the Celestia approach applied to truth โ you do not check everything, you check enough that lying becomes unprofitable.
I lived inside that last row for most of 2024, analyzing Celestia's data availability sampling. The insight of DAS is elegant: you do not need to download every blob to be confident the data is available. You sample a subset, and the two-dimensional Reed-Solomon erasure coding guarantees that if any required sample is missing, the whole dataset is unavailable โ the absence of a single shard is detectable from a handful of random queries. The security is probabilistic and it is sound. But I also found a latency bottleneck in the gRPC layer that no amount of sampling theory could fix. The math said "fast." The implementation said "wait." That gap between theoretical maximum and practical constraint is the entire story of modular infrastructure, and it is the entire story of AI verification as well. The trade-off matrix is where theory goes to meet its own latency.
Apply the matrix to the empty-input failure and the diagnosis sharpens. The pipeline has no verification stage at all. It never checks that the output's information content is bounded by the input's. If the input is empty, the output should be empty โ that is an invariant as clean as k = xยทy in a Uniswap v1 pool. Break the invariant and the pool drains. Break the information invariant and the reader is drained instead. In the Uniswap case, I found an integer overflow in eth_to_token_swap_input that automated tools missed because they tested behavior and not invariants. The research pipeline has the same blind spot. Its unit tests check that the pipeline produces a report. They never check that the report's claims trace back to a source. There is no assertion that fires when information is created from nothing, and so nothing fires.
And information does not stay created in one place. It propagates. This is the composability risk I wrote about in 2021, reincarnated in a new medium. In the Lido analysis, the danger was that a single assumption โ that stETH would always redeem near par โ was composable into a hundred other positions, so a local failure became a systemic one. Hallucinated research composifies the same way. One fabricated report gets scraped by a second agent, embedded, and retrieved as context by a third. Within a few hops, the fabrication has become a citation. The provenance is gone, the confidence is intact, and no downstream system can tell that the root of the tree is a null field. We built an information contagion vector and gave it an API.
The market does not want the empty answer
Here is the part that makes engineers uncomfortable, because it is not a bug in the code. It is a bug in the incentives, and the incentives are load-bearing.
I ran that empty-input experiment as a provocation, and the result should not have surprised me. The honest output of an empty input is "N/A." Insufficient data. Come back with a title, a source, an information point โ anything. That is the correct answer, and it is precisely the answer the system is structurally discouraged from giving, because the economics are asymmetric. A pipeline that emits a confident report โ even a wrong one โ captures attention, engagement, and the compounding trust of a reader who has not yet checked. A pipeline that emits "N/A" captures nothing. It looks broken. It gets replaced by a competitor that will happily fill the void.
So the market selects for hallucination. Not because anyone wants to be lied to, but because the alternative โ silence โ is punished. This is the same dynamic that kept the real-world-asset narrative alive for three years past its evidence. The story was always that institutions would bring their assets on-chain. The reality was that the institutions holding real assets did not need a public chain to settle them; they needed a database with better uptime and a compliance team. But "institutions don't need your chain" is an "N/A" answer, and "N/A" does not raise a fund. So the narrative kept being generated, year after year, fluent and confident and ungrounded. Code is law, but bugs are reality โ and the most expensive bugs are the ones the market pays for.
The same logic explains why the AI-analytics layer will not fix itself. Every participant who could build a verifier is competing with participants who are not. The unverified pipeline ships faster, costs less, and produces more content. Verification is a cost center in a market that rewards volume. Unless the reader can tell the difference โ unless grounded analysis is legible as grounded, at a glance, without doing the work โ the empty-input problem is not a defect to be patched. It is the equilibrium. The rational move for any single actor is to keep hallucinating, which is the textbook definition of a collective-action failure.
This is where the crypto analogy turns uncomfortable. We spent a decade building verifiability into money, and we are now spending the next one building unverifiability into the systems that tell us what to do with it. The irony is exact. Zero-knowledge isn't mathematics wearing a mask โ it is the discipline of proving without revealing, of making a claim and handing over the machinery to check it. The analytics layer does the inverse. It reveals without proving. It shows you a conclusion and hides the entire chain of reasoning that would let you falsify it.
The canary, not the coal mine
Watch the empty-input failure, because it is the canary, not the coal mine. The systems that will matter in the next cycle are the ones that can refuse. A research pipeline that halts on empty input, that returns a typed "insufficient data" and a null instead of three thousand words, is worth more than a hundred that produce fluent fiction โ not because it is more useful today, but because it is the only kind that can be trusted tomorrow, when the same architecture gets pointed at capital allocation instead of content.
The forward bet is narrow and specific. Probabilistic verification layers โ optimistic ML with real slashing, stake-weighted sampling of inference, ZK-AI bridges that prove a specific model ran on a specific input โ are the only credible path from "the AI told me" to "the AI proved it." Everything else is a trusted party with better branding. The question is not whether the model can write. It can. The question is whether, when the input is empty, it will have the discipline to say so. Right now, almost nothing does.