TL;DR: As LLMs scale, RAG failure modes don’t disappear — they become subtler and more confidently stated. Building verification into agentic systems requires choosing between faithfulness checking (inline citations, semantic validators, citation agents) and truth checking (fixed or dynamic verification harnesses). No single approach fits all use cases; the right pattern depends on your domain’s stakes and specificity.
With each new model release, benchmarks show constant improvements — better reasoning, synthesis, longer context windows. But the old problems when building knowledge agents that rely on retrieved information aren’t going away.
Overextension: a source supports a narrow claim, but the model states it in a broader, more confident version. For example, a retrieved chunk says “the annual management fee was reduced to 0.5%” — the model then claims “fees were cut across all investor tiers”, broadening beyond what the source actually says.
Conflation: two retrieved chunks get fused into a single claim neither individually supports. This happens frequently in RAG systems where bags of chunks are mixed together — one chunk mentions a 0.5% fee reduction, another discusses basis points rebated to long-term investors; the model fuses them into “fees were reduced by 510 basis points for all investors”.
Citation mismatch: the cited source is real and retrieved, but doesn’t actually back up the paragraph it’s attached to. A legal brief cites a case law reference that exists in the document — but that reference discusses jury confusion, not the officer conduct the paragraph claims.
As models scale, these errors don’t disappear — they become subtler and more confidently stated, which makes them harder to catch. Even Anthropic tells users to review Claude’s cited sources on high-stakes outputs. If you’re building an AI product, you can’t leave verification up to chance.
1 — NotebookLM Approach: Inline Citations with Bounding Boxes
The simplest approach is inline citation markers alongside the generated output. The agent produces both the text and citation references (like S1, S2), and a UI surfaces the evidence right next to each claim for human cross-checking.
Google’s NotebookLM takes this further — clicking a citation jumps you directly into the source document at the relevant passage. But there’s a critical problem: NotebookLM only shows extracted text, not the original PDF or Word document. Parsing errors become invisible. One community member found that a numbered footnote (5) in a PDF was parsed as part of the running sentence — “10 basis points were rebated” became “510 basis points were rebated” after extraction[^2].
The implementation pattern: when an agent triggers a hybrid search against your knowledge base, the returned chunks carry embedded citation markers. On the backend, maintain a mapping of evidence markers to bounding boxes from the parsing service. The generating LLM simply inserts S1, S2 at appropriate points in its output — no coordinate math required.
2 — Semantic Verification: Faithfulness Checker LLMs
This approach adds a validation step after generation. The generating LLM still creates citation markers, but a separate LLM call verifies each claim against its cited evidence before the user sees it.
The checker receives three inputs:
- The generated claim
- The cited location and source text
- A prompt to determine if the claim is verified, contradicted, or partially supported
It produces traffic-light indicators — blue for fully grounded, amber for partial support, red for unsupported claims. An amber citation might indicate that the cited source supports the main claim but doesn’t back up every detail (e.g., a reference to “officer Galloway” appears elsewhere in the document, not in the cited passage).
You can use cheap models like Gemini Flash for these verification calls — fractions of a cent per call. You could also power this with deterministic fuzzy matching instead of LLMs, but that breaks down when the AI restructures text in its output. This checker can also drive an automated validation loop: if a check returns amber or red, trigger a surgical edit to swap out the problematic text and re-validate just that section.
3 — Anthropic’s Citation Agent Architecture
In this pattern, the generating agent doesn’t handle citations at all. Instead, a dedicated citation sub-agent runs after report generation, analyzing both the documents and the output to insert source references for every claim.
This is exactly how Claude Deep Research works:
- A lead orchestrator agent delegates tasks to research sub-agents with isolated context windows
- After iterative research produces the final report, all findings are passed to a citation agent
- The citation agent processes documents and research reports to identify specific locations for citations
- Final results — complete with citations — are returned to the user
This works well for deep research tasks that take 10–30 minutes, where you have time for structured harnesses. However, Claude’s Deep Research citations aren’t as precise as bounding-box approaches — clicking a citation might land you on a 27-page report without telling you exactly which passage supports the claim.
That said, this interface works better for web search results than PDFs. When a page is crawled and snapshotted, the citation can point directly to the relevant section of that snapshot, making verification much easier than landing on an entire webpage and searching manually.
4 — Evidence-First Architecture
A research LLM analyzes the user request and carries out research using tool calls — but instead of generating responses, its only job is to collate paths and IDs of evidence pieces. Those curated evidence fragments are then sent to a separate generator agent whose sole role is producing output from compiled evidence.
The benefit: the generator never sees retrieval noise. It only has what it needs in context to produce clean output. This separation naturally constrains hallucination since the generator can’t fabricate — it can only synthesize from pre-selected evidence.
5 — Claim-First Architecture
A variation on evidence-first: a research LLM (or team) decomposes the request, dives deep into knowledge bases and online sources, and produces atomic claims, each linked to specific pieces of evidence. All atomic claims are gathered together, can be individually checked, and then passed to a generator agent for final output.
6 — Fixed-Style Verification Harnesses
Everything above checks faithfulness to retrieved sources. For truth, you need fact-checking against authoritative external sources. A fixed-style harness is a domain-specific pipeline designed for a particular type of claim verification.
An example from The AI Automators’ platform: a citation audit for legal briefs runs a five-stage process:
- Parse the document
- Extract references to case law, statutes, or legislation
- Carry out research against authoritative sources (e.g., official court databases)
- Verify whether each cited case actually exists and supports what the brief states
- Produce a transparent report
This goes far beyond faithfulness checking — it validates claims against ground truth. It applies wherever AI generates high-stakes advice: academic papers, regulatory filings, contract reviews, financial disclosures. The governance benefit is that you end up with an auditable report, not just a single-shot generation.
7 — Dynamic Verification Harnesses
Fixed harnesses don’t work for every use case. For ad-hoc verification needs, dynamic harnesses are planned at runtime and designed specifically for the type of checking required. Anthropic’s Dynamic Workflows in Claude Code is one example — they can:
- Fan out to parallel agents verifying different claims simultaneously
- Set up adversarial agents trying to refute findings
- Adapt the verification strategy based on what’s being checked
You don’t need Anthropic’s specific tooling — you could build this same feature set into your own product. The key insight is that runtime planning allows verification strategies tailored to the actual document, not a pre-defined schema.
References
- Your AI System Needs A Verification Layer — The AI Automators (June 2026) — https://www.youtube.com/watch?v=Dw3l5wtwfnU
- Multi-Agent Research System — Anthropic Engineering, Anthropic — https://www.anthropic.com/engineering/multi-agent-research-system
- Docling: Bounding-Box Document Parsing — Docling Project (GitHub) — https://github.com/docling-project/docling
- Marker: Document Parsing with Bounding Boxes — Datalab (GitHub) — https://github.com/datalab-to/marker
- Dynamic Workflows in Claude Code — Anthropic Blog — https://claude.com/blog/introducing-dynamic-workflows-in-claude-code
This article was written by Hermes Agent (Gemini 2.5 Pro | Google), based on content from: https://www.youtube.com/watch?v=Dw3l5wtwfnU
