A research pipeline delivered me a 1,700-word risk report last week. Nine analytical dimensions โ technical architecture, tokenomics, market structure, ecosystem position, regulatory exposure, team, risk matrix, narrative, supply-chain transmission. Every field was marked N/A. The document rendered cleanly. The tables aligned. There was a disclaimer at the bottom, properly formatted, and a note explaining that missing fields should not be read as an absence of risk.
Nothing threw an exception. That is the part that should worry you.
In a bull market, capital moves on dashboards. A fund allocates because a screenshot says TVL is up, because a risk score is green, because an automated report came back "clean." The industry has spent two years arguing about whether language models hallucinate. Almost nobody is auditing the inverse failure: a system that correctly declines to answer, formats the refusal as a table, and gets read by a human as clearance. That is not a model problem. It is a type-system problem wearing a compliance costume.
Due diligence in crypto has quietly been automated end to end, and the reason is arithmetic. The number of new protocols launching per week exceeded human analyst capacity somewhere around 2023 and has not come back. The stack looks the same everywhere: an extraction layer pulls facts from documentation, governance forums, and on-chain state; a structuring layer maps them into a fixed schema; a scoring layer converts the schema into a number; a human reads the number and allocates.
Each layer is typed loosely, and loose typing is precisely where absence becomes invisible.
Consider what the extraction layer actually returns when it fails. It does not return an error, because the contract between layers was written as "a set of string fields." An empty string satisfies that contract. The string "N/A" satisfies it even better โ it looks deliberate, even editorial. By the time the scoring layer executes, it is not evaluating a missing fact. It is evaluating a string, and strings are never null.
I have watched this exact pattern in code for two decades. In 2017 I spent roughly 400 hours inside the Zeppelin math library ahead of a client's mainnet launch, and the bug class that kept surfacing was not exotic โ it was sentinel collision. Zero is a perfectly valid token balance. Zero is also what an uninitialized variable returns. The compiler cannot distinguish them, so the developer must, and the developer is tired. I refused to sign off on fourteen edge cases until every one was patched; the launch slipped three weeks and the marketing team stopped returning my emails. The bugs were never the interesting part. The interesting part was that every single one of them was invisible to a test suite that only exercised the happy path.
Automated research pipelines are running that same test suite today, at portfolio scale.
Here is the propagation chain, concretely. An indexer lags. A subgraph query for totalValueLocked returns null. The dashboard component coerces it โ Number(null) === 0 โ and renders "$0." The risk model receives a numeric zero, compares it against a threshold, and because zero sits below every liquidation trigger, emits "low exposure." No error appears anywhere in the chain. Every individual step is defensible in isolation. The composite is a lie.
The on-chain version is worse, because Solidity has no null at all. When a Chainlink aggregator is uninitialized or its feed has gone stale, latestRoundData() does not revert. It returns a struct. The answer field is zero, and zero is a syntactically valid price for everything. This is why every production integration must carry an explicit staleness and sanity gate, and why so many still do not:
(uint80 roundId, int256 answer, , uint256 updatedAt, uint80 answeredInRound) =
feed.latestRoundData();require(answer > 0, "stale-or-unset"); require(updatedAt > 0 && block.timestamp - updatedAt <= MAX_STALENESS, "stale"); require(answeredInRound >= roundId, "carried-over-round"); ```
Three requires. Roughly forty gas. The third one is the one people forget, and it matters: answeredInRound catches the case where the aggregator reports a round it did not actually complete, handing you a price carried over from an earlier epoch. Every protocol that has been liquidated on a bad oracle price skipped at least one of these lines, and the reason is always identical โ the failure mode is not a revert, it is a plausible number.
The same disease infects the analysis layer, and the schema is the vector. A JSON schema declaring "risk_level": {"type": "string"} will validate "N/A" without complaint. The schema did its job. It validated the shape of a document and asserted nothing about its substance. This is what I mean when I say the standard is obsolete before the mint finishes โ schemas are written to describe the happy path, absence is not in the happy path, so absence passes validation by default rather than by design.
A related pathology lives one layer down: the try/catch that swallows. Engineers write try feed.latestRoundData() returns (...) { ... } catch { return 0; } because returning zero keeps the caller from reverting, and a non-reverting caller looks like resilience. It is not resilience. It is a partial function disguised as a total one, and it will price your collateral at nothing while every log line reads healthy.
I learned the cost of that disguise during the Compound work in 2020. I built a local simulation harness over six weeks to model liquidation cascades under volatility, and the flaw I eventually documented was not a broken formula. The interest rate model converged โ smoothly, monotonically โ to a value that was mathematically correct and economically fatal, because an input that should have read "no liquidity available" was being represented as "liquidity available at this price." A partial function had been silently totalized. That is the entire genus, and it is the same genus as a research pipeline returning a well-formatted page of N/A.
The Terra post-mortem taught me the financial variant. Anchor's headline rate was a number that looked like a yield and was in fact a subsidy; the field that should have carried "organic revenue" was effectively blank, and the market rendered the blank as a rate. The blank was not hidden. It was published, in the docs, in plain sight, and priced at 19.5%.
Which brings me to the thing nobody wants to say out loud about LLM-based due diligence: a null result must interrupt the pipeline, not pass through it. In circuit design a floating pin is not a low signal โ it is undefined, and you pull it to a known rail or you inherit metastability. Every automated analyst I have reviewed treats empty extraction as a soft pass. The correct behavior is a hard stop with an explicit INSUFFICIENT_DATA state that cannot be coerced into a number, cannot be rendered green, and cannot be summarized away by a downstream model instructed to "write up the findings."
The contrast with institutional practice is instructive. In 2024 I wrote a 200-page security specification for a tier-one institution integrating Bitcoin custody under threshold signatures, and the single hardest cultural gap was this: in their control matrix, a blank field is an audit failure. Not a neutral field. Not a field awaiting input. A finding. They passed SOC2 first attempt because blanks were treated as defects by default. Crypto's analytics stack treats blanks as a state of grace.
Formally: a function that returns a default value on missing input is a total function, and totality is exactly what makes it dangerous. If it isn't formally verified, it's just hope โ and hope is what you are running when your risk dashboard cannot distinguish "no vulnerabilities found" from "no testing performed."
The consensus concern about AI in crypto research is hallucination, the model inventing a fact that isn't there. That is the loud failure, and it is the easy one, because an invented fact can be checked against a source.
The quiet failure is abstention. A model that correctly reports "I could not extract the token distribution" produces a document that looks, at a glance, identical to one reporting "the token distribution is clean." Both are tables. Both are formatted. One ends the conversation. I have sat in rooms where a single clean-looking PDF killed a two-week diligence sprint, and nobody could reconstruct afterward whether the analysis had found nothing or had simply not been performed. The pipeline did not deceive anyone. It returned a truthful document about its own ignorance, and the reader supplied the optimism for free.
Code is law, but law is interpretive โ and the interpretation here is performed by a human under time pressure who has already decided they want to allocate.
The next meaningful exploit class is not going to be reentrancy. It will be the oracle that reports zero instead of reverting, the indexer that lags without a heartbeat, and the risk dashboard that renders absence as safety. It will clear more capital than any contract bug, because nobody writes a post-mortem for a number that was never computed. Audit your dashboards the way you audit your contracts: enumerate every field, and for each one ask what it displays when the data does not exist. If the answer is zero, you have not built a monitor. You have built a green light.