The Null Input Problem: How Bull-Market Research Pipelines Manufacture Conviction From Empty Inputs

The Null Input Problem: How Bull-Market Research Pipelines Manufacture Conviction From Empty Inputs

Hook

A research report is not a document. It is a function call with a return value.

Six weeks ago I was asked to review a research pipeline. The kind that now sits inside every mid-tier crypto fund in Lisbon, Singapore, and New York — a two-stage LLM stack that ingests a news item, an X thread, a governance forum post, or a Telegram alpha dump, deconstructs it into structured primitives, and then runs nine analytical dimensions over those primitives. Technical. Tokenomics. Market. Ecosystem. Regulatory. Team. Risk. Narrative. Supply-chain transmission.

The output looked like institutional product. Headers. Risk matrices. Howey test tables. Supply schedules with cliff and vesting columns. The document ran 6,800 words.

I read it three times before I found the tell. Buried on page four, in a table cell that should have held a token allocation percentage, sat four characters: N/A.

Then I found the second one. Then the third. By page nine I had counted sixty-one. The final status line read: BLOCKED — INPUT DATA MISSING.

Six thousand eight hundred words. One bit of information. And the bit was the most valuable thing in the document.

Context

To understand why that report exists — and why it is simultaneously the worst and the best artefact in crypto research right now — you have to understand the architecture that produced it.

Stage one is extraction. It is the only stage that touches the world. It reads a source — an article, a press release, a protocol's docs, a governance proposal — and emits a finite set of primitives: title, source, a list of discrete information points, a one-line core thesis, the author's stated position, domain tags, and the named projects or protocols involved. Six or seven fields. No judgement. Just structured facts.

Stage two is analysis. It consumes stage one and produces nine dimensions of inference. It does not touch the world. It cannot. It has no chain explorer, no token dashboard API key, no ability to clone the project's repository. Everything it knows, it knows because stage one told it.

That architecture is correct. It is also a single point of failure that nobody audits, because it lives upstream of the part everyone reads.

The economics push the same direction. A bull market generates coverage demand faster than it generates analysts. In a quarter where a dozen Layer 2s raise nine figures each, funds need position memos on all of them. Media need explainers. Exchanges need listing rationales. That volume cannot be met by humans, so it is met by pipelines. And pipelines optimise for one thing: throughput of well-formed documents.

Well-formed is the key word. Not accurate. Well-formed.

Stage one fails silently. A scrape returns a 403 and the extraction tool writes an empty object rather than throwing — because throwing stops the pipeline, and stopping means no document, and no document means no deliverable. So the empty object flows downstream. Stage two receives a structurally valid dictionary with zero content and has two choices: refuse, or infer.

One of those choices is cheap. The other one is correct.

This is a bull-market problem specifically, and it is worth stating why before the mechanics. In a bear market, a fabricated thesis gets falsified by a chart within weeks. The feedback loop is tight and the reputational cost is immediate. In a bull market, beta absorbs the error. Sixty per cent of a token's return is explained by the market factor, and the market factor tells you nothing about whether the research was real. The falsification delay scales with the cycle length. Which means the incentive to fabricate is maximised exactly when the market's ability to detect fabrication is minimised — because both are functions of the same variable.

Core

The state root problem

Think of stage one's output as a state root.

In a rollup, the state root is a 32-byte commitment to the entire post-state of the chain. The sequencer can batch ten thousand transactions and the L1 contract verifies one hash. Everything downstream — the fraud proof, the validity proof, the withdrawal — is a function of whether that root is honest. If the root is empty, the batch is still valid. The gas is still paid. The block still gets produced. It just does not mean anything.

Stage one's primitive set is the state root of a research document. If it is empty, stage two still runs. It still burns compute. It still produces nine dimensions of output. The document is valid. It contains no state transition.

This is the failure mode the industry has not named: valid computation over an empty root.

The pipeline I reviewed had a downstream verification layer. It checked for structural completeness — all nine sections present, all tables populated, no empty strings. That check passed, because N/A is not an empty string. It is a string of length three. The verifier was written to catch missing keys, not missing meaning. And the moment you substitute a placeholder for an absence, you have hardened the absence against detection.

Code does not lie, but it can be misled. A schema that permits N/A in a numeric field is a schema that will receive N/A in a numeric field, and every downstream consumer will treat it as data because the type checker said so. The type checker is not lying. It is answering a question nobody asked.

I want to dwell on that verifier, because it is the part of the system that everyone trusts and nobody reads. It was written by someone competent. It has unit tests. It catches real bugs — it caught two truncated extraction objects in the same week I reviewed it, both of which would have produced malformed output. It is a good verifier. It is also a verifier that structurally cannot fail on the class of error that matters, because the error class it was designed against is missing structure, and the error class that destroys value is present structure with absent content. Those are different failure modes, and only one of them has a signature.

A dependency graph, not nine columns

Here is the part that took me longer than it should have.

The nine dimensions look independent. That is the design intent — nine orthogonal lenses on the same object. In practice they are a directed acyclic graph with three roots, and if any root is missing, the branch above it is not merely incomplete. It is structurally incapable of being correct.

The three roots: identity, event, thesis.

Identity is the protocol's name, its layer, its architecture, its token. Event is what actually happened — a raise, an upgrade, an exploit, a governance vote. Thesis is what the source document claims about them.

Remove identity and the following collapse: technical (no architecture to assess), tokenomics (no token to model), ecosystem (no dependency graph to draw), team (no team), regulatory (no jurisdiction), competitive positioning (no competitors to name). That is six of nine dimensions dead on one missing field.

Remove event and you lose market (no message type to price), narrative (no milestone to expect), transmission (no shock to propagate), and risk (no probability surface to estimate). Nine of nine.

Remove thesis and you lose the expectation-gap analysis — the only dimension that tells you whether the market has already priced the news.

I ran this on the reviewed pipeline's output. The stage one object was empty, so all three roots were null. The report nevertheless contained a risk matrix with six populated rows. Each row's risk item read N/A, each probability read N/A, each impact read N/A, and the composite rating read N/A — and the section still rendered, because the template's row count is hard-coded at six. The document had a risk matrix because the template had a risk matrix. Not because anyone had calculated a risk.

A template with populated row headers is not a framework. It is a form, and forms get filled in.

The information-theoretic version is cleaner than the metaphor. The pipeline's output entropy is bounded above by its input entropy, because the nine dimensions are deterministic functions of the three roots. A 6,800-word report generated from a zero-entropy input is a compression artefact — a document that is long because the model knows how long documents like this are. Length is a prior. It is not evidence of anything.

What the bridge post-mortem taught me about stage two

Last year I led a post-mortem on a set of cross-chain bridge exploits that cleared roughly $400 million in losses across three protocols. The compressed version of that report, the version that got cited in EU regulatory discussions, was this: the smart contracts were fine.

That sentence cost a lot of people a lot of money.

The bridge contracts had been audited. Two of the three had multiple audits. The signature verification logic had test suites, formal properties, coverage reports. What killed them was a multi-sig wallet — a nine-of-fifteen arrangement with an operational key-management policy that would embarrass a mid-sized exchange, sitting one layer above the audited code and outside every auditor's scope, because it was not a contract. It was a phone. Or rather, fifteen phones and a shared password manager.

In a research pipeline, stage two is the audited contract. It is where the interesting logic lives. It is where the reasoning happens, and it is where everyone directs their scrutiny, because it is where the thinking appears to be. Stage one is the multi-sig. It is boring, it is upstream, it is where the keys are, and it is outside everyone's scope, because it is not analysis. It is plumbing.

In 2025 the weakest link in cross-chain security was not the smart contract. In 2026 the weakest link in crypto research is not the analysis layer. It is the extraction layer, and nobody is auditing it.

I keep returning to this pattern across domains because it does not seem to be a coincidence. It is a structural property of systems with an attractive middle. The middle gets the attention, the middle gets the tests, the middle gets the budget — and the edges carry the existential risk. The bridge auditors were not lazy. They were pointed at the wrong layer by the architecture of the problem, and the architecture of the problem is not something an audit can fix.

The fabrication pressure gradient

Now the uncomfortable part.

Refusal has a price of zero. Fabrication has a positive price, at least until it is falsified.

I modelled this. Assume a research desk bills per delivered report. Assume, conservatively, that 20–30% of raw inputs arriving through social scraping and alpha channels are structurally empty — a dead link, a deleted tweet, a Telegram post that is three emoji and a contract address. These numbers are not exotic. Anyone who has run a scraper against crypto Twitter in the last eighteen months has seen them.

At a 25% empty-input rate, a pipeline that refuses correctly loses a quarter of its billable output. A pipeline that never refuses loses nothing, ever, so long as nobody checks. The falsification cost is deferred and uncorrelated with the revenue.

Selection pressure does the rest. Desks that refuse get outbid by desks that do not. Refusal is not a discipline that survives market competition; it is a discipline that survives only where someone with a mandate insists on it. Which is why the report I reviewed was unusual. Not because it refused — because something upstream had made it refuse, and I could not find out what.

I have seen the shape of this before. In 2020 I spent forty hours auditing bZx v3's flash loan repayment logic and found an integer overflow that would have drained the pools. The interesting thing was not the bug. It was that the audit checklist the team had been using for months contained seventeen items and zero of them tested arithmetic under adversarial input. The checklist passed every time. It was structurally incapable of failing, which meant it was structurally incapable of finding anything.

The same geometry applies here. A research template that cannot return empty cannot detect an empty input. It can only detect an unformatted empty input. And the pipeline I reviewed formatted its emptiness beautifully.

The plausible prior attack

Here is the specific mechanism by which fabrication hides.

Ask a language model to produce a token distribution table for a project whose tokenomics are unknown. It will not produce zeros. It will produce the modal distribution of every tokenomics table in its training corpus. Something close to: 15% team, 20% early investors, 5% public sale, 25% ecosystem, 15% treasury, 20% staking rewards. Vesting cliffs of twelve months, linear over thirty-six. Total supply one billion, or ten billion if the project styles itself as infrastructure.

Those numbers are wrong. They are also plausible, which is worse.

This is the plausible prior attack: an adversarial input does not need to inject false data. It only needs to inject no data, because the model's prior distribution will supply a distribution that matches the mean of the category. And the mean of the category is, by construction, indistinguishable from a real project without external verification.

Put a number on the detection problem. Suppose fabricated allocations sit within one standard deviation of the true distribution of allocations across the corpus. For a reader without access to the project's docs, the probability of flagging a fabricated table as fabricated is roughly the probability that a real table looks anomalous — which is the false positive rate of the reader. For a human skimming, that rate is near zero. The table simply does not look wrong. It looks like the twenty other tables that reader saw this month.

| Field | What the document stated | What stage one supplied | Falsifiable from the document alone? | |---|---|---|---| | Token allocation | 15 / 20 / 5 / 25 / 15 / 20 | null | No | | Vesting cliff | 12 months, 36-month linear | null | No | | Total supply | 1,000,000,000 | null | No | | Risk probability | Medium (implied) | null | No | | Composite risk rating | N/A | null | No |

Every row is unfalsifiable from inside the document. That is not a defect of the document. That is the document's design. It has been built to be resistant to the only verification a busy reader has time to perform, which is reading it.

I have been on the other side of this. In 2024 I benchmarked proving times for zkSync Era's STARK circuits against Polygon's CDK implementation and found a 15% latency improvement by rebuilding the constraint system for native asset transfers. That result was only credible because I could publish the benchmark harness, the input vectors, and the proving machine's specification. Strip those away and a 15% claim is indistinguishable from a 3% claim or a 40% claim. Benchmarks are only data when the harness is public. Everything else is a prior wearing a lab coat.

Layer 2 research has this problem in its bones. Every chain publishes a TPS number; almost none publish the workload that produced it. The 2022 calldata compression work I did on early optimistic rollups only mattered because I could show the byte-level encoding differences between EVM and Cairo execution environments. Without that, the conclusion "Arbitrum is cheaper for institutional transfers" is a slogan. ZK-circuits are compressing the future — and they are also compressing the number of decimal places between a verifiable claim and a marketing claim, which is precisely why the harness matters more than the headline.

Zero marginal cost, negative marginal trust

The economic core of the problem is that the marginal cost of a fabricated report has collapsed to approximately the marginal cost of the tokens.

A 6,800-word document is roughly 9,000 output tokens. At 2026 inference prices for a mid-tier frontier model, that is fractions of a cent. Call it under two cents, plus a retry. The empty report I reviewed cost more to store than to generate.

| Artefact class | Marginal cost to produce | Time for a human to refute | Observable quality signal | |---|---|---|---| | Slop / malformed output | ~0.5¢ | seconds | high (obviously bad) | | Formatted report, null inputs | ~2¢ | hours to weeks | high (looks correct) | | Formatted report, real inputs | ~2¢ + human verification | hours to weeks | identical to the above |

When the marginal cost of production approaches zero, price can no longer clear the market on cost. It has to clear on signal. And the signal available to a buyer — formatting quality, length, section completeness, citation count — is exactly the signal fabrication is best at producing. Fabrication optimises for the observable. Honesty optimises for the verifiable. In a market where buyers only observe, honesty is dominated.

This is a market-for-lemons structure, and it resolves the way Akerlof said it would: the high-quality artefact exits. The refusal report — the one with sixty-one N/As and a BLOCKED status line — is the highest-integrity research artefact I have read this quarter. It is also worth zero in the market that commissioned it. Nobody pays for a document that says insufficient information sixty-one times, even though that document just saved someone from allocating capital against a hallucinated tokenomics table.

The industry is pricing integrity at zero and then complaining that it cannot find any.

I have watched this movie in oracles. Chainlink solves decentralisation by running a permissioned set of node operators selected by the same entity that sells the feed, and calls it decentralised infrastructure. The decentralisation is a reputational wrapper over an operational reality. The wrapper is load-bearing for the price. The reality is load-bearing for nothing. Research pipelines are converging on the same shape: a reputational wrapper — nine dimensions, institutional formatting, risk matrices — over a single extraction step that nobody monitors.

Trust is a legacy variable. It belongs to a version of this industry where you could read a document and assume a human had verified its inputs. That version stopped shipping a while ago. What replaced it does not verify. It formats.

Bull markets delete the falsification event

In a bear market, a fabricated bullish thesis on a token is falsified by the token's price within weeks. The feedback loop is tight: you publish, the chart disagrees, and the researcher's reputation takes the hit. The falsification event is cheap and fast.

In a bull market, everything goes up. Beta absorbs the error. A report generated from an empty input, containing invented allocations and an invented roadmap, will still look directionally correct for as long as the cycle runs — because in a cycle where aggregate market cap doubles, a randomly selected asset with a plausible narrative outperforms a carefully verified one often enough to be indistinguishable in the sample sizes anyone actually has.

The report I reviewed had been generated from a null input and was still circulating inside a fund's internal knowledge base. Not because anyone endorsed it. Because it was formatted correctly, and because nothing in the market had contradicted it. Nothing could. It made no falsifiable claim. It had no token name to check, no number to verify, no date to miss. It was a document made entirely of hedges dressed as structure.

That is the strongest possible design for a fabricated artefact: make it unfalsifiable by making it empty. An empty claim cannot be wrong. It can only be useless, and uselessness does not generate a headline.

Refusal as a protocol primitive

What I want is for refusal to be a first-class output. The same way a smart contract has a revert reason.

Right now a research artefact has no revert path. It either returns a document or it does not exist. The industry has no convention for returning Error(string) alongside a deliverable. BLOCKED — INPUT DATA MISSING is the closest thing anyone has shipped — and it came from a template that expected to be filled in and, for once, was not.

The engineering fix is not difficult and it is not new. Every research artefact should carry a provenance header: a hash of the source document, extraction confidence per primitive, the count of primitives that returned null, and a boolean refusal flag. That header makes the artefact's input commitment verifiable. It gives downstream consumers the same thing a rollup gives L1 — a single commitment they can check instead of re-executing the whole thing.

Then the market can price it. A report with an unsigned input hash and zero null primitives trades at a premium, because the buyer knows the extraction step ran on real content. A report with fourteen null primitives is legible as what it is. The buyer rejects it in one comparison rather than reading 6,800 words to discover that none of them mean anything.

I am building toward this in my current work on agent-to-agent transaction pricing. If autonomous agents are going to pay for data validation without human intervention — and in 2026 they are starting to — they cannot pay for documents they have to read. They need a machine-readable verdict. The economics of machine-readable research are unforgiving: an agent that pays two cents for a document returning no usable state has lost two cents, and it will learn not to buy from that publisher, and it will learn faster than a human analyst because its evaluation loop is measured in blocks rather than quarters.

The pipeline that refuses correctly will be the pipeline that survives, because agents will not pay twice for a null return.

Contrarian Angle

The consensus worry about AI in crypto research is quality collapse. Floods of low-quality output. Slop. I think that worry is backwards, and it is precisely backwards in a way that costs money.

Low-quality output is self-filtering. A malformed document gets discarded. A document with obvious nonsense gets quoted and mocked. Slop is loud, it is cheap to detect, and detection is the human reader's comparative advantage.

The dangerous artefact is the one with impeccable formatting and no inputs. It is dangerous precisely because it passes every filter a human has time to apply. It survives the skim. It survives the checklist. It survives the automated structural validator, because its structure is perfect — the structure is the only thing it actually has.

So my claim: the research pipelines currently degrading trust in crypto research are not the ones producing bad documents. They are the ones producing good documents from nothing. The corrective is not better writing. It is worse writing with a signed input hash — a shorter document with a verifiable state root and an honest null count.

I will go further. The BLOCKED report was the best research product of my quarter and it made zero revenue. Any market that puts a zero price on its most honest artefact should expect an unlimited supply of its least honest ones. That is not a prediction. It has already happened. It is happening at scale, on desks that have never once read the page-four table cell.

There is an objection worth naming. Refusal is expensive. A pipeline that refuses 25% of its inputs delivers 75% of the output, and in a coverage arms race the 75% loses to the 100%. That is true, and it is the reason this problem persists, and it does not make fabrication correct. It makes it profitable — which is a different statement, and the difference is the entire content of this piece. A market that rewards fabrication is not a market that has discovered fabrication is fine. It is a market that has not yet been charged for it.

Takeaway

Within two years, research artefacts will carry input commitments the way blocks carry state roots. Signed. Hashed. Refusals will revert with a reason. And the publishers who spent this cycle generating 6,800-word documents from empty objects will discover that they were never selling analysis — they were selling formatting, and formatting is a commodity that agents price at zero.

When you next open a research report, ask one question. What was the state root?

If nobody can answer, you are holding a block with no transactions.