A client called me in a mild panic last quarter. Their team had shipped a research report to a regulator, and a footnote citation pointed to a paper that didn't exist. Correct-looking journal name, plausible author, plausible year, plausible title. Just not real. An analyst had used AI to summarize supporting literature, the AI had confidently produced the citation, and no one had noticed until a fact-checker at the regulator did.
They wanted to know how to prevent it from happening again. That's what this piece is about. It's a field guide, not a philosophy essay. If you work in a role where being right about sources matters — journalism, legal, analyst, academic, corporate research — and you use AI anywhere in your workflow, this should help.
I'll cover the five most common failure modes of AI-assisted research, a five-layer defense framework, recommendations by role, and the common wrong approaches I see teams reach for. At the end I'll be honest about what the framework doesn't solve.
The premise: AI in research is already here
Before the framework, one honest observation. The teams calling me about research integrity in 2026 aren't asking "should we use AI?" They're asking "how do we use it without shipping bad work?" The horse has left the barn on the first question. Analysts use AI for literature scans. Journalists use it for background research. Corporate strategy teams use it for market synthesis. The productivity gain is real and the tools aren't going back in the box.
That means the interesting question isn't whether to prohibit AI. It's how to build a workflow that captures the productivity gain while catching the errors that come with it. Prohibition strategies don't work in practice — people use AI anyway, they just stop telling you. Defense-in-depth strategies do work, and they compound: each layer catches things the previous layer missed.
The five failure modes
Not all AI errors in research are the same. Different failure modes need different defenses. Here are the five I see most often, in rough order of frequency.
1. Fabricated citations
The AI produces a citation to a source that doesn't exist. Sometimes it's a real outlet with a fake article; sometimes it's a plausible-sounding journal that isn't indexed anywhere; sometimes it's a real author with a paper they never wrote. This is the failure that led to my client's panic call and it's the most publicly embarrassing when it slips through.
2. Source laundering
The AI has read an unreliable source, summarizes its content in an authoritative voice, and presents the claim as its own without attribution. The reader thinks they're getting a synthesis; they're actually getting recycled content from a source they'd never have accepted directly. Subtle and hard to catch.
3. Correct source, wrong claim
The AI cites a real outlet correctly — the article exists, the URL resolves, the author is real — but misrepresents what the article actually said. Paraphrases that shift meaning. Attributions to speakers who didn't say what's claimed. This one bypasses whitelist checks entirely because the citation itself passes.
4. Overconfidence bias
The AI presents uncertain claims as certain, and hedged claims as unhedged. Whatever qualifications appeared in the source ("preliminary data suggests," "a small study of 40 patients") get flattened into confident statements. Readers infer more certainty than the underlying research supports.
5. Recency drift
The AI treats old information as current. A 2019 industry statistic gets restated as if it applies to 2026 conditions. A superseded regulation gets cited as if still in force. Because AI training data mixes eras, temporal context often gets lost in synthesis.
The five-layer defense framework
Each of the failure modes above is caught by different means. Stack them and you get defense-in-depth: even if one layer misses, the next catches. No single layer is sufficient; all five together are strong.
Layer 1: Prompt discipline
How you ask the AI matters. Prompts that demand citations from a named source pool ("only cite from Reuters, FT, WSJ, and Bloomberg") produce fewer fabrications than open prompts. Prompts that ask for hedged language when the source hedges produce less overconfidence. Prompts that specify recency requirements ("sources must be from 2024 or later") catch some drift. This is the cheapest layer — free, in fact — and it eliminates a surprising fraction of errors before they enter your workflow.
Layer 2: Source whitelist enforcement
Mechanically verify that every source cited in the research output is on your approved list. This is what our Source Whitelist Checker Skill does — you provide a YAML whitelist and a piece of writing, and the Skill returns per-source dispositions (approved, rejected, flagged for review) with reasoning for each ruling. It catches most fabricated citations (they usually invent outlets not on the whitelist), most source laundering (recycled content from off-whitelist blogs gets flagged), and provides an audit trail for compliance.
Whitelists are the highest-leverage single defense against AI research errors in my experience. They're also the most under-adopted, because they require you to write down your editorial policy explicitly — something most teams have never done. The exercise of writing the whitelist itself is often the most valuable part.
Layer 3: Existence verification
For every URL cited, confirm the page actually exists and matches the described content. This requires a web-fetch capability — either an MCP server that can browse, or a manual pass by a reviewer with the links open. Catches the fabricated-URL-at-real-outlet cases that Layer 2 misses. Also catches URL shortener redirects to off-whitelist destinations.
Layer 4: Claim re-verification
For the small number of specific claims that carry real weight in your output, independently re-verify them against the primary source. Not every claim needs this — the point is to identify the load-bearing claims (a specific percentage, a specific attribution, a specific date) and check those. This is where the "correct source, wrong claim" failure mode gets caught. Time-consuming per check, but you should be doing far fewer of these than you have citations.
Layer 5: Editorial review
A human editor or reviewer looks at the finished work with the goal of catching what the previous four layers missed. This is the layer everyone knows about and the layer teams reach for first — often as their only defense, which is where things go wrong. Editorial review is best used to catch the subtle failure modes (overconfidence, recency drift, framing bias) that don't show up as citation errors. When editorial review is doing the whole job of every layer, editors burn out and misses accumulate.
Recommendations by role
Different roles need different emphasis across the five layers. Here's where I'd put the weight for each.
Journalists
Layers 2 and 5 hardest. Newsrooms already have editorial standards, so the whitelist exists implicitly — write it down explicitly and mechanize the check. Layer 5 you already do well. Layer 3 (existence verification) matters if you publish online, less so for wire copy. Layer 4 for load-bearing quotes.
Financial and equity analysts
Layers 2 and 4 hardest. Regulators care about the source-of-record for material claims, and load-bearing numbers need independent verification against primary sources (SEC filings, earnings transcripts, official statistics). Layer 3 mostly automatic if you're working from SEC EDGAR and company IR sites. Layer 1 pays outsized dividends for repeat workflow: put your approved data providers in the prompt template.
Academic researchers
Layers 2 and 3 hardest. Citation to non-existent papers is career-damaging in a way that fabricated news citations aren't — peer review catches it. Whitelist here is journal-based rather than domain-based (indexed peer-reviewed only, or field-specific). Existence verification via DOI resolution is straightforward and worth automating.
Corporate researchers and strategy teams
Layers 1, 2, and 5 hardest. Layer 1 because internal teams often skip prompt discipline (there's no external editor forcing it), Layer 2 because approved-source policies at big companies tend to be aspirational rather than enforced, and Layer 5 because internal work often ships without formal review. Fixing Layer 1 is the fastest win: a prompt template that pins the approved-source list eliminates most citation failures before they happen.
Content marketing and publishing teams
Layers 1 and 2 hardest. High-volume content operations rely on speed, which means Layer 4 (per-claim reverification) is rarely feasible. Whitelist enforcement plus disciplined prompts catch most issues at the front of the pipeline where fixing them is cheap. Layer 5 does the polish.
The wrong approaches
Three approaches I see repeatedly that don't work.
Trusting the LLM to self-check
Asking an AI "are you sure these citations are real?" produces overconfident yes-answers even when the citations are fabricated. Models are trained to sound helpful, and confirming their own output feels helpful. Self-check is not a real defense layer. The verification has to come from a different system — a whitelist, a URL fetcher, an independent source lookup, a human.
Editorial review as the only defense
"Our editors will catch it" is what everyone says until an editor doesn't. Layer 5 is essential but it's the last layer, not the only layer. Every failure that reaches an editor is a failure your earlier layers missed, and editors have finite attention. Load-bearing checks that can be mechanized should be mechanized, so editorial attention goes to the judgment calls that can't.
Prohibiting AI outright
Prohibitions push AI use underground. Analysts still use ChatGPT on their personal accounts, journalists still paste drafts into Claude, researchers still ask Gemini for literature scans — they just don't mention it in workflow docs or check-in comments. A prohibition regime gives you no visibility into the actual workflow, no ability to enforce standards, and no defense when errors happen. Building a good defense framework is strictly better than pretending the tool doesn't exist.
What the framework doesn't solve
Two categories of problem this framework isn't equipped for.
Bias and viewpoint diversity. A whitelist enforces which outlets you cite, not which viewpoints you cover. A research pipeline can be perfectly whitelist-compliant and still narrow, one-sided, or biased in what it emphasizes. Diversity of sources within a whitelist is a separate discipline that starts with editorial judgment about what balance means for your context. The framework catches errors of fact; it doesn't catch errors of framing.
Novel-source discovery. Whitelists are conservative by construction. If your work depends on breaking new sources into your process — investigative journalism, emerging-market analysis, cutting-edge research — whitelist enforcement will slow you down. That's fine, and probably correct, when the risk of a bad new source outweighs the cost of missing a good one. Not fine when you're specifically trying to expand coverage. Adjust the discipline to the context.
The path forward
If you're building this framework at your team, do it in this order. Layer 1 (prompt discipline) first — it's free and it's a mindset shift more than a tooling change. Layer 2 (whitelist enforcement) next, using our Source Whitelist Checker or your equivalent. Layer 3 (existence verification) when you have web-fetch MCP capability set up. Layer 4 (claim re-verification) reserved for load-bearing claims, not applied blanket. Layer 5 (editorial review) always — but now doing the job it's actually best at.
Skills and Servers is building out a Research & Analysis pillar with more Skills covering these layers — citation formatters, diversity scorers, existence verifiers, primary-source resolvers. Browse the category as it grows. Same design and quality discipline as the Data & Analytics cluster we built out first.
The meta-point: research integrity is a workflow property, not a tool property. No single Skill or MCP or prompt guarantees good research. What you're building is a pipeline where errors get caught early and cheap. If you get the framework right, AI accelerates the work without compromising the standards. If you skip it, you'll spend the productivity gain on catching mistakes — and eventually one will slip past and remind you why the framework matters.
Better to build it now.