Nine Dimensions, Zero Inputs: The Forensic Anatomy of a Fabricated Crypto Report

The File That Analyzed Nothing

The document arrived on a Tuesday. Forty-one pages. Nine analytical dimensions. A risk matrix with fourteen rows and probabilities carried out to two decimal places. It had been produced for a protocol that raised roughly $100 million six weeks earlier, and it had been forwarded to me by a fund associate who wanted a second opinion before an allocation vote.

I read it twice. Then I went looking for the thing it was analyzing.

There wasn't one. No contract address. No commit hash. No TVL series. No funding rate history. No unlock calendar. Not a single sentence lifted from the protocol's own documentation. The report's third page carried a section labeled Input Quality Audit, and that section confessed the problem in plain text: six required fields, six rows, every one marked missing. No title. No source. No information points. No core argument. No named protocol. No publication date.

Pages four through forty-one proceeded to analyze anyway.

That is the anomaly worth writing about, and it is not the anomaly most people assume. The failure was not that an AI hallucinated a token. The failure was that a system with nothing to say produced a complete, formatted, professionally typeset document that said it — and the pipeline billed for it, and a human forwarded it, and somewhere upstream a treasury was about to act on it.

I have spent nine years reading code and ledgers, and I have learned that failures have shapes. Bridge exploits have a shape. Liquidation cascades have a shape. This one had a shape too: the shape of a document that would rather be complete than be correct.

How the Pipeline Got Here

To understand why that file exists, you have to understand what happened to crypto research economics between 2024 and 2026.

The number of tokens with meaningful liquidity across major chains crossed forty thousand this cycle. Every one of them wants coverage. Every one of them funds a Telegram group, a research desk, a KOL roster, or all three. The demand for structured analysis did not grow linearly with the token count — it grew with the number of allocation decisions, which grew faster. A fund running twenty positions needs a memo for each one. A copy trading desk with four thousand subscribers needs a thesis for each rotation. A listing committee needs a document it can point to when the position goes to zero.

Against that demand sits the supply side. Genuine protocol-level research costs roughly one analyst-month per project if you are being honest, and most desks are not being honest. I know what honest costs because I have paid it.

In late 2017 I spent three weeks reading the Geth client by hand during the Ethereum Classic fork controversy. Not skimming — reading, with the source open next to a scratch file of notes about the hashrate distribution. Thirteen major pools controlled over sixty percent of the network's hash power. That was the actual finding, and it took three weeks to establish, and it produced one blog post read by maybe four hundred people.

In 2020 I deployed $15,000 of my own capital into Uniswap V2 pools purely to watch what MEV bots would do to it. I ran a local node, tracked front-running transactions during volatility spikes, and documented arbitrageurs extracting 4.2% in effective fees from retail flow. That work took a month. It produced one article and grew my newsletter to five thousand subscribers.

Three weeks of work for four hundred readers. One month of work for five thousand readers. That ratio — enormous cost, negligible scale — is the reason automated pipelines exist. It is also the reason they break.

Here is the architecture that became standard. Stage one ingests a source document and extracts structured facts: names, numbers, dates, claims, counterclaims. Stage two takes that structured output and reasons over it to produce analysis. Split the pipeline this way and you can swap models, cache the expensive layer, and run the cheap layer thousands of times a day. Inference on stage two costs fractions of a cent. A junior analyst costs fractions of a bitcoin.

The economics are irresistible. The engineering is where it falls apart, because nothing in the standard architecture forces stage two to check whether stage one returned anything.

The Anatomy of an Empty Extraction

Let me show you what the artifact actually contained, because the structure is more instructive than the content.

Section zero was the input audit. Six required fields, all flagged absent:

{
  "article_title": null,
  "information_points": [],
  "core_argument": null,
  "protocols_involved": [],
  "publication_date": null,
  "source_quality": null
}

That is the entire input to a forty-one page report. An empty array and five nulls.

And then, embedded in the audit section, one line that is worth more than everything after it: the analyst refuses to fabricate or speculate.

The system knew. It printed the confession. It appended a disclaimer. And then it kept going, because the pipeline had a dispatch table sized for nine sections and a job queue that expected nine sections back.

This is where I want to be precise, because the obvious take — "the AI made things up" — is lazy and wrong. The document did not invent a team, a funding round, or a TVL figure. It did something subtler and more dangerous. It populated the shape of an analysis with placeholders that read like conclusions.

Each of the nine dimensions came out looking like a section that had been written. Technical: innovation N/A, maturity N/A, security assumptions N/A. Token economics: a supply table with team, early investors, community, and treasury rows, all marked N/A. Market: a competitor table with a single row marked N/A. Governance, regulatory, risk matrix, narrative, supply chain transmission — all present, all formatted, all hollow.

A reader skimming that document sees structure. Structure is the strongest credibility signal in financial writing. Nobody builds nine sections, a risk matrix, and a Howey test table for a project they have not examined. Skim depth is the heuristic every allocator uses when they are moving fast, and it is trivially counterfeitable.

The nine dimensions are not arbitrary, either. Each one maps to a specific data requirement, and the mapping is the audit itself. Here is the honest version:

| Dimension | Minimum Required Input | Present in Artifact | |---|---|---| | Technical | Repo, audit reports, commit cadence, spec, mainnet status | No | | Token economics | Allocation table, vesting curve, emissions schedule, revenue | No | | Market | FDV, float, volume, funding rates, unlock calendar | No | | Ecosystem | Upstream dependencies, downstream integrators, deployment counts | No | | Regulatory | Entity jurisdiction, Howey factors, KYC/AML posture | No | | Team & governance | Contributors, voter participation, holder concentration, investor rounds | No | | Risk | The risk matrix itself | No | | Narrative | Expectation-gap metrics, sentiment-to-fundamental ratio | No | | Supply chain | Cascade mapping across miners, exchanges, infra, DeFi | No |

Nine dimensions. Zero inputs. Zero outputs, nine times, arranged in a grid.

A report that enumerates its own missing inputs and then proceeds to conclusions is not analysis. It is a commitment device — it commits the reader to a position the document cannot defend. That distinction matters more than any single exploit I have written about this cycle, because it operates on the reader's brain rather than on a contract's state.

Null Is a Valid Answer Everywhere Except in Narrative

Now the part that should worry anyone building on automated infrastructure.

The extraction stage returned an empty template. In most systems, that is a signal. An API that receives malformed input returns a 400. A database query against a missing table throws. A validator that cannot verify state does not vote — it abstains, and the chain either stalls or routes around it. Consensus fails loudly, because a silent failure in consensus is indistinguishable from an attack.

Language layers fail quietly. An extraction module that gets nothing has no exception to raise, because an empty document is a perfectly well-formed input. The schema validates. The array is empty, not malformed. So the pipeline proceeds, and the missing data propagates downstream as the absence of constraints, which the narrative layer fills with fluent prose.

I watched this exact failure mode up close in 2026, when I worked with a small team deploying an AI-driven trading bot on Solana to test its behavior during flash crashes. The bot's logic was fine. The execution path was fine. What killed it was the oracle feed: during a 20% drop inside three seconds, the price feed did not fail, it went stale. It kept returning the last known good number, roughly 400 milliseconds behind reality, and the bot kept making decisions on prices that no longer existed.

We documented it in a post-mortem. The headline finding was not "the bot failed to exit." The bot exited exactly as designed. It did not fail to act; it acted on data that was already dead.

The empty extraction is the same bug wearing different clothes. A pipeline that would rather return the last known good shape — a formatted document — than return nothing is a pipeline that will trade your treasury against stale beliefs.

There is a second, uglier layer. When I looked at how the artifact justified its nine sections, they were not nine independent checks. Every one of them read from the same null source. That is not diversification of analysis. That is correlated failure with a table of contents.

Nine independent checks that share one input source are one check wearing nine hats.

I learned that lesson in early 2022, tearing apart the Axie Infinity Ronin bridge compromise. $625 million gone, and the root cause was not a smart contract vulnerability. Five of the nine multisig key holders were geographically and infrastructurally concentrated in a single Russian server cluster. The threshold was five of nine on paper. In practice, an adversary who reached one jurisdiction reached the quorum. The design was decentralized; the operations were not. Every additional key in that cluster added the appearance of independence without adding a single unit of it.

Security is a myth until the bridge breaks. The same sentence applies to a nine-section report where every section inherits from the same empty extraction.

Every exploit is a lesson paid for in ETH. This one is paid for in something harder to recover, which is the time an allocator spends believing a document that was never about anything.

The Cost Asymmetry Nobody Prices

Here is the arithmetic that keeps this failure mode alive.

A genuine audit of a mid-cap protocol — contract review, token model stress test, governance analysis, operational security assessment — runs four to eight weeks and somewhere between $150,000 and $400,000 depending on scope and who is signing. Call it $250,000 and six weeks. That produces a document with named auditors, commit hashes, line-item findings, and a public disclosure trail. It is expensive because it is expensive to be wrong about it later.

A fabricated report of the same length runs in about forty seconds. Total inference cost, including the extraction stage that returned nothing: under a fifth of a dollar. Call it $0.20.

The gap is six orders of magnitude. And the detection probability is low until the position is underwater, at which point detection is irrelevant because the loss has already cleared.

Now put that asymmetry in a bull market, where a thread can move a low-float token fifteen percent before the author finishes their coffee. Liquidity is just trust, quantified in gas — and in this market, trust is quantified in impressions, which are cheaper than gas and infinitely more elastic.

Yields vanish when the herd arrives at the gate. They do not vanish because the yield was fake. They vanish because the gate was never load-bearing, and nobody checked what the gate was attached to until everyone was pressing on it at once.

The 2023 restaking backtests I ran taught me the same thing in numerical form. When I simulated 10,000 slashing scenarios for EigenLayer allocations, the headline was that a 15% capital weight produced roughly 22% higher APY. The number everyone quoted. The number almost nobody quoted was the other one: ruin risk up roughly 40% at the same weight. Both figures came out of the same model. Only one of them fit on a slide.

Every fabricated research document is a backtest with no price series. It has the shape of a result and none of the variance. And variance is the only part that costs you money.

The Contrarian Read: This Was the Honest Document

Here is the angle I keep coming back to, and it inverts the entire conversation.

The empty report is not the dishonest artifact in this market. It is the only honest one you will see this cycle, precisely because it printed its own ignorance in a labeled table on page three.

Think about the alternative. A different pipeline, same empty extraction, but with a summarization step tuned for fluency. It fills the team section with three plausible founders. It estimates TVL from comparable projects. It assigns the token a regulatory risk score of "medium" because medium is the modal answer. It writes nine sections that read exactly like the forty-one pages I received, minus the audit table that gave it away.

You cannot detect that document. Neither can I. Neither can the associate who forwarded the file to me, and neither can the investment committee voting on Thursday.

The version I received was merciful. It was a map of exactly which questions had not been answered, indexed and footnoted. Most pitches hide those gaps inside fluent prose where they cannot be audited. This one left the gaps visible.

So the reflex to blame the model is misdirected. The model flagged the nulls, appended a disclaimer, and refused to fabricate. It behaved better than most analysts I have worked with. The failure sat one layer up, in a pipeline owner who shipped stage two without stage one because the billing metric was output tokens, not verified claims.

Refusal does not invoice. Non-delivery is priced at zero. In a market where every other desk is shipping forty pages and posting the thread, the desk that returns "we have no data" looks broken, and the desk that returns nine confident sections looks productive. The incentive gradient runs straight toward fabrication, and it runs quietly.

Ledgers bleed, but code remembers the truth. Prose does not. Prose forgets on purpose, and it gets paid for the forgetting.

Post-Mortem: What I Would Patch

I write this section in every major piece because the point of a failure is the patch, not the post. Four changes, in rough order of cost.

First, throw on empty extraction. The stage boundary needs a hard assertion: if the information-point array is empty, the pipeline halts and the job returns a failure code. Not a warning. Not a flag. A halt. Right now the schema accepts an empty array as valid, which means the failure is invisible at exactly the layer where it should be loudest. In consensus terms, this is the difference between a node that abstains and a node that votes with stale state.

Second, attach provenance to every claim. Each sentence in an analytical output should carry a pointer to the extracted fact that produced it, resolvable to a source document and a content hash. If a sentence has no pointer, it cannot ship. This is the same discipline as citing the repository and the transaction hash in a trading writeup. It is tedious. Tedium is the point. The cost of provenance is the entire reason it filters anything.

Third, make null a publishable answer. "We ran the extraction, the source was empty, here is the list of six fields we could not obtain" is a legitimate deliverable and it should be priced as one. Right now the market treats it as a non-delivery, so suppliers fabricate instead. Change the price and you change the behavior. Refusal has to be a product, or fabrication remains the only rational move.

Fourth, break input correlation. If nine dimensions are going to be reported as nine sections, at least some of them need independent sources. Technical claims should resolve to the repository and to deployed bytecode, not to the pitch deck. Market claims should resolve to exchange data. Governance claims should resolve to on-chain voter records. Any two dimensions that trace back to the same document are one dimension, and the report should say so.

None of these are technically hard. All of them cost money to run and produce fewer pages per dollar. That is why they are not standard, and that is why the artifact on my desk existed at all.

What To Ask Before You Allocate

The next time a research document lands in your queue — and it will, this week, probably twice — do not read the conclusion first. Read row one. Ask for the extraction layer: the named protocol, the contract address, the source document, the date. If the input layer is empty, everything below it is decoration, and decoration is the most expensive thing you can buy with a treasury.

Logic cuts through the noise of the bull run. The noise this cycle is not price. Price is honest; price is the one number in the ecosystem that cannot lie for long. The noise is forty-one beautifully formatted pages that describe a protocol which does not exist in any retrievable form.

Here is the question I keep sitting with. How many positions in your current book rest on a document whose inputs you have never actually seen? Not the analysis — the inputs. And if you cannot answer that in under thirty seconds, you are not holding a portfolio. You are holding a set of commitments someone else made on your behalf, and you never read the row one.