Nine sections. Forty-one fields. Zero populated values.
I received the brief on a Tuesday morning, between two audit reviews. Technical architecture: N/A. Supply structure: N/A. All four Howey prongs: N/A. Risk matrix, six categories: N/A. Ecosystem dependencies, upstream and downstream: N/A. The document had been pushed through a nine-dimension analytical framework — technical, tokenomic, market, ecosystem, regulatory, team, risk, narrative, transmission — and every terminal node returned the same string. Forty-one fields, one value.
The instinct is to file it as a failed analysis and request better inputs. I did not. An all-null output is not the absence of a finding. It is a finding, and it is the most honest artifact I have read this quarter.
These nine-dimension templates proliferated after 2021, when every research desk needed a standard format to price coverage at scale. The logic was industrial: if a stable schema runs against any protocol, you can staff junior analysts against a checklist and ship consistent output. The format worked — for protocols that had something in the fields.
The economics were never about accuracy. Research is billed per report, not per verified claim. A forty-one-field template is a billable unit. A single honest sentence — "this protocol has not published enough to assess" — is not.
I learned to distrust formats in 2017, at eighteen, tracing EVM opcode logic from the Yellow Paper in a dorm room in Bangkok. Three months writing a Python state-transition simulator for basic ERC-20 contracts, because the whitepapers I was handed described intent while the bytecode described behavior. Those two documents rarely agreed. The code whispers what the auditors ignore.
So when the N/A report landed, I treated it as bytecode.
The first thing to understand is that null does not average. In IEEE 754 floating point, any arithmetic operation involving NaN returns NaN. There is no partial credit and no dilution — one uninitialized value poisons the entire downstream computation graph. The nine-dimension format is a directed acyclic graph with a single source node: Stage One. When Stage One emits nothing, you do not get nine partial analyses. You get nine nulls, deterministically. The document was not incomplete. It was the only correct output for that input.
The second thing is where this pattern actually bites in production code. Solidity's low-level call returns a tuple: success and data. If the target is an empty account, a self-destructed contract, or a proxy whose implementation slot was never written, the EVM returns success = true with data.length == 0. The dangerous case is never the revert. The dangerous case is the silent success. A decoder that skips the length check either reverts downstream or, worse, abi.decode zero-fills and hands address(0) and zero amounts to logic that trusts them.
Now map that onto the report. The framework is a low-level call. It returned empty bytes. The downstream consumer is the reader, and the reader does not check length. They abi.decode the void into what they already believed. A bull decodes N/A as "unresearched, therefore early." A bear decodes the identical bytes as "unresearched, therefore dead." Same return data, two decoders, two opposing positions. The null did not create the disagreement. It revealed the disagreement was never evidence-backed to begin with.
I have been on both sides of this pattern. In 2020 I found an integer overflow in an early yield aggregator's reward accounting — a function that would wrap on a sufficiently large deposit, and the documentation never mentioned the cast. Fifteen days reading Solidity while the pitch deck advertised 10x APY. The finding paid a five-thousand-dollar bounty. The lesson was not the overflow. It was that the mismatch between the prose and the arithmetic is where risk lives, and that mismatch is measurable.
In 2024 I compared the multi-signature thresholds in a Bitcoin trust's public filings against the actual configurations visible in test deployments. They did not match. I was asked to suppress the finding for client relations. The blog post that followed was never really about the trust — it was about the fact that a filed number and an implemented number are different data types, and that conflating them is standard practice. Trust but verify is not a slogan. It is a length check.
This is where language models make the pathology worse. A model handed a forty-one-field template has no incentive to leave fields empty. In 2026 I spent three weeks red-teaming an AI-agent DeFi protocol whose oracle feeds were manipulable by adversarial inputs — gradient-guided perturbations to price series that nudged the agent's policy network past its decision boundary. The oracle did not fail. The oracle reported confidently. That distinction mattered more than the exploit. Hallucination is not a model failure mode; it is the default decoding behavior of a system optimized to produce plausible continuations. Ask a model to fill a form and it will fill the form.
The N/A report refused. Forty-one fields, and a pipeline somewhere declined to invent forty-one answers. In a market where every aggregator, dashboard, and thread is optimized for completeness, that refusal is a rare signal. Silence is the highest security layer, but only when something downstream is actually built to handle it.
Here is the counter-intuitive position, and it will not be popular on research Twitter. The industry's demand for "more data" is, in practice, a demand for more confident decoders, not more truth. Measured strictly by information gain — the only metric that survives a sideways market — the N/A report outperforms most published crypto research, which takes an identical void and pads it to three thousand words with jurisdiction narrative. Hong Kong's virtual asset licensing gets written up as innovation-friendly regulation when it is a competitive bid against Singapore for the same desk fees. USDC's compliance-first posture gets written up as institutional maturity when the operational fact is a freeze authority that can darken any address inside twenty-four hours. China's digital collectibles get written up as an emerging market when the secondary venue was never built — which makes their price field structurally N/A by design, not by data gap. In all three cases the technical field is empty and the narrative field is full. Logic holds when markets collapse.
The instrumentable version of the fix is unglamorous: force Stage One to emit a typed record with an explicit sentinel for "no verified data," and make every downstream stage propagate that sentinel instead of overwriting it. Integer, address, boolean, enumeration — four types, each with a defined null. Then measure coverage, not conclusion. A report that declares nine of forty-one fields populated and labels the rest is worth more than forty-one fields of confident noise, because the first is auditable and the second is not. The market currently has no mechanism to tell them apart. That gap is the real product opportunity of the next cycle, and it is not being built by anyone shipping dashboards.
We spend enormous effort on oracle design for price feeds and almost none on oracle design for knowledge. The asymmetry is strange until you price it: a manipulated price feed moves PnL within one block, while a manipulated research report only moves conviction, and conviction has no liquidation engine. That is precisely why it persists.
The forward question is not whether the next framework will return fuller fields. It will — models guarantee that. The question is whether anyone will build the length check. When your analysis pipeline returns success = true with empty bytes, do you revert, or do you abi.decode the silence into a position?