We didn't get an answer. That was the point.
On a Tuesday night in Istanbul, fog swallowing the minarets outside my window, I ran a routine pipeline over a document a colleague had forwarded — a market note that was supposed to contain a thesis about a freshly funded protocol. What came back was a nine-section report, immaculately formatted, tables aligned, headers bolded. Every field read "N/A." Technical assessment: insufficient information. Token economics: insufficient information. Ecosystem position: insufficient information. Under the section titled "hidden information," the output said: Cannot be inferred. There is no text to analyze; any hidden information would be fiction.
I laughed out loud, alone, at two in the morning. A machine had just refused to lie to me.
Then I stopped laughing, because I recognized what I was looking at. That refusal is the thing our industry has spent a decade claiming to build and has almost never actually built. Not a smarter model. Not a faster analyst. A system that, when it lacks input, says so — and does not paper the gap over with confident prose, a plausible chart, and a price target.
We are in a bull market. Confidence is free. Provenance costs something.
The supply chain of a crypto narrative
Every price in this market is downstream of an information supply chain almost nobody audits. A tweet becomes a thread. The thread becomes a "research note." The note becomes a Telegram forward, then a governance forum post, then a listing announcement, then a three-hundred-million-dollar valuation. At no point in that chain does anyone ask where the original number came from — whether it was pulled from a block explorer, scraped from a Dune dashboard somebody abandoned in 2023, or simply invented by a language model that was trained to be helpful rather than accurate.
I've been in this industry long enough to remember when the supply chain was shorter. In 2017, at DevCon3 in Tokyo, I watched cryptographers explain zero-knowledge proofs to artists and artists explain color theory to cryptographers, and I assumed the bottleneck was translation. I was wrong. The bottleneck was never translation. It was verification. Nobody in that room could tell you which of eleven competing claims about a single project was true, and nobody had built infrastructure to find out. Six weeks of parallel workshops across three cities and five hundred developers taught me something I have never stopped writing about: the industry had an abundance of people explaining how to build, and almost nobody explaining why anyone should believe the output.
Eight years later, the supply chain has gotten longer, faster, and dramatically more synthetic. The EU's AI Act has been phasing in its obligations since August 2024, and regulators in Brussels have been constructing transparency requirements around training data and synthetic media. Meanwhile, on-chain, the volume of machine-generated content moving through crypto's social channels has grown faster than any human moderation layer can process. Deepfake video of a founder "announcing" a partnership. Inflated GitHub activity. Synthetic governance forum posts written specifically to farm delegation. Wash-traded volume designed to trip a screener.
The result is a market where the quantity of analysis has never been higher and its epistemic quality has never been harder to assess. Everyone has a dashboard. Almost nobody has an attestation.
Failure mode one: empty input, silent default
That N/A report sits at the honest end of a spectrum. The dangerous end is a system that receives nothing and still produces a number.
This is not hypothetical. It is the single most common defect in every data pipeline in this industry, and I have found it in production code on protocols holding nine figures. A data source changes its schema. The ingestion script throws. The error is caught by a try/except that logs to a file nobody reads. The front end keeps rendering the last successful write. The field shows a number. The number is four days old. Nobody notices until somebody routes liquidity against it.
What makes this failure mode so persistent is that it doesn't look like a failure. An empty field looks broken. A stale field looks fine. Empty is visibly incomplete; stale is invisibly false — and in a bull market, invisible falseness is the most valuable commodity there is, because it lets everyone keep building on a foundation nobody has inspected.
Failure mode two: the last good price
Oracle design has spent years solving the wrong half of this problem. The engineering literature is full of work on manipulation resistance — how to stop someone from moving a price in a thin pool for a single block and extracting value from a lending market. That work matters. But it addresses adversarial corruption, not benign absence.
The harder question is what a protocol should do when the oracle simply has nothing to say. Chain X's RPC endpoint is degraded. The only venue for asset Y is a pool with forty thousand dollars of depth that hasn't traded in nine hours. The off-chain node that normally pushes updates has been offline since the weekend. There is no manipulation here. There is just nothing.
Most protocols answer that question with a default: keep publishing the last value, and widen the deviation threshold slightly. That is a governance decision dressed as an engineering one. It says: we would rather have a wrong number than no number, because a wrong number keeps liquidations flowing and the TVL chart smooth, whereas no number halts the market and forces somebody to explain why.
I've come to think of this as the liquidity preference for bad data — the structural bias of every leveraged system toward believing something rather than nothing. An empty field halts the machine. A stale field runs the machine. In a market where running the machine is the business model, the stale field always wins. This is not a bug in any individual protocol. It's a selection effect operating across the entire sector.
Failure mode three: confident fabrication
Then there's the newest and fastest-growing failure mode, the one that arrived with large language models: input that exists, but is itself invented.
I want to be precise here, because this is where the conversation usually collapses into vague talk about "AI slop." The mechanism is more specific. A model asked to produce a competitive analysis of a protocol will produce one. It has no representation of whether the protocol exists. It has a representation of what a competitive analysis of a protocol like that looks like — the cadence, the comparable set, the token unlock table with plausible percentages. The output is fluent because fluency is the objective function. Factuality is a constraint applied afterward, if at all, and usually by a separate system with a much smaller compute budget.
I saw the industrial version of this in 2021, when I co-founded a platform for digital artists to retain royalties. The market didn't want provenance; it wanted velocity. Collectors bought because a chart went up, and the chart went up because people bought. The underlying question — who made this, when, from what, and can you prove it — was treated as a rounding error. What actually killed projects like mine wasn't the crash. It was that the crash exposed an entire valuation resting on a claim nobody had verified. Gas fees, Layer 2 economics, environmental cost — I spent months on the technical side of that problem and eventually understood the technical side was the easy side. The hard side was that the market had no mechanism for caring where a number came from.
That's the common thread across all three failure modes. Empty input, stale input, fabricated input — they are the same failure. The system's output is not bound to its input. There is no cryptographic or procedural link between what went in and what came out. Everything downstream inherits that unbinding.
What a bound pipeline actually looks like
Binding output to input is not a research problem in 2026. It's an integration problem, and the primitives exist.
Start with attestations. The Ethereum Attestation Service gives you a public registry where any statement can be made by an identified address, timestamped, and revoked. On its own, an attestation proves only that someone said something. But a chain of them — this address attests that it pulled this RPC response at this block height, this oracle attests that its median was computed over these venues, this auditor attests that the deployed bytecode matches this commit hash — turns a claim into something you can trace back to its origin, or fail to.
Then content credentials. The C2PA standard, which has been gaining real adoption across camera manufacturers, editing software, and publishing platforms, embeds a signed provenance manifest into media at the point of capture. It is not a blockchain project, and I think that is a feature rather than a bug. What matters is that it establishes the pattern: provenance travels with the artifact instead of being asserted about it later by a third party. Every AI-content-detection product I have evaluated fails the same way — it is a probabilistic guess made after the fact. Signed provenance at capture is a fact. Detection is an opinion.
Then verifiable credentials and zero-knowledge proofs. A user proves they hold a credential without revealing the rest of their wallet. An institution proves its reserves exceed its liabilities without publishing its balance sheet. An oracle proves that the value it published was computed from a specified set of inputs, without revealing the inputs. In each case, the proof is bound to the claim.
Here is what I find genuinely interesting, and it is the part the market has not priced: the most valuable thing an analysis system can do is produce a verifiable record of what it did not know. A report that says "N/A" without a reason is useless. A report that says "N/A, because the only available source was a tweet from an unverified account, and here is the signed log of the retrieval attempt" is a research artifact. It tells the next analyst exactly where to begin. It converts an absence into a data point.
We didn't build that. We built dashboards.
The hooks problem
I need to bring this back to something concrete, because abstraction is precisely how this industry avoids accountability.
Uniswap v4's hook architecture is the best current example of both the promise and the peril. Hooks let a pool's behavior be modified at specific lifecycle points — before a swap, after a swap, on liquidity addition, on donation. The design turns a DEX from a fixed product into a programmable surface. It is, genuinely, Lego. I have watched developers light up talking about it.
I have also watched roughly ninety percent of them bounce off it. The complexity spike is not in the concept; it's in the invariants. Once a pool's behavior depends on arbitrary external code, the pool's safety properties stop being properties of the pool. They become properties of the hook, plus the hook's dependencies, plus the oracle the hook reads, plus the governance that can upgrade the hook. Every hook is a new trust boundary where data enters the system — and where all three failure modes above get a fresh place to hide.
This is where the bull market does its damage. A funded project deploying a novel hook has every incentive to ship and no incentive to publish the part of the audit that reads: "the price source returned N/A on four percent of blocks during testing, and the fallback behavior is undefined." That sentence kills a launch. It doesn't kill a protocol; the undefined fallback does, six months later, on a Sunday, while the team is asleep.
The ETF and the disappearance of the native signal
Something similar happened to Bitcoin, and it happened so gradually that most people didn't notice they had stopped reading the chain.
For most of Bitcoin's life, the interesting signals were native. Mempool congestion. Miner outflow. Address accumulation. The ratio of coins moving to coins sitting. In the year after the spot ETFs were approved in January 2024, a growing share of marginal flow moved into vehicles whose activity is reported in a prospectus rather than broadcast to a mempool. Creation and redemption happen with authorized participants. The signal — the thing you are actually reading when you read Bitcoin — migrated from the chain to the custodial layer.
I don't say this as a maximalist grievance. I say it as a data problem. If your model of Bitcoin's supply and demand was trained on native on-chain behavior, and the dominant flow now enters through a pipe you cannot observe at block granularity, then your model's inputs and its target have decoupled. That is failure mode one wearing a suit. Peer-to-peer electronic cash was the original thesis; the current instrument is a macro asset attached to a custodial plumbing system, and the analytical tooling has largely not caught up. The Bitcoin that institutions buy and the Bitcoin you can verify are increasingly two different objects.
The contrarian turn
Here I have to turn on my own argument, because there is a version of everything above that is smug and wrong.
The smug version says: transparency wins, the honest system that says N/A is the future, and anyone shipping confident analysis is a charlatan. I've been writing long enough to distrust any thesis that makes the author look good, and this one does exactly that. So let me test it.
A system that refuses to answer is not automatically honest. It is also a system that has shifted all the risk onto the reader. "Insufficient information" is a perfect alibi — it can never be wrong. If I hand you a page of N/As, I have protected myself completely and told you nothing. The rigor is real; the value is zero. And in a market where someone has to decide by Friday, a blank page does not produce caution. It produces a market for whoever is willing to fill in the blank. Abstinence creates the vacuum that fabrication fills.
The deeper problem is that this industry has spent a decade optimizing for the appearance of rigor rather than the function of it. Nine-section frameworks. Confidence intervals on numbers scraped from a dashboard with an unmaintained subgraph. "Based on my analysis" used as a rhetorical device rather than a claim with a traceable referent. We built the liturgy of diligence and skipped the sacrament.
So no — the answer is not more N/As. The answer is N/As that carry a receipt, and the discipline to tell them apart from the ones that don't. Transparency without provenance is just a more articulate silence.
Takeaway
We didn't get an answer that Tuesday night. We got a log. That is the difference that matters, and it is the difference this market has to start pricing.
The next cycle's real infrastructure will not be a faster chain. It will be the binding layer — the attestations, content credentials, and proofs that make it possible to say, of any number on any dashboard, where it came from, when it was true, and what its author did not know. Bull markets reward the confident. They get liquidated by the provenance. My question for whoever is reading this at two in the morning, on a bridge between two continents, is not whether you trust the number in front of you. It is whether you can prove you should.
