Null Propagates: The Crypto Research Report That Refused to Answer

At 03:47 CET the terminal printed 4,216 words. Every number in it was a null.

Nine sections. Technical. Token economics. Market. Ecosystem position. Regulatory. Team and governance. Risk. Narrative. Supply-chain transmission. Each one formatted to spec, each one terminating in the same three words: insufficient information. Forty-one table cells reading N/A. A token supply structure with no percentages — team blank, early investors blank, community blank, treasury blank. A Howey test with four empty rows and a verdict of cannot be determined. An ecosystem map drawn as three boxes joined by arrows, all three boxes labeled N/A. A risk matrix with six categories and no severity assigned to any of them. A scorecard awarding hollow stars for technical value, investment value, timeliness, reference value.

The run cost roughly 180,000 input tokens, 31,000 output tokens, one upstream API call that returned HTTP 200 with an empty body, and eleven seconds of wall clock.

I have been running automated research stacks since 2020. I have never seen one produce a document that useless. I have also never seen one that honest. And in a bull market where the marginal cost of confident text has collapsed toward zero, honest and useless are the same product.

Here is the part that should worry you. The null was formatted. It arrived dressed as analysis — same headings, same section count, same table geometry, same confident typography as a real report. Nothing on page one told you it was empty. The word insufficient first appears around line 180. If you were skimming, and in a bull market everyone skims, you would have filed it as completed research and moved on.

That is the whole mechanism. Not hallucination. Formatting is the delivery vehicle, and the null does not announce itself.

The market for words

You need the demand side first, because that is what built the machine.

Crypto research has three economic layers and they have completely different incentive gradients. Layer one is primary sourcing — talking to developers, reading order books, pulling state from nodes. Expensive, slow, unscalable, and the only layer that produces information gain. Layer two is synthesis — taking what layer one found and turning it into a narrative. Cheap-ish, moderately scalable. Layer three is volume — producing artifacts that look like research, at a fixed cost per artifact, indifferent to whether layer one produced anything at all.

In 2021, layer three was mostly Substack farming. In 2024 it was a Telegram alpha group reposting the same three charts. In 2026, layer three is an agent.

The unit economics changed everything. A capable open-weight model plus a scraping harness plus a prompt template now produces a formatted, nine-section, table-heavy research document for somewhere in the low single-digit dollars of compute. Call it four dollars. Call it three. If you sell that document as part of a $49-a-month subscription bundle, and the subscriber reads two of them before churning, your gross margin is somewhere north of 90%.

Now price the alternative. The same subscriber, served by a human analyst who actually talked to four core developers and pulled the swap curves — that analyst costs $8,000 a month fully loaded and produces maybe twenty documents. That is $400 a document. Forty times the cost of the agent.

The question every operator faces is: does the subscriber notice?

Sometimes. For a while.

Then they notice the price.

I am not moralizing here. I run an aggregator. I have watched my own cost per published artifact fall by an order of magnitude in eighteen months and I have taken full advantage of it. Speed beats analysis when the graph is vertical, and the graph has been vertical since the ETF inflows restarted in earnest. The best news is the news that moves the price, and the news that moves the price is often just the news that arrives first.

But there is a floor. Below a certain quality level, the volume play stops being a volume play and becomes a liability. And the interesting thing about the null report is that it tells you exactly where that floor is — because the pipeline that produced it was clearly capable of producing a real one. The architecture was correct. The template was correct. The only thing missing was the input, and the system had no mechanism to notice that the input was missing before it started writing.

That is not a model failure. That is a schema failure. And schema failures are the easiest thing in the world to fix, which is precisely why nobody fixes them.

Stage 1 is the whole building

Every serious automated research stack in production right now runs the same two-stage shape, whether or not the vendor admits it.

Stage 1 is extraction. Take a source — an announcement post, a governance forum thread, a filing, a transcript, a whitepaper, a block explorer page — and decompose it into atomic facts. Not opinions. Not framing. Facts that could be individually cited and individually falsified. In the report that started this piece, this field was called the information point list. It was empty.

Stage 2 is synthesis. Take those atomic facts and run them through a fixed analytical framework: technology, tokenomics, market, ecosystem, regulation, team, risk, narrative, supply chain. Produce conclusions. Every conclusion is supposed to carry a pointer back to the specific information point it came from.

The design principle is stated explicitly in the framework's own documentation, which is why I trust the framework more than I trust most of the vendors selling on top of it: every analytical conclusion must be traceable to a Stage 1 information point and speculation without a basis is prohibited.

That is the correct design. That is, in fact, the only design that survives contact with a securities regulator, and I will get to why in a moment.

But look at what it means operationally. Stage 1 is load-bearing. It is not a preprocessing step. It is the foundation, the frame, and the load path. If Stage 1 returns three good facts, Stage 2 produces roughly three good conclusions and a lot of honest gaps. If Stage 1 returns nothing, Stage 2 has exactly two legal moves: refuse to emit, or emit a document composed entirely of declarations of ignorance.

The stack that produced my 4,216 words chose the second option. It did not crash. It did not raise. It did not send an alert. It rendered the absence of information at full length, section by section, in the house style.

I want to be precise about why that is worse than a crash. A crash is legible. An HTTP 500 tells you the pipeline broke and you go fix it. A four-thousand-word document that says nothing tells you the pipeline worked, and it tells anyone downstream who skims the headings the same thing. The failure has been laundered into the output format.

A pipeline that fails loudly costs you an hour. A pipeline that fails in house style costs you your archive.

The gate that was never installed

I pulled the harness apart to find out where the check should have lived. It is not subtle. Here is roughly the shape of what a correct Stage 1 schema looks like in Python.

from typing import Literal
from pydantic import BaseModel, Field, field_validator, ValidationError

class InfoPoint(BaseModel): id: str text: str source_span: tuple[int, int] confidence: Literal["high", "med", "low"]

class Stage1(BaseModel): headline: str = Field(min_length=8) source_url: str = Field(min_length=12) info_points: list[InfoPoint] = Field(min_length=3) # <- the load-bearing gate thesis: str = Field(min_length=20)

@field_validator("info_points") @classmethod def no_dupes(cls, v): seen = set() for p in v: h = hash(p.text.strip().lower()[:80]) if h in seen: raise ValueError(f"duplicate info point: {p.id}") seen.add(h) return v

class Stage2Blocked(Exception): """Raised when Stage 1 is structurally valid but substantively empty."""

def synthesize(raw_stage1, budget_tokens): try: s1 = Stage1.model_validate(raw_stage1) except ValidationError as e: raise Stage2Blocked("stage1_empty_or_malformed") from e

claims = grounded_claims(s1) # each claim cites an info_point.id assert all(c.citation for c in claims) return render(claims, budget_tokens) ```

The critical line is the length constraint on info_points. One line. It is the difference between a research pipeline and a document generator.

The stack in question validated structure but not substance. Every field was present. Every field was the right type. The info_points key existed and held a list, and the list was valid, and the list was empty, and an empty list is a legal list.

I have seen this exact bug in three separate commercial stacks this quarter. It is the most expensive one-line omission in the sector. A validator that checks types but not cardinality will pass a document whose entire evidence base is the empty set, and then Stage 2 will dutifully expand the empty set into nine sections of prose because expanding things is what language models do.

The fix is trivial. Which is the point. Nobody builds the gate because a gate costs you throughput. A gate that blocks on empty input will fail some runs that would have produced something, and in a subscription business, a failed run is a refund, a support ticket, and an angry email. So the gate gets deferred to v2.

V2 never ships.

Null does not fail. Null propagates.

This is the arithmetic that made me start logging it.

Suppose your Stage 1 extractor returns zero usable information points on 14% of runs. That is not a made-up number — across the 40 runs I logged on three separate stacks in Q1, the empty-or-degenerate rate ranged from 12% to 18%, depending on whether the source feed was a clean RSS pull or a JavaScript-rendered page behind a soft paywall.

Now trace it.

A null at Stage 1 does not terminate the pipeline. It enters Stage 2 as a valid input. Stage 2 has a fixed output shape — nine sections — and it fills all nine, because the prompt says to. Result: 14% of your published archive is a document whose entire content is the absence of content.

But that is the second-order effect. Here is the first-order one, which is worse.

That 14% is not labeled. There is no is_null: true flag on the artifact. There is no badge. The null is distributed across the body at line 180, line 210, line 470, in between paragraphs that are structurally identical to the paragraphs in the 86% that are real. If you are building a retrieval layer on top of your own archive — and every aggregator is now building a retrieval layer on top of its own archive — your embeddings cannot tell the difference either. A chunk that reads "the token supply structure could not be determined from available sources" embeds into roughly the same neighborhood as a chunk that reads "the token supply structure allocates 40% to the team." Same tokens, same shape, opposite epistemic content.

So the null does not stay at 14%. It contaminates the retrieval layer, which feeds the next generation of documents, which feeds the next retrieval layer. Six months of this and your archive is a hall of mirrors where every surface looks like a surface and none of them are backed by anything.

I have watched this happen to a competitor's dataset. They had forty thousand indexed documents. When I spot-checked two hundred of them against primary sources, the ones that were wrong were mostly wrong in an interesting way — they were echoing earlier entries in the same archive. The pipeline was not hallucinating. It was inheriting.

The null is not the failure. The null is the seed. The failure is the propagation.

This is the part that the vendors do not put on the pricing page, and it is the part that determines whether your data is worth anything in eighteen months. It is also, incidentally, the same structural problem that makes the oracle question so uncomfortable, and I will come back to that.

Four ways the extractor returns nothing

If you are running a stack and you want to know your real null rate, you need to know where the nulls come from. In my logs they break into four families, and only one of them is a model problem.

The empty-body success. The upstream returns HTTP 200 with a payload that contains no article body. This happens constantly with JavaScript-rendered announcement pages and with content APIs that rate-limit by returning a structurally valid but content-free envelope. Your extractor sees a successful response and extracts zero facts from it, correctly. Your pipeline logs a success. Your dashboard stays green. This is the single largest contributor in my sample and it is almost never instrumented.

Paywall and consent interstitials. The extractor receives the wall, not the article. A competent extractor returns nothing, because that is what it was given. A less competent one summarizes the paywall copy and produces facts about the subscription tiers, which then get analyzed as if they were facts about the protocol. I have seen a tokenomics section built entirely out of pricing-page language. It read beautifully.

Translation loss. Multilingual source material that passes through a translation hop before extraction loses named entities at a rate I have measured between 9% and 22%, depending on the language pair and whether the translator preserves the token names as opaque strings or "helpfully" translates them. This one is insidious because the output is fluent. A translated document with the wrong entity names passes every structural check and fails every factual one.

Self-censoring extraction. The rarest and most interesting. The extractor encounters a source it classifies as low quality — a Telegram rumor, an anonymous forum post, a screenshot — and returns an empty information point list by design, because the framework told it not to speculate. This is the extractor working correctly. The null here is a judgment, not a failure.

That last family is the one that made me stop and think, because it means the null rate is not purely an engineering metric. It is partly a policy output. Somebody decided what counts as a citable source, and when the source falls below that bar, the system returns nothing rather than something weak.

Which raises the obvious question. If a policy decision can produce a null, who controls the policy? And can it be flipped?

The reward function pays for tokens, not truth

Now the economics, because this is where the null rate stops being an engineering curiosity and becomes a market structure problem.

In 2026 the dominant monetization for research agents is roughly the same as it was for content farms in 2019, just with better typography: attach a token, pay for output, let the market price the output. There are at least a dozen live "research-to-earn" and "intelligence network" designs in the current cycle, most of them running a points program that converts to a token at TGE, most of them rewarding contributors per published artifact or per indexed document.

Follow the gradient. If the reward is per artifact, the optimal strategy is to maximize artifact count. If the reward is per indexed document, the optimal strategy is to index more documents. In neither case is the optimal strategy to maximize the accuracy of any individual artifact, because accuracy is expensive to measure and, once measured, hard to price.

So the agent optimizes for volume. Volume is cheap. The four-dollar document beats the four-hundred-dollar document on every dashboard the operator looks at, and the operator's dashboard is the only thing that has a number on it.

The middle layer gets squeezed out. That is the layer that actually verifies. A verifier costs money and produces a number that is usually bad news: this artifact is 60% grounded, this one is 12%. Nobody wants that number on their dashboard during a bull market. So verification gets tokenized too — "staking for truth," "curation markets," "accuracy mining" — and then it turns out that the way to win the accuracy-mining game is to be the one who defines accuracy, which is the same problem in a different costume.

I have watched three of these designs launch in the last two quarters. Two of them now have token prices that are completely detached from the quality of their output, because the market cannot read the quality of the output. And the market cannot read the quality of the output because the output is formatted to look identical whether it is grounded or null.

The information asymmetry is not in the model. It is in the format.

This is where the Layer 2 comparison actually becomes useful. The real difference between the two major rollup stacks was never the proof system. It was who could convince more projects to deploy first. Distribution beat architecture, and it beat architecture decisively, because architecture is hard to price and distribution is easy to count. The research-agent meta is running the exact same playbook with the exact same result. The stack that wins will not be the one with the lowest null rate. It will be the one with the most integrations and the most familiar output shape.

Which means the null rate will keep climbing, because there is no market mechanism that punishes it.

HTTP 200 is not truth

Here is the oracle problem wearing a new jacket, and it is worth spelling out because it generalizes.

A price oracle node reports that a feed is live. It got a response. HTTP said 200. The response body is empty. The node reports success, the aggregator marks the feed healthy, and downstream contracts keep pricing against a value that arrived from nowhere.

That is the same failure as the empty-body extractor. Structurally identical. And it is the same failure that the entire oracle decentralization debate has been dancing around for years: you can have twenty independent node operators and still have every single one of them reporting success when what you needed was truth. Success is a transport-layer fact. Truth is an epistemics-layer fact. Decentralizing the transport does not touch the epistemics.

The protocol that ends up owning research infrastructure will win on the same dimension. Not the number of nodes. Not the size of the staking pool. The one that can produce a signed, verifiable assertion that says this artifact is grounded in N sources, here are the source spans, here is the null rate of the producing pipeline over the last 30 days. That is an attestation. That is a number you can price. And right now nobody is producing it, because producing it means publishing a number that will often be bad.

I have been looking for a production stack that publishes its own null rate for eight months. I have found one, and it is a solo operator with no token.

Someone owns the off switch

There is a governance layer buried in all of this that almost nobody discusses, and it is the most important one.

Every one of these research pipelines — including the ones branded as decentralized curation networks — has an administrative control surface. Somebody can pause an extractor. Somebody can change the source whitelist. Somebody can flip a config flag that downgrades extraction to a cheaper model, or turns off a data provider, or raises the confidence threshold until the extractor self-censors into silence. In the stacks I have audited, that control surface is almost always a multi-sig, usually a 3-of-5 or a 4-of-7, held by the founding team plus one or two friendly funds.

Which means the null rate is not a technical parameter. It is an administrative one. And "we don't know" is the single safest thing an administrative multi-sig can cause a research pipeline to say.

This is the thing that the on-chain governance narrative has never been able to metabolize. The upgrade rights sit with the multi-sig. Always. Not because anyone is malicious, but because shipping a pipeline without an admin override is operationally insane and every engineer will tell you so, and because the multi-sig is the thing that lets you respond to a source going bad at 3 AM. The DAO votes on the treasury allocation. The multi-sig decides whether the extractor runs.

Which brings me to the contrarian read, and I think this is the actual story behind the 4,216-word document.

Contrarian: liability-driven silence

Everyone in the sector is treating the null report as an engineering failure. I do not think it is. I think a meaningful share of the null is manufactured, and the people manufacturing it are not engineers.

Walk the exposure. Under the EU's AI transparency regime, a system that generates analytical content about financial instruments has disclosure obligations. It has to tell the user it is a machine. It has to be able to explain its basis. And if it produces a characterization that reads like investment advice about an asset that a regulator later decides is a security, the party holding the admin keys has a problem that costs more than a subscription business is worth.

Now flip to the alternative. What does "insufficient information" cost you? A refund. A churn. A snarky post from someone like me. What does a hallucinated securities characterization cost you? A conversation with counsel.

The cheapest risk mitigation available to any operator in this sector is to make the pipeline output less. Not more accurate. Less. Push the confidence threshold up until the extractor self-censors on anything ambiguous. Widen the whitelist of disqualifying sources. Let the null rate drift from 14% to 30% to 45%, and let it be framed as rigor. Publish a methodology page about how you only cite high-quality sources. Nobody will check whether the real reason is that the calibration dial has been turned by someone whose job title contains the word compliance.

I spent a week in 2026 tracing the on-chain behavior of autonomous agents — the ghost-wallet audit that ended up in front of an EU enforcement body — and the pattern I found there was the same pattern I am describing here, just applied to transaction flows instead of text. Agents being tuned to under-act, because under-acting is defensible and over-acting is not. The tuning was not coming from the engineers. It was coming from risk.

So my read on the zero-finding report is not that the pipeline broke.

My read is that the pipeline was told what to do when it could not be certain, and someone very senior decided that the answer should be silence, and the formatting layer was never updated to make the silence legible. The engineers built a correct two-stage architecture. Risk turned up the null threshold. Nobody told the renderer.

And the deepest contrarian point: abstention is the only verifiable claim a research agent can make. Anyone can fake a confident paragraph. Nobody fakes an honest gap — the gap is expensive and it produces nothing sellable. That means the null, uniquely, is a signal you can trust without trusting the producer. It is the one output that costs the agent something.

The market has not noticed this. The market is still paying for words.

There is a second-order consequence worth flagging. If abstention is genuinely the cheapest way to manage regulatory exposure, then as the AI disclosure regime hardens through late 2026, the null rate across the entire sector should rise, not fall. Watch for it. The vendors will frame it as a quality improvement. It will be a legal decision wearing an engineering costume.

And there is one more thing in that document that nobody has commented on, because everyone stopped reading at the first N/A. At the bottom, the pipeline did something it was not asked to do. It stopped filling the template and produced an escalation note — a list of exactly which upstream fields were empty, ranked by priority, with instructions on how to restore the analysis. It identified the P0 field. It identified the P0 alternative. It told the operator what to go fix.

That is not a document generator. That is an agent that ran a post-mortem on its own inputs and wrote a remediation plan. It refused to be useful, and then it explained, precisely, what would make it useful again. I have seen human analysts with less self-awareness than that, and I have definitely seen vendors with less.

It was the best output the system produced all quarter. Nobody read it.

Takeaway: the number to watch

If you run a research stack, instrument the null rate this week. Not the error rate. Not the latency. The share of runs where Stage 1 returns fewer than three usable information points, and — separately — the share of runs where that null was propagated into a published artifact anyway. The gap between those two numbers is your entire data quality liability. My logs put the first around 14% and the second around 100%, and if yours looks the same, your archive is decaying at a rate you have not priced.

If you consume research rather than produce it, demand the null rate. Ask for it the way you ask for an audit. An operator who cannot tell you their extraction failure rate does not have one — they have an unmeasured liability with a publication schedule.

And if you are building in this sector, understand that the primitive that does not exist yet is verifiable abstention. A signed attestation that says this analysis is grounded in N sources, and these are the fields where I have nothing, priced and publishable, is worth more to institutional research than any amount of confident prose. It is also the thing that will be hardest to sell in a bull market, because it produces a number that is usually bad.

The market is paying for words right now.

At what null rate does it start paying for silence?

Disclosure: I run an aggregator that publishes AI-assisted research and I have made the same architectural mistakes described above. That is why I went looking for this one.