Last month, a research pipeline I was contracted to audit returned forty-seven distinct conclusions about a DeFi protocol. It scored the founding team's technical competence. It modeled a thirty-six-month token unlock schedule. It assigned a regulatory risk grade under the Howey framework. The input file was empty. Not truncated, not corrupted — empty. Zero bytes, no header row, no delimiters. The system did not crash. It performed exactly as designed. That is the finding, and it is worse than a crash.
This is not an isolated event. Over eighteen months I have reviewed eleven automated crypto research tools — institutional "AI analyst" dashboards, open-source screening scripts, and two vendor APIs sold to funds. Nine of them produced substantive output when fed null input. Six produced confident output. Three assigned numeric scores to assets that never appeared in the source data. In the absence of data, opinion is just noise. The modern research stack has industrialized the production of that noise.
The market has been sideways for months. When price stops moving, attention migrates to infrastructure — and the fastest-growing category of infrastructure is the tool that tells you what to think. Data vendors now bundle "signal engines." Exchanges publish machine-generated research. Funds subscribe to APIs that promise to rank tokens by risk-adjusted conviction. The pitch is uniform: remove the human analyst, remove the bias, ship the conclusion.
The mechanics are less uniform. Most of these systems share a three-stage architecture: ingest, normalize, infer. Ingest pulls raw data — on-chain events, price feeds, governance proposals, repository commits. Normalize maps everything into a schema. Infer runs a model — statistical, heuristic, or increasingly a language model — over the normalized record. Every stage holds a contract with the next. The contract at the ingest boundary is simple and absolute: if there is no data, the pipeline must halt.
That contract is routinely violated. Not by malice, but by an incentive that is structural. A pipeline that halts returns nothing. A pipeline that returns nothing cannot be sold on a dashboard. A pipeline that always returns something can. The market rewards the appearance of coverage, and the cheapest way to manufacture coverage is to let the infer stage run on whatever the normalize stage hands it — including the absence of everything.
I have watched this failure migrate from traditional finance into crypto with unusual speed. In 2017 I audited token models against securities law for a Sydney legal firm. The failure then was human: analysts who wanted the deal to close. The failure now is mechanical, and therefore scalable. A single misconfigured default can stamp the same fabricated confidence across ten thousand assets in an afternoon.
Let me be precise about the bug, because precision is the only defense.
The first failure is a category error: treating absence as neutral. A missing price is not a price of zero. A missing governance proposal is not a rejected proposal. A missing team is not a team of unknown quality — it is the absence of a team, which is a distinct state requiring a distinct verdict. Most schemas collapse these states into a single null, and most models then impute a default. In the pipeline I audited, the default for any missing numeric field was the asset's own median. The median of an empty set is undefined. The library returned zero. The model read zero as a real observation.
The second failure is confidence propagation without a floor. Modern inference layers attach a confidence score to every output. The intent is honest: signal how much the model trusts itself. The implementation is not. When the input is empty, the model still computes a confidence — because confidence is derived from the model's internal consistency, not from the evidence. A model that is certain of nothing and a model that is certain of everything emit the same internal coherence. Without an evidence floor, confidence measures the model's self-assurance, which is a property of the model, not of the world.
Here is the reduction. The bug is four lines long.
def score(record):
value = record.get("tvl", default=0) # empty dict -> 0
conf = model.confidence(record or {}) # runs on {}
return {"score": normalize(value), "confidence": conf}Pass an empty dictionary. The function returns a normalized score built on a fabricated zero, wrapped in a confidence number the model generated about itself. No exception is raised. No log entry is written. The output is indistinguishable from a real one.
The third failure is the Howey test applied to a ghost. I have run securities analysis on token models for eight years. The framework asks four questions: investment of money, common enterprise, expectation of profit, efforts of others. Each requires a subject. When the pipeline has no token, no issuer, and no distribution, every element evaluates to false, and the aggregate verdict reads "not a security." This is the most dangerous output in the entire system. A regulatory clearance generated from an empty file is not a clearance — it is a default, and defaults are not findings. I have seen this exact artifact in a fund's diligence memo. The memo cleared an asset that did not exist.
The fourth failure is the rounding error that looks like a feature. In 2020 I dissected the Compound governance contract and found a rounding discrepancy in the borrow-rate calculation that could have let whales extract roughly two million dollars in arbitrage during volatility. The lesson was not that the code was evil. The lesson was that a one-line arithmetic default, left unexamined, becomes a transfer of value. The null-input bug is the same species. It does not steal funds directly. It steals decisions — it moves capital toward assets that were never evaluated, and away from assets that were.
The fifth failure is the disappearance of the audit trail. A correct pipeline that halts leaves a record: input received, validation failed, no output emitted. That record is the source of truth. The pipelines I reviewed had no such record, because they never halted. Silence in the ledger is loud — but only if the ledger exists. Here, the absence of an error log is mistaken for the absence of an error.
I want to name the deeper pattern, because it recurs across every layer of this industry. In 2022 I spent three days pulling transaction hashes from LunaScan after the Terra collapse. The peg did not break because of a single malicious actor. It broke because a mechanism depended on speculative demand and nobody had modeled the demand's floor. The system had no input for "what if buyers stop," so it assumed they would not. That is the null-input bug wearing a stablecoin's face. Every catastrophic failure in this space is, at bottom, a system that was asked a question it had no data to answer, and answered anyway.
The same logic governs the layers underneath. Interest-rate models in Aave and Compound are calibrated to governance parameters, not to observable market clearing — so when liquidity vanishes, the curve does not represent supply and demand, it represents a vote. Blobspace on Layer 2 is priced today on today's demand, with no model for the demand that is coming; the arithmetic is already tightening. Ordinals gave Bitcoin a fee market that its security budget could not otherwise justify — a narrative input the base-layer model never anticipated. In each case the mechanism is sound only while its inputs hold. The moment an input goes empty, the mechanism does not pause. It extrapolates.
The incentive that produces all of this is not greed. It is uptime. A dashboard that shows "insufficient data" loses a user. A dashboard that shows a number keeps one. The research vendor is not paid for the accuracy of a halt. It is paid for the persistence of a screen. Every design decision flows from that single pressure, and the result is a machine optimized to never say nothing.
The fix is not more intelligence. It is a type system. Before you improve a model, you constrain its inputs. A correct schema distinguishes at least four states for every field: present-and-valid, present-and-invalid, absent-and-expected, and absent-and-unexpected. The first two are data problems. The second two are engineering problems, and they belong to the ingest layer, not the infer layer. When you encode these as distinct types, the compiler catches the category error before the analyst ever sees a number. This is boring work. It is also the only work that holds.
Any reader can run one test. Take the vendor's API and send an empty request body. If the response contains a score, a grade, or a recommendation, the vendor is not selling analysis. It is selling a default with a coat of paint. Do it before you pay. Do it before you publish. Do it before you allocate. The test takes ten seconds and costs nothing, which is precisely why almost nobody runs it.
Here is what the bulls and the builders got right, because a teardown that ignores the counter-case is just theater.
The engineers who built the good versions of these systems did not solve the hard problem — they refused to solve it. They made the ingest contract enforceable. They wrote schema validators that reject null payloads before inference ever runs. They separated "no data" from "neutral data" at the type level, so the compiler, not the analyst, catches the category error. They capped confidence at the evidence, not at the model's internal coherence. These are unglamorous choices. They produce dashboards that sometimes say nothing, which is exactly what a correct dashboard should sometimes say.
The second thing the builders got right is deterministic replay. A pipeline that can be re-run against the same input and produce the same output is auditable. A pipeline that cannot is a rumor with a user interface. The teams I trust run their models against frozen datasets and publish the diffs. That practice alone eliminates most of the failure modes above, because a null input produces a null output every single time, and the diff is empty and honest.
The third is the recognition that automation is not the enemy of judgment — it is its substrate. The value of a screening engine is not that it decides. It is that it decides only when it has evidence, and flags the rest for a human. The builders who understood this did not remove the analyst. They moved the analyst to the exact place where the data ends. That is a design philosophy, not a feature.
The next cycle will not be won by the desk with the most models. It will be won by the desk that knows, at the byte level, when its models have nothing to say — and says so. The question every research vendor should be forced to answer is not how accurate its output is. It is: what does your system print when the file is empty? If the answer is anything other than an error, you are not reading research. You are reading a bug that learned to write.
