The 47 Nulls: Why the Most Valuable Output in Crypto Research Is 'Insufficient Information'

Hook

In late March I ran a two-stage analysis pipeline against a document I'd been asked to evaluate. The first stage was a constrained extraction pass: pull the title, the source, the domain tags, the core thesis, the project identifiers, the list of information points, the time-sensitivity rating, the source-quality score. The second stage was a nine-dimension analytical framework — technical, tokenomics, market, ecosystem, regulatory, team and governance, risk, narrative, and supply-chain transmission.

Stage one returned nothing. Not 'unknown,' not 'low confidence.' Empty. The title field was null. The source field was null. The domain tag — the single field that determines whether the entire downstream framework even applies — was never populated. The information-point list was a zero-length array. The core thesis, which every downstream dimension depends on, was three blank strings where a stance, a summary, and a stated purpose should have been.

Stage two, executing correctly against that empty array, produced forty-seven N/A — insufficient information markers, six empty comparison tables, one empty transmission graph, and exactly one sentence that carried signal:

'An analysis that is confident on empty input causes more damage than an analysis that is honest about having no input.'

I have spent nine years reading automated research output, and I have read thousands of pages of it. That sentence is the most important thing an analysis system has said to me this cycle. And it was produced by accident — by a framework that happened to be built with a refusal path instead of a hallucination path.

The industry has spent the last eighteen months optimizing the opposite behavior.

The confidence is the bug. Not the null. The confidence.

Context

The two-stage architecture is now standard across crypto research desks, and it is worth describing precisely because almost nobody describes it precisely. Stage one is a deconstruction pass. It takes unstructured input — a whitepaper, a governance forum post, a funding announcement, a Discord leak, an audit report — and converts it into structured fields. This is a schema-constrained extraction problem. You are not asking the model to think. You are asking it to fill a table: title, source, type, domain, thesis, information points, projects, time sensitivity, source quality.

Stage two is an analysis pass. It takes the structured table and runs a fixed framework over it. Nine dimensions, each with sub-tables, each producing conclusions, evidence, hidden-inference notes, and risk flags. The design intent is clean. Separate the messy work of extraction from the structured work of analysis. If extraction fails, analysis should fail loudly.

In practice, extraction almost never fails loudly. It fails quietly, and that is the entire problem.

Here is the mechanism. When you give a language model a schema with fifteen required fields and hand it a document that does not contain those fields, the model has three possible behaviors:

1. Emit null. Return empty strings, empty arrays, explicit N/A.
2. Emit a refusal. Return an error: 'insufficient input to populate this schema.'
3. Emit a plausible fill. Invent values that satisfy the schema's shape without satisfying its semantics.

Behavior three is what most production pipelines do, because behavior three is what most evaluation harnesses reward. If your scoring function measures 'did the output validate against the JSON schema,' then a fabricated value scores identically to a correct value. The schema validates. The pipeline proceeds. The analysis runs on invented data. And because the analysis framework is designed to produce confident prose — that is literally what it was trained and prompted to do — the invented data gets laundered into confident prose.

The framework I encountered in March did none of this. It emitted null, then propagated the null, then at the final synthesis step refused to synthesize. It output a structured apology instead of a structured conclusion. It ranked its own information value at one star across all four axes: technical, investment, timeliness, reference. It listed its top 'risk' as input data integrity and its top recommendation as re-run stage one and confirm the source document exists and is parseable.

That refusal is not a bug. It is a security property. And it is the rarest thing in the current AI-research stack.

Why does this matter now, specifically? Because the 2025–2026 institutional entry phase has flooded the market with automated research. Every fund, every exchange, every 'AI agent' product now emits structured reports at machine speed. The volume of analysis has gone up by orders of magnitude. The verified volume of analysis has not. We have built an industry that produces confident prose faster than it can produce correct prose, and we have not built the tooling to tell the two apart.

This is the same structural failure I have been tracking at the protocol layer for three years, and it is finally arriving at the application layer where it can do retail-scale damage.

Core: Null Propagation Is a Protocol Problem

Most engineers treat null handling as a code-hygiene issue. Wrap the field in a check, log a warning, move on. That framing is wrong for one specific reason: in an analytical pipeline, null is not a value, it is a claim about the world. When stage one emits domain: null, it is asserting: 'the input document does not establish a domain.' When stage two ignores that assertion and proceeds anyway, it is overriding a claim about the world with a claim about the schema.

This is the same class of error as a cross-chain bridge that trusts a relayer's signature without verifying the source chain's state root. The bridge's contract is well-formed. The relayer returned a signed message. The message validated. The problem is that the message was a claim about a state that never existed. I have watched this failure mode at the cryptographic layer, and the structural similarity to a hallucinated research report is not a metaphor. It is the same bug wearing different clothes.

⚠️ Field note: the reason null-propagation failures are so damaging in analysis is that they are silent at every layer. The schema validates. The logs show no errors. The output is fluent. The only place the failure is visible is in the semantics, and semantics are exactly what nobody has time to check.

Let me make the analogy precise, because precision is the whole point. In a bridge, you have a verification function V(proof, state_root) -> bool. If V is called with a proof for a state root that the destination chain has never seen, and V returns true anyway, you have a soundness failure. The fix is not 'add a null check.' The fix is to make the verification function depend on the existence of the referenced state. In analysis terms: the analysis function must depend on the existence of the information points. It must be structurally incapable of producing a conclusion from an empty array.

Most frameworks are not structurally incapable. They are prompt-instructed to avoid it, which is a completely different and much weaker guarantee.

The Hallucination Gradient

There is a gradient, and it is predictable. Given a fixed schema and a fixed model, the probability of a fabricated fill is a function of how specific the missing field is and how plausible a fill would be.

A missing 'source URL' is rarely fabricated, because fabricated URLs are obviously fake and the model has been punished for them. A missing 'core thesis' is frequently fabricated, because any document has some thesis and the model can always write one that sounds right. A missing 'domain tag' is almost always fabricated, because the schema demands a value from a closed set and the model will happily pick the most statistically likely one.

This is the gradient: the more the schema constrains the answer, and the more plausible the average fill, the more likely the fill is fabricated. The most dangerous field in the whole table is the one with the highest prior. domain: blockchain is a very high-prior fill for any document that mentions tokens, ledgers, or wallets — even when the document is actually about, say, supply-chain logistics for a company that happens to use the word 'chain.'

I have a concrete example from my own work. In 2024, post-ETF approval, I audited the Groth16 verification logic of a privacy-preserving DeFi protocol. The circuit's challenge-generation phase had a soundness error: under specific timing conditions, the same proof could be accepted twice, enabling a form of duplicate spending. The team resisted the finding — production pressure, launch date set, auditors already paid. The output of the circuit looked fine. The proofs verified. Every test passed. The bug lived entirely in the semantics of a field that was structurally allowed to be duplicated.

That is the hallucination gradient in hardware. A circuit that validates against its interface while lying about its state. A research pipeline that validates against its schema while lying about its inputs. Same gradient, different substrate.

Why Verifiable Inference Cannot Save You

The obvious response — and the one every ZK-adjacent team reaches for — is: make the inference verifiable. Prove that the analysis was computed from the declared inputs. Attach a proof to the report. Let the reader verify.

I have to be blunt about this because I have run the numbers. Verifiable inference for language-model research pipelines is economically dead on arrival, and it will stay dead for the foreseeable future.

Here is the arithmetic. A single forward pass through a modern open-weights model — say, a 70B parameter model at 4-bit — costs on the order of 10^11 to 10^12 floating-point operations. Producing a ZK proof of that computation, in the current Groth16 / PLONK family, requires proving a circuit with roughly 10^9 to 10^11 gates depending on the arithmetic encoding. At realistic proving costs on commodity hardware, you are looking at seconds to minutes of proving time per token, and a proving energy budget that exceeds the inference energy budget by three to five orders of magnitude.

My position on ZK Rollup proving costs has been consistent for two years: the proving overhead is already absurd relative to the value it secures, and rollups only survive it because the value being secured is large and the proofs are batched. For AI inference, the value per unit of compute is far lower and the compute is far higher. You cannot batch your way out of a five-order-of-magnitude gap.

So 'verifiable AI research' is not a solution. It is a research program with a known negative result on the economics.

The alternative is not cryptographic verification. It is process transparency. Log the null. Propagate the null. Make the refusal auditable by exposing the exact field that was empty, the exact document span that failed to fill it, and the exact decision point where the framework chose to stop. This is weaker than a proof. It is also deployable this quarter, at near-zero marginal cost, and it captures the vast majority of the actual failure modes.

⚠️ Field note: the industry keeps reaching for cryptographic guarantees for problems that are really logging and discipline problems. A proof that the wrong computation was performed correctly is worse than a log that says the computation was never performed.

The Economics of Refusal

Here is where it gets interesting, and where the March pipeline's behavior stops looking like an accident and starts looking like a design choice with economic consequences.

Producing a refusal is cheaper than producing an analysis. A framework that outputs N/A forty-seven times has done almost no work. A framework that outputs a confident nine-dimension report has done a great deal of work — and, critically, has generated a great deal of output that looks like value.

This creates a perverse incentive. If you are paid per report, per token, per 'insight,' or per engagement, then refusal is a revenue event you are actively avoiding. The market rewards output volume, and output volume is trivially maximized by never refusing. The result is a research economy in which the supply of confident conclusions is structurally decoupled from the supply of valid inputs.

This is a token-emission problem in disguise. I spent part of 2026 dissecting a Layer-2 designed to monetize AI compute, and I found exactly this flaw at the incentive layer: the emission schedule rewarded high-compute nodes regardless of output quality, which meant a Sybil attacker could spin up cheap inference nodes that produced garbage at high volume and farmed emissions. I built an economic model showing the design would hyperinflate within six months. My static prediction was technically accurate; the team then adjusted parameters via governance and partially invalidated it, which taught me that even a correct technical model needs a dynamic behavioral layer.

The same lesson applies here. The reason refusal is rare is not that it is technically hard. It is that the incentive structure of the research market actively punishes it. Any system that refuses to answer is, by construction, producing less 'output' than a system that hallucinates. And in a market that measures output, less output looks like less value.

So the March pipeline's forty-seven nulls are not just a technical artifact. They are an economic anomaly — a system that paid the cost of honesty in a market that prices honesty at zero.

A Field Report from the Circuit Layer

I want to ground this in something concrete, because abstractions are how this problem hides.

In 2020, during DeFi Summer, I spent forty hours auditing the initial implementation of a governance contract that later became famous for a reentrancy patch. I found a subtle integer overflow in the claimReward function that predated the patch. I did not report it immediately. I wrote a custom Echidna fuzzing harness to prove the theoretical bounds of the exploit first, because a vulnerability without a proof is a rumor and a vulnerability with a proof is a fact. The fuzzer found the boundary condition in under an hour. I published the math as a GitHub gist, and the core devs engaged within a day.

The lesson I took from that, and the lesson I keep re-learning, is that high-level abstractions mask fundamental logic errors. The governance contract looked correct at the interface. The overflow lived two layers down, in assembly-level interaction patterns that no reviewer was reading. The only way to find it was to stop reading the abstraction and start reading the machine.

A research pipeline is the same. The interface — the report — looks correct. The failure lives two layers down, in the extraction pass, in the field that was silently filled with a plausible lie. And the only way to find it is to stop reading the report and start reading the inputs.

In late 2022 I went further down. I spent three months reverse-engineering Celestia's Blobstream light-client verification, comparing its security assumptions against Ethereum's blob data availability. I wrote a comparative note arguing that Celestia's trust model was more complex than necessary for simple data posting. My analysis was cryptographically sound. It was also commercially useless, because I had ignored staking economics and adoption incentives entirely. That note is why I now force myself to attach a market layer to every technical claim — not because the market layer changes the cryptography, but because it changes who reads the cryptography.

And in 2025 I analyzed an AI-driven oracle network that used LLMs to validate off-chain data. I found a deterministic failure: when multiple AI agents produced identical but incorrect outputs due to prompt-injection vulnerabilities, the verification layer failed to detect the semantic inconsistency, because it was checking for agreement rather than correctness. I reproduced it on a local inference server. A consensus mechanism that converges on the wrong answer is worse than one that fails to converge, because it produces a signed, confident, wrong result — exactly the failure mode of the March pipeline, but with an economic payload attached.

That is the through-line. The oracle that agreed with itself. The governance contract that validated its interface. The circuit that accepted the same proof twice. The research pipeline that filled its empty fields. They are all the same bug: a system that has confused the validation of its structure with the validation of its content.

Contrarian: The Market for Refusal

Here is the counterintuitive claim, and I will state it flatly because the flatness is the point: the most valuable product in crypto research over the next two years will not be an AI that answers. It will be an AI that refuses.

This sounds like a provocation. It is an arithmetic claim.

Every research desk in this cycle is racing to deploy agents that produce more output, faster, cheaper. The marginal value of the next confident report is approaching zero, because the market is drowning in confident reports. What is scarce — genuinely, structurally scarce — is a trustworthy signal about which reports are grounded. A refusal is exactly that signal. It is a machine-readable, cheap-to-produce, hard-to-fake attestation that the input did not support a conclusion.

The reason this market does not yet exist is that refusal is hard to monetize. Nobody pays for a report that says 'insufficient information.' Nobody screenshots it. Nobody posts it. The refusal has no narrative surface. It is invisible to the incentive layer.

But look at what is actually happening at the institutional edge. The 2025–2026 institutional entry phase has brought allocators into crypto who are legally required to document their due diligence. A fund that cannot show why it concluded something is exposed. A fund that can show 'our pipeline flagged this input as insufficient and refused to analyze it' has a defensible audit trail. Refusal is not a failure of analysis. It is a compliance artifact.

And this is where I have to be careful, because the compliance angle is where the story gets co-opted. The licensing regimes racing to establish themselves as Asia's financial hub — Hong Kong's virtual-asset licensing chief among them — are not building provenance standards. They are positioning for market share. A license that says 'you may operate here' is not the same as a standard that says 'your research is verifiable.' The jurisdictions that win the positioning race will not necessarily be the jurisdictions that solve the provenance problem, and the industry will keep confusing the two.

The same confusion runs through the interoperability layer. Ethereum's Dencun upgrade lowered cross-chain costs between rollups, and the marketing treated that as a UX win. It was not. The cost went down; the verification path got no shorter. Getting a verified data attestation from one rollup to another is still orders of magnitude worse than withdrawing from a centralized exchange, because the exchange is a single trusted counterparty and the rollups are a graph of partial trust. Cheaper messages do not equal verified messages. Cheaper analysis does not equal grounded analysis. Same substitution error, both times.

So the contrarian position is not 'refusal is nice.' It is: refusal is the only output in the current research stack that carries information the market cannot cheaply fabricate. Confidence is free to generate. Grounding is not. And the moment allocators figure out that they are paying for confidence rather than grounding, the pricing inverts.

⚠️ Field note: I have watched three separate teams in the last year build 'AI research agents' that emit confident multi-dimension reports. Not one of them had a refusal path in the schema. Not one. When I asked what happens when the input is empty, every team said some version of 'that doesn't happen.' It happens constantly. They just never see it, because their pipelines fill the gap before anyone reads the field.

Takeaway

The March pipeline did not fail. It reported. It told me, in forty-seven machine-readable lines, that the input did not support a conclusion — and it told me exactly which fields were empty and why. That is a complete, correct, and rare output.

The forward-looking judgment is this: over the next eighteen months, 'refusal engineering' will become a named discipline, and the teams that build it will be the ones that survive the first serious institutional audit of AI-generated research. The mechanism is straightforward. Once a single large allocator gets burned by a confident report built on fabricated inputs — and one will, because the volume of unrefused output guarantees it — the demand for grounded, auditable, refusal-capable pipelines will spike, and the supply will be almost nonexistent, because almost nobody built the refusal path.

If I am right, then the most important line of code in the next generation of research infrastructure is the one that returns null and means it.

The question worth sitting with is not whether your pipeline can produce a nine-dimension report. It is whether it can produce a nine-dimension silence — and whether anyone on your team would notice the difference.