On a Tuesday morning in the second week of January, I opened a research artifact that an automated pipeline had generated and forwarded to a desk of eleven people. It was nine sections long. It had a risk matrix with six rows. It had a supply-structure table with four categories and an unlock-schedule column. It had a Howey test with four elements, each given its own verdict cell. It had a narrative-persistence score. It had a supply-chain transmission diagram with arrows.
Every cell in every table read the same thing: N/A.
The pipeline had been fed an empty document. It had not crashed. It had not thrown an exception. It had formatted the void into a deliverable, and somewhere between stage one and stage nine, the absence of information had been transmuted into the appearance of an assessment. The desk read the artifact as nothing alarming found. Two of them increased position size.
That is the finding. Not a hack. Not a rug. Not a depeg, not an exploit, not a governance attack. A schema.
I have spent thirteen years reading ledgers and roughly nine of those years building the pipelines that read them for other people. My entire professional identity rests on the claim that the chain does not lie. It doesn't. But the chain also does not volunteer. Between the ledger and the reader sits a stack of extraction, parsing, entity-tagging, scoring, and rendering decisions, and that stack is where a null becomes a neutral, where a gap becomes a green light, and where a report containing zero verifiable facts becomes an input to somebody's position sizing.
This is not a story about one bad template. It is a story about a failure class that has become structural in how crypto research is produced, and about the specific metric I now use to catch it before it reaches a human being who is in a hurry.
Context: the machinery that turns nothing into something
Here is how these artifacts get built, and why they fail in this particular way.
The framework that produced the artifact I opened is a nine-dimension template. Technical. Tokenomics. Market. Ecosystem position. Regulatory. Team and governance. Risk. Narrative. Supply-chain transmission. Each dimension follows the same three-step logic: extract facts, compare facts against a benchmark, infer a conclusion. Nine dimensions, all downstream of a single upstream object — a list of structured information points, each one a minimal independently verifiable unit of fact. "Protocol X reported TVL of Y on date Z." "Round A closed at valuation V led by fund F." That list is the only source of truth in the system. Everything else is arithmetic on top of it.
When that list is empty, the nine dimensions do not return nine verdicts. They return nine containers. And a container with a label on it looks like a deliverable.
I want to be precise about why this is a modern failure and not an old one. In 2018, an analyst who had nothing to say wrote nothing. The bottleneck was human labor, and human labor has a natural defense: it is expensive, so it gets rationed, and the rationing mechanism is judgment. When I started, a research note was a document someone had to sit down and type. Laziness and caution were aligned. Nobody generated nine empty tables by hand, because nobody wanted to spend four hours typing N/A.
Automation broke that alignment. Generation is now nearly free and evaluation is not. A pipeline that produces nine sections of structurally perfect emptiness costs fractions of a cent, and the human who receives it spends real cognitive effort deciding what it means. The cost of producing a bad artifact collapsed; the cost of consuming one did not. That asymmetry is the entire mechanism. It is not a model problem. It is a cost-structure problem wearing a model's clothes.
I learned the corrective discipline in August 2020, during the Uniswap V2 launch, when I was tracking what I assumed was an ordinary arbitrage bot and found instead a slippage miscalculation being farmed by a coordinated set of wallets. I wrote a Python script to cluster behavior across transaction timing, gas-price bands, and token-pair selection, and isolated 14 addresses responsible for $2.3 million in extracted value. The analysis was not clever. The analysis was a spreadsheet. I built a standardized template that logged every transaction timestamp and every gas fee, because I had discovered that I could not reason about chaos until I had forced it into columns. My manager at the time told me the template was excessive. The template was the only reason the finding survived review.
The lesson I took was not "build templates." It was that structure is an epistemic commitment, not a formatting preference. When you decide which columns exist, you decide which absences are visible. A column that is always populated looks like diligence. A column that is never populated looks like a gap. A table where every cell is N/A, rendered with borders and a header row, looks like neither. It looks like a category of analysis that has been performed.
That distinction carried me through the May 2022 collapse of Terra and Luna, when I audited liquidity depth on major DEXs using hot-wallet tracking and found that a 60% share of reported volume on one venue traced to a single entity — a forensic report I built around $45 million in fabricated flow and delivered as a sell signal on liquidity divergence rather than sentiment. That report worked, and it worked for a specific reason: the data existed. The chain had produced the transactions. My job was to read them, not to invent a scaffold for their absence. When the facts are there, a pipeline is a lens. When the facts are not there, the same pipeline is a projector.
By January 2024, during the spot Bitcoin ETF approval, I had moved from individual audits to standardizing metrics for a team. Retail was reading spot inflows as a single number and drawing the wrong conclusion, so I built Net Exchange Reserve Velocity — on-chain outflow rates combined with ETF share-class creation and redemption changes — and enforced a reporting template across every analyst output so that two people looking at the same week would produce the same number. The goal was never consensus. The goal was that a disagreement would be about interpretation and not about arithmetic.
Then in 2025, with MiCA in force, I tracked capital moving from traditional finance into regulated custodians and found a repeating quarterly pattern: 12 pension funds rotating into stablecoin issuers, roughly $1.2 billion per cycle. I built a dashboard that monitored the specific wallet tags and alerted on deviation. That dashboard had a design principle I now apply everywhere: it alerted on change in tagged flow, never on presence or absence of an alert. Absence of an alert meant nothing had been observed. It did not mean nothing had happened. Two different sentences. Two different operating postures.
By early 2026, when autonomous agents began transacting on-chain in volume, I was clustering 500-plus AI-driven wallets and separating human flow from machine flow, arriving at the uncomfortable estimate that 80% of trading volume in the emerging AI-crypto protocols was autonomous. I introduced a Human-versus-AI wallet-tag classification and forced a Bot Filter into every market analysis I signed. Not because algorithmic flow is bad. Because an analyst who cannot state what fraction of the tape is machine-generated is not analyzing a market. They are analyzing their own reaction to one.
All of which is to say: I am not a skeptic of pipelines. I am a builder of them. And that is exactly why the artifact with nine empty sections concerns me more than any single protocol failure I have covered.
Core: the anatomy of a null that reads as a positive
I spent three days reconstructing how the empty artifact was produced. I had access to the pipeline's intermediate outputs. Here is what I found, and here are the four failure modes that generate this class of artifact.
Failure mode one: upstream truncation. The pipeline's first stage generates a template with all fields present and unfilled, then attempts to populate them. If the extraction step errors, times out, or returns an empty payload, the template still exists. The population step writes nothing. The render step reads a complete schema and writes a complete document. Confidence on this diagnosis: high. This is the most common cause, and it is the most dangerous, because it produces no error signature at any downstream stage. The output is indistinguishable from a genuine assessment of a low-information subject.
Failure mode two: non-textual source material. The input was a link, a video, or an image. The extraction layer found no parseable text. The pipeline treated zero text as zero facts rather than as extraction failure. These are completely different conditions. One says the subject is unknown. The other says the subject was never examined. A well-built pipeline distinguishes them with a single boolean. Most do not carry that boolean.
Failure mode three: sub-threshold density. The input was a single sentence — a funding announcement, a tweet, a listing notice. The nine-dimension framework requires a minimum information mass to produce anything, and the input did not meet it. Rather than switching to a lighter template, the system emitted the heavy template with empty cells. This is the failure mode that most resembles a design flaw rather than a bug, and it is the one I consider most fixable.
Failure mode four: schema mismatch. The upstream field names did not match the downstream expectations. Either the stage returned an empty list or the downstream read keys that did not exist. Confidence: low, in this case, but this class is real and it grows as pipelines accumulate versions.
Now the part that matters more than the taxonomy. Failure modes one through four are engineering problems. The fifth failure is not.
The fifth failure is that a rendered document with nine sections and fourteen tables was read by eleven professionals as a negative screening result. Nobody asked what had been examined. They asked whether the output looked like a green light, and a document with no red flags in it looks like a green light. The null had been neutralized. Absence of evidence had been processed as evidence of absence, at a rate of eleven humans per artifact.
This is what I now call structural verisimilitude — the property of a document that satisfies the formal expectations of an assessment while containing none of its substance. And I want to be careful here, because this is the point where an analyst is most tempted to overclaim. I do not have experimental evidence that tables cause overconfidence. What I have is a consistent observation across several years of reviewing outputs: the more heavily structured the presentation of absence, the less likely a reader is to question the absence itself. I treat that as a hypothesis with strong anecdotal support, not as a law. I flag it explicitly in my own reports so that nobody downstream treats the structure of this article as proof of the argument inside it.
What I can measure is the prevalence. And that brings me to the metric.
The Standard: Fact Anchoring Ratio
I define one new quantity per analysis, explain its arithmetic, and let readers audit it. Here is this one.
Fact Anchoring Ratio (FAR) is the weighted share of emitted claims that trace to a primary source.
FAR = ( sum over all claims of claim weight ) / ( total claims emitted )
Claim weight is assigned by source class:
- 1.0 — primary, machine-readable, independently reproducible. An on-chain transaction, a contract state read, a filed document, a signed governance proposal.
- 0.5 — named secondary source with a timestamp. A specific person quoted on a specific date, or a dashboard reading that any other analyst can regenerate.
- 0.0 — unattributed. "The team stated," "community sources indicate," "reports suggest," any construction where the reader cannot independently locate the claim.
FAR runs from 0 to 1. A report with every claim anchored to a ledger read scores 1.0. A report with every claim sourced to narrative convention scores 0.0. And here is the operational part: a report with zero claims scores 0, not undefined. That is the fix. The denominator is total claims emitted, and if the pipeline emitted twenty statements of absence — "insufficient information to assess," "data unavailable," "condition not determinable" — those are claims. They are claims of ignorance, and they carry weight 0.0, because an assertion of ignorance that cannot be traced to a specific failed lookup is just ambient doubt dressed as diligence.
Working floor: FAR below 0.15 blocks emission. Not "flags for review." Blocks. I have run this gate on my own outputs for eighteen months and it has never once blocked a piece of research that contained a genuine finding. It has blocked a substantial number of pieces that contained tables.
There is a companion statistic I track but do not gate on, because I do not trust it enough: Null Neutralization Rate, the share of unpopulated fields rendered inside a bordered table or structured block rather than as plain text. My working figure across the sample I reviewed was that 71% of research documents containing a risk matrix also contained at least three N/A or equivalent cells, and 44% contained five or more. Those numbers come from a non-random sample — 4,180 long-form research posts over a 30-day window, drawn from accounts my system tags as analyst-adjacent — and I will not pretend that is a representative frame. It is a directional reading. The direction is uncomfortable enough to justify the gate.
Standardization isn't bureaucracy. It's the only mechanism I have found that makes a null legible as a null.
Bot Filter: how much of the output layer is machine-drafted
I run a Bot Filter on every market analysis I publish, and it would be inconsistent not to run one on the research layer itself.
Using posting cadence, lexical entropy, template-reuse detection, and structural fingerprints, my classifier flagged 38% of the 4,180 documents in that sample as machine-generated or machine-assisted at the drafting layer. Estimated false-positive rate: I would put it between 8% and 14% on manual spot checks, which means the honest range is something like the low-to-mid thirties. The filter is not a moral judgment. A machine-drafted document can be excellent. The filter exists because the reader needs to know what they are reading in order to weight it.
Here is what the Bot Filter reveals about this specific failure class, and it is the part I find genuinely alarming. Machine-drafted documents scored systematically higher on structural completeness and systematically lower on FAR than human-drafted documents in the same sample. The drafting layer is optimizing for the completion of forms, because form completion is what the training signal rewards and what the consumers visibly reward with engagement. The consequence is that the exact artifact class that looks most like research is the artifact class least likely to contain an anchored fact.
I want to state the limitation plainly, because this is where a lesser analysis would stop and call it a scandal. My classifier measures drafting assistance, not truth. A human writing a fully fabricated report and a model writing a fully anchored one both exist in this sample. The correlation I found — machine drafting, high structural completeness, low FAR — is a correlation inside a convenience sample, and correlation is not causation. The plausible causal story is not "models fabricate." It is "the demand side rewards structure, and structure is the cheapest thing to produce." That story is testable and I have not tested it. I am flagging it as the next study, not as a conclusion.
Reverse-engineering the institutional desk
In 2025 I built a dashboard that tracked pension-fund capital rotating into regulated stablecoin issuers. Twelve funds, roughly $1.2 billion per quarter, moving on a schedule. The reason that dashboard worked is not that I was smarter than anyone else. It is that I started from the institutional end-goal and traced backward through the on-chain steps: custody wallet tags, then issuance flows, then redemption timing, then the banking rail. Reverse-engineering works because institutions are structurally predictable. They have mandates. Mandates produce calendar behavior.
Apply the same method to the desk that received the empty artifact. Its end-goal was to hold a position. Its constraint was a risk process that required a documented screen. The pipeline delivered a documented screen. The pipeline did not fail the desk. The pipeline satisfied the desk.
That reframing changes where you put the fix. If the problem is a pipeline bug, you patch the pipeline. If the problem is that the desk's process rewards the existence of a document over the content of one, you patch the process. I have watched three organizations attempt the first fix and none attempt the second, because the first is an engineering ticket and the second is a governance argument, and engineering tickets get closed.
The forward-looking question I now ask of any research function is not "what is your model." It is "what is the last artifact your process refused to accept." If the answer is nothing, the process is not a filter. It is a rubber stamp with an audit trail.
Latency: the informational version of a front-run
There is a market-structure parallel here that I think is exact, and it is the reason I care about this beyond process hygiene.
I have argued for years that orderbook DEXs will not displace centralised venues, and the reason is not UX and not liquidity incentives. It is that market makers will not leave resting quotes on a public ledger to be picked off. Latency is not a feature of trading; it is the substrate of it. The venue that lets you hide your order wins the maker.
The same logic applies to research. A conclusion that is published in a shareable, machine-readable, structurally complete format is a resting quote. Whoever reads it first, and fastest, takes the other side. In the case of a falsely neutral screening report, the trade is simple: you read the artifact, you recognize that it contains no information, you observe that the recipient desk believes it contains a green light, and you position ahead of the flow that belief is about to produce. The gap between the report and the correction is the analyst's golden hour, and it is available to anyone who knows a null when they see one.
This is why the bot-drafted, structurally complete, fact-free research document is not merely wasteful. It is a liquidity event. It creates a predictable mispricing in the behavior of whoever consumes it, and predictable mispricing gets arbitraged. The cost does not land on the desk that produced the report. It lands on the desk that traded on it, and it lands as a transfer of the desk's capital.
Contrarian: the case against my own gate
Now the part I owe the reader, which is where this argument is weakest.
My first claim — that structured rendering of absence increases unwarranted confidence — is not proven. I have a consistent observation and a plausible mechanism. I do not have a controlled test. The confound is severe: the desks that get fooled by structurally complete empty reports are also the desks operating under the tightest time constraints, with the thinnest analyst coverage, and the strongest internal pressure to produce a documented position. It is entirely possible that formatting is not the causal variable at all, and that I am measuring time pressure and calling it typography. If that is true, my FAR gate does nothing except make my reports shorter.
I have no way to distinguish these two hypotheses from my current data. I am telling you that because the alternative — presenting a formatting theory as a behavioral law — is precisely the sin this article is about.
My second claim is more uncomfortable and it cuts against my own practice. A pipeline that reliably outputs nothing is not a cautious pipeline. It is a broken pipeline that has learned to sound cautious. I have watched analysts develop a professional identity around refusing to speculate, and I have watched that identity degrade into a machine that produces well-worded abstentions and calls them rigor. Abstention is not analysis. It is the absence of analysis with better manners. If your FAR gate blocks everything, you have not built a filter. You have built a very expensive way of saying nothing, and you have given the reader no reason to come back.
The fix is not at the output gate. It is at the intake gate. The correct response to an empty information-point list is not a nine-section report of N/A. It is a hard stop, an error surface, and a request for the minimum field set. That is a real design decision, it costs real engineering time, and almost nobody makes it, because a hard stop looks like a worse product than a document.
My third claim is the one I would defend hardest. The root cause is not technical at all. It is that a desk mandates a daily or weekly memo on a subject that does not produce daily or weekly facts. Once that mandate exists, the pipeline will satisfy it, because that is what pipelines do, and if the facts are not available the pipeline will manufacture the shape of facts. No model change fixes a mandate. You cannot engineer your way out of a demand for continuous signal imposed on a discontinuous reality. The correction is a governance decision: define the subject, define the cadence, and accept that some weeks the correct output is a single line reading no new verifiable facts.
That sentence is harder to write than it sounds, because the reader will ask why they are paying for it. Which brings me to the real cost of the empty artifact. It is not that a desk lost money on one position. It is that the market for research has been flooded with documents whose only function is to justify their own existence, and that flood has made genuine findings harder to identify. The blockchain doesn't dilute signal. Formats do.
I will add one more observation from adjacent territory, because the pattern repeats. When I audit claims about Bitcoin settlement layers, the same failure appears in a different costume: a dashboard with every metric populated, an ecosystem page with every integration listed, and no independently verifiable path from a transaction on the layer to a final state on the base chain. The cells are full. The anchoring is absent. That is the same FAR problem with more marketing behind it. And when I audit compliance disclosures, the mechanism surfaces again in a third costume: a KYC status field rendered as complete because the form was submitted, while the substantive question — what the entity actually verified about the beneficial owner — remains unanchored, with the cost of answering the questions pushed onto the users who comply honestly. Full forms. Empty answers.
The pattern is not about crypto. It is about any system in which the completion of a document is decoupled from the auditing of its contents.
Takeaway: what to watch next week
Three signals, each observable without privileged data.
First, count abstentions that are anchored. Read the next five research documents you receive and mark every sentence that states the absence of information. Then ask, for each one, whether it names the specific lookup that failed. "On-chain data unavailable" is unanchored. "Contract state read on address 0x… returned no events after block N" is anchored. The ratio between those two tells you whether the pipeline has an intake gate or just a template.
Second, watch for the first hard stops. The tell is a research product that sometimes returns nothing at all — a page that says the subject could not be assessed and names the exact fields it needs. When you see one, that team has made the governance decision, not the engineering one, and it is the more expensive of the two.
Third, watch the correction windows. When a fact-free assessment does reach a desk, the position it produces has a lifetime measurable in hours. If you can identify the artifact, you can identify the window, and the size of that window is the real cost of the entire failure class.
The ledger has never asked for your belief. It has always required the reader's patience to read, and it has never once gone to the trouble of telling you where it has nothing to say. That last part is our job, and we have been outsourcing it to a renderer. The question worth carrying into next week is not which project is hiding something. It is who audits the schema that decides which silences are visible — and whether the answer is a person, or a template nobody has ever refused.