The output was empty. Not thin. Not noisy. Empty. Title, source, summary, stance, purpose, list of information points — every field either blank or stamped 'not provided.' That is the observation. Everything downstream of it is arithmetic. If the upstream stage returns null, no amount of downstream reasoning recovers signal. The ledger bleeds faster than the logic holds.
The instinct in a bull market is to fill the gap. A model is asked for 'deep analysis,' it sees a blank table, and it hallucinates a table full of plausible facts. This is the failure mode nobody prices in. Not a wrong conclusion — a fabricated premise. I have watched this exact pattern chew through crypto research desks for two years, and it is worth anatomizing because the mechanics are identical whether the pipeline is extracting from a news article or a token's on-chain activity.
Context: The Extraction Layer Is Where Systems Die
The architecture under review is a two-stage pipeline. Stage one ingests a document — an article, a page, a filing — and emits structured fields: title, source, summary, stance, purpose, information points. Stage two consumes those fields and produces 'deep analysis.' The design assumes stage one is a reliable transducer. It is not.
The failure surface at stage one is narrow and well-documented, and the probabilities are ordered for a reason. First on the list: the ingest is not the article body but navigation chrome, cookie banners, or sidebar junk. This is the most common cause and the most embarrassing to admit, because it is a plumbing problem masquerading as an intelligence problem. Second: the page is JavaScript-rendered and the scraper captured the DOM before hydration completed. You get a skeleton with no content. Third: the material sits behind a paywall or a login wall, and the extractor grabbed the teaser placeholder. Fourth: encoding or chunking failure truncated the body to an empty string — often a silent Unicode or segmentation bug that logs no error. Fifth: the stage-one LLM call timed out or returned truncated, and the structured output degraded to default nulls.
None of these are exotic. All of them are detectable. A pipeline that emits an empty result and asks stage two to proceed anyway is not a pipeline; it is a coin flip wearing a lab coat.
Core: Diagnosing the Empty Result Before Touching the Model
Here is the mechanical insight that matters: an empty stage-one result is a plumbing signal, not an analysis problem. The correct response is not to prompt harder at stage two. It is to instrument stage one until you know which of the five failure modes fired.
The diagnostic order is not arbitrary. I count the cracks before the dam breaks, and the cracks are ordered by cost of inspection. Check the raw payload first. Log the exact bytes handed to the extractor. If those bytes are a cookie consent string, you have failure mode one and you fix a selector, not a model. If the bytes are a partial DOM with empty containers, you have failure mode two and you fix a render wait. If the bytes are a summary placeholder with a subscription prompt, you have failure mode three and the fix is access, not prompt engineering. Only after you have confirmed the payload is clean, complete, and the real body do you suspect the LLM call itself — encoding, chunking, timeout.
I have run this triage loop on trading infrastructure that looks unrelated but is structurally identical. In 2020, during the DeFi Summer arbitrage run across Uniswap and Sushiswap, I built Python monitors for gas price and slippage. When the monitors returned zeros, my first hypothesis was never 'the market is calm.' It was 'the feed is stale.' Two nights in a row the 'calm' was a dead websocket, and the positions I nearly sized on that calm would have been sized against air. The analogy is not decorative. A null result is data about your pipe until proven otherwise.
Now the harder mechanical point, the one the pipeline design misses. Even a successful extraction of 'information points' is a lossy compression, and stage two cannot reconstruct what the compressor discarded. If stage one summarizes an article into five bullet points, stage two is analyzing the bullets, not the article. The 'deep analysis' is deep only relative to the summary, which is a paraphrase of a paraphrase. On a financial document this compounds tragically: the number that matters — a reserve ratio, a gas figure, a specific on-chain balance — often survives as the vague verb 'reported' in the summary. Stage two then builds confident structure on the vague verb.
This is where I diverge from how most crypto research tooling is sold. The pitch is automation and scale. The reality is that the extraction layer is the single point of failure, and each hop in the chain multiplies the error. Code is law until the miners decide otherwise; and here the 'miner' is your parser, and it decided to give you the cookie banner.
The structural failure is not that the model is weak at reasoning. Modern reasoning at stage two is adequate for most financial documents. The failure is that the pipeline asks stage two to be confident when stage one handed it a blank sheet. A system that cannot distinguish 'empty input' from 'low-signal input' will hallucinate facts to fill the void, because the instruction 'produce deep analysis' is unconditional. An unconditional output demand against a conditional input supply is a hallucination generator. That is the bug, and it is architectural, not a matter of model choice.
Consider what the correct contract looks like. Stage one should be able to say, explicitly, 'I failed, and here is which failure mode.' Stage two should be able to say, 'I cannot analyze; the upstream is empty; here is the diagnostic.' The current contract has neither. It has a schema of fields that must be populated, and a default of null when they cannot be, and a downstream stage that ignores the null. The schema is the cage. Build the cage, then watch the beast jump in — except here the beast is a fabricated summary, and it climbs through the null.
I have carried a version of this lesson since the 2017 ICO audit days. Auditing the CoinDash ERC-20 implementation, the bug was not in the marketing narrative. It was in the integer overflow in the fundraising logic, and it lived in one function that the team had not instrumented because it 'only ran during the raise.' The failure surface was narrow, expensive, and invisible until you looked. The empty-pipeline result here is the same shape: a narrow upstream defect that the downstream, by design, cannot see and will paper over with narrative.
The fix, mechanically, has three parts. First, treat the raw payload as a first-class artifact — store it, hash it, and never let it be silently replaced by a parsed derivative. Second, make stage one fail loudly and typed, with an explicit failure-mode field rather than a null. Third, gate stage two on input sufficiency — if the information-point count is below a threshold, or the payload hash matches a known chrome pattern, stage two refuses and escalates to diagnostics. None of this is sophisticated engineering. It is the discipline of not letting an empty string pass as content.
There is a broader pattern in how these systems get built during a bull market. Euphoria rewards speed to output. A pipeline that always produces 'analysis,' even from a cookie banner, feels productive. A pipeline that returns 'diagnostic required' feels broken. So the incentive pushes toward the unconditional-output design, and the hallucination is priced in as an acceptable cost until a research desk acts on a fabricated premise. Then the loss is real, and the post-mortem reveals the empty sheet three layers up. Liquidity is just borrowed time with a premium; so is a summary you did not verify against the payload.
Contrarian: The Retail Tooling Assumption Is Backwards
The consensus in crypto research tooling is that the hard part is the analysis. Most effort goes into larger models, more sophisticated prompts, denser ontologies of 'information points.' My reading is the reverse: the analysis layer is commoditized, and the extraction and verification layer is where every dollar of edge still lives.
Retail and even mid-tier desks assume the bottleneck is reasoning. They benchmark their pipelines on how smart stage two looks. Smart-money operators I have watched benchmark the pipe on how faithfully stage one transduces the source — and they keep humans in the loop precisely at the seam where a summary claims a specific number. The blind spot is that a smooth, confident stage-two output is treated as evidence the pipeline works. It is evidence of nothing. A model instructed to analyze will analyze; the fluency is constant and uninformative. The only meaningful quality signal is whether the analysis can be traced, claim by claim, back to a verified byte in the raw payload.
This is also why I built the 2025 AI-agent options infrastructure myself rather than renting a black-box bot. The returns came from transparent execution logic I could audit, not from a model I could not inspect. A pipeline whose inputs you cannot inspect is a black box with a P&L attached, and the P&L will eventually disagree with the box. Risk is not a number; it is a feeling you ignore — and the feeling here is the quiet wrongness you get when stage one returns null and stage two returns confidence.
There is a second contrarian point, smaller and sharper. The empty-result problem is often misfiled as an AI problem when it is a web-scraping and data-plumbing problem, and the framing matters because it misdirects the fix. Teams respond to a blank result by upgrading the reasoning model. The correct response is to upgrade the extractor's awareness of where it is on the page. Most 'the AI failed' incidents I have triaged were, in plain engineering terms, a CSS selector problem. Say that out loud on a research floor and it sounds less impressive than 'model limitations,' which is precisely why it goes unfixed and recurs.
Takeaway
Before the next dashboard shows you a confident analysis, find the raw payload that fed it and check that the payload was the article and not the cookie wall. If the chain from source byte to claim is broken at the first hop, every downstream insight is a hallucination with good posture. The forward question for anyone building or buying these systems: when the input is empty, does your pipeline tell you, or does it invent? Build the cage, then watch the beast jump in — and make sure the beast is a missing field, loudly declared, and not a fabricated fact, quietly believed. Survival is the only alpha that compounds, and the first survival check is whether your data is real before your analysis is confident.