GEOLLMRAGcitations

How LLMs Choose What to Cite: RAG, Retrieval & Trust

June 27, 2026

When an AI answer engine cites a source, it isn't rewarding that page for existing — it's the output of a pipeline: interpret the question, retrieve a set of candidate documents from an index or a live web query, score each one for relevance and trustworthiness, then decide, while composing the answer, whether a specific passage is worth attaching a link to. Nothing in that chain is guaranteed, which is why two similarly-ranked pages can get very different citation treatment.

The four-step pipeline: from question to citation

Google's AI Overviews, ChatGPT's search feature, Perplexity, Gemini, and Claude each implement some version of the same four-stage sequence. The exact plumbing differs — a proprietary search index here, a general web search API there — but the shape of the pipeline is consistent, and each vendor documents pieces of it.

1. Interpreting the user's intent

Before anything gets retrieved, the system decides what kind of question it's actually answering. Anthropic's documentation for Claude's web search tool is explicit about this triage: Claude is meant to search when a request "depends on information that is current, changing, or outside its training data" — recent events, prices, specific organizations or products — and to answer directly, without searching or citing anything, for "established facts, math, science fundamentals... creative writing... [or] analysis of content already provided in the conversation." That distinction matters for GEO: if a query resolves to the second bucket, no source gets retrieved at all, and no page — however well-optimized — can be cited for it.

2. Retrieving candidate sources

Once the system decides external information is needed, it pulls a set of candidates. Google describes this for AI Overviews and AI Mode as a "query fan-out" technique — "issuing multiple related searches across subtopics and data sources" to develop a response, rather than running one query. OpenAI's Responses API distinguishes two retrieval modes: a fast "non-reasoning" pass that sends the query straight to a web search tool and uses the top results, and an "agentic" mode in which a reasoning model runs searches as part of its own chain of thought, reading results and deciding whether to search again. At this stage, a page can only become a candidate if it's indexed and reachable — Google states plainly that a page "must be indexed and eligible to be shown in Google Search with a snippet" just to qualify as a supporting link.

3. Scoring relevance and authority

Candidates then get filtered and ranked — not just for topical relevance, but for whether the system is willing to rely on them. This is where signals resembling E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) — Google's own framework for judging content quality — come into play, alongside freshness (is this current enough for the topic?) and structural clarity (is the claim stated in a way that can be lifted cleanly?). A source can be topically relevant and still lose at this stage if it reads as unsupported, outdated, or diffuse.

4. Synthesizing the answer and deciding to cite

Finally, the model writes the answer and — separately — decides which parts get attached to a source. This isn't a single decision. Anthropic's web search tool attaches a cited_text field (up to 150 characters, taken verbatim from the page) to each citation, alongside the URL and title. OpenAI's Responses API returns inline url_citation annotations for the sources actually referenced in the text, plus a separate sources field listing every URL the model consulted — which is "often greater than the number of citations." Being read by the model and being cited by the model are two different outcomes, and most retrieved pages don't make the second cut.

What RAG actually is (and where the term comes from)

"RAG" gets used loosely in marketing content, so it's worth being precise about where it comes from. The term was introduced in a 2020 paper by Patrick Lewis and colleagues at Facebook AI Research (now Meta AI), published at NeurIPS 2020: Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. Its core idea: large language models store knowledge in their parameters ("parametric memory"), but that knowledge is fixed at training time, hard to inspect, and hard to update. RAG pairs a parametric generator with "non-parametric memory" — an external, searchable index the model can query at inference time — so it can pull in facts it was never trained to memorize.

Concretely, the original architecture combined a Dense Passage Retriever (DPR), a bi-encoder that finds relevant text chunks by comparing vector embeddings of the query and the documents, with a BART-large sequence-to-sequence model that generated the final text. The non-parametric memory was a December 2018 dump of Wikipedia, split into roughly 21 million 100-word passages and searched via approximate nearest-neighbor lookup. The paper tested two variants — RAG-Sequence, which conditions the entire generated answer on one retrieved passage, and RAG-Token, which can draw on a different passage for each generated word — and showed both beat purely parametric baselines on open-domain question answering (Natural Questions, TriviaQA, WebQuestions, CuratedTrec) while producing more specific, less repetitive text on generation tasks like Jeopardy-question generation and fact verification (FEVER).

That's academic RAG: a fixed, pre-indexed corpus and a retriever trained jointly with the generator. What ChatGPT's search feature, Gemini's Google Search grounding, Claude's web search tool, and Perplexity do today is a descendant of that idea, not a copy of it. The corpus is the live web instead of a frozen Wikipedia snapshot; the retriever is a full search engine (or search API) instead of a small trained bi-encoder; and the model itself decides when to issue a query, reads the results, and can search again — closer to an agent using a tool than to the original single-shot retrieve-then-generate loop. Google's own guide to optimizing content for its generative AI features confirms the lineage directly, describing its AI features as relying on retrieval-augmented generation combined with query fan-out to surface indexed content with citations. The name stuck; the implementation has grown well beyond the 2020 paper.

How engines judge whether a source is trustworthy

Retrieval gets a page in front of the model. Whether it survives to become a citation is a separate question, and it hinges on signals that are reasonably well documented — at least on Google's side, which publishes explicit guidance that other vendors largely echo in practice.

E-E-A-T. Google's framework for judging content quality — Experience, Expertise, Authoritativeness, Trustworthiness — was extended from E-A-T to E-E-A-T in December 2022 specifically to credit content demonstrating first-hand use or direct experience, not just credentials. Google's documentation states that among the four, trustworthiness matters most, and it frames E-E-A-T not as a single field to fill in, but as "a mix of factors that can help determine which content demonstrates" these qualities — judged in practice by human quality raters whose assessments help train Google's automated systems, rather than a direct, checkable ranking input.

YMYL weighting. Some topics are held to a higher bar. Google calls these "Your Money or Your Life" (YMYL) topics — content that "could significantly impact the health, financial stability, or safety of people, or the welfare or well-being of society" — and states plainly that its systems "give even more weight to content that aligns with strong E-E-A-T" in these categories. A recipe blog and a page about drug interactions are not held to the same evidentiary standard.

Freshness. Time-sensitive queries push retrieval toward recently updated content; stable, definitional queries don't need it. This falls directly out of how query fan-out and live retrieval work — a page discussing last year's pricing or a deprecated feature is a weaker candidate the moment the underlying facts have moved on, independent of how well-written it is.

Structure and extractability. This is the signal least likely to appear in any vendor's official documentation, but it follows directly from the citation mechanics above: if a system's citation mechanism grabs a short, self-contained span of verbatim text — as Claude's cited_text field does, capped at 150 characters — and pairs it with a URL, then a claim buried inside a long, hedge-filled paragraph is mechanically harder to lift cleanly than the same claim stated in one direct sentence. "Structure helps" isn't a vague content-marketing platitude here; it's a direct consequence of how extraction works at the API level.

Why some engines cite more than others

Citation behavior isn't a stylistic accident — it follows from documented differences in how each product treats search as a default versus an optional tool, and in how each interface decides what to surface.

Google's AI Overviews and AI Mode are built on top of Search itself, so grounding is close to universal by design. Google states its systems "identify more supporting web pages, allowing us to display a wider and more diverse set of helpful links associated with the response than with a classic web search." Citation here is closer to the default state than a special case.

Gemini, via its API, treats search as an invoked tool rather than an always-on step: "the model analyzes the prompt and determines if a Google Search can improve the answer" before deciding to run one, and Gemini 3 is billed per search query it actually executes — a pricing model that only makes sense if search is genuinely conditional rather than constant.

Claude documents an explicit, fairly narrow trigger condition for search — current events, prices, specific people, organizations, or products, or an explicit request — and answers a large share of questions from parametric memory alone, with no retrieval and therefore no citation possible.

ChatGPT, via OpenAI's web search tool (which powers its search feature), runs one of two modes depending on the model: a quick non-reasoning pass that mostly forwards top search results, or an agentic mode where a reasoning model plans and re-runs searches as needed. OpenAI's documentation also draws a distinction worth remembering for GEO purposes: the inline citations shown to a user are a curated subset, while the full sources list — every URL the model actually consulted — is "often greater than the number of citations." A page can be read by the model and still not make the visible citation list.

Perplexity is built differently from the ground up: it's positioned as a search-first answer engine rather than a general assistant with a search tool bolted on, and its interface is designed to foreground numbered source citations as a core product feature rather than an optional add-on.

The practical takeaway: whether your content gets seen by a model and whether it gets cited are governed by different mechanisms, and the gap between the two varies by platform. Optimizing for one engine's documented behavior doesn't guarantee the same outcome on another.

What this means for your content

None of this changes GEO's basic playbook, but it explains why each element of that playbook works mechanically, not just anecdotally.

  • Stay indexable and crawlable. Google is explicit that a page must already be "indexed and eligible to be shown in Google Search with a snippet" to qualify as an AI Overviews source. A page that can't clear ordinary indexing never reaches the retrieval stage for at least one major engine, regardless of content quality.
  • Write the claim as one extractable sentence. Citation mechanisms lift short, specific spans of text — Claude's citation field is capped at 150 characters. A fact stated in one direct sentence is far easier to extract cleanly than the same fact implied across a paragraph of qualifiers.
  • Make expertise and experience visible, not just implied. Author identity, credentials, and evidence of first-hand use are the concrete things E-E-A-T asks reviewers — and by extension, the systems trained on their judgments — to look for, particularly on YMYL-adjacent topics where the evidentiary bar is explicitly higher.
  • Keep time-sensitive pages current. Anything tied to pricing, versions, regulations, or availability should show a real update, not just a changed timestamp. Retrieval favors recency specifically for queries where the underlying facts change.
  • Don't rely on structured data to do the work. Google states directly that "structured data isn't required for generative AI search, and there's no special schema.org markup you need to add." Schema still helps with broader discoverability and disambiguation, but it isn't a documented citation shortcut.
  • Expect partial credit. Being retrieved, read, and summarized without a visible citation is a real and common outcome — OpenAI's own documentation confirms the consulted-sources list typically runs larger than the cited-sources list. Tracking whether your content is being used at all, not only whether it's linked, is part of measuring GEO performance honestly.

FAQ

Do AI engines always cite the pages they actually used?

No. OpenAI's documentation shows a platform can consult more sources than it displays as citations — the "sources" field is described as "often greater than the number of citations." A model can be influenced by a page without ever surfacing it as a link.

Is what ChatGPT, Gemini, and Perplexity do today the same as the original RAG paper?

Conceptually related, not identical. The 2020 Lewis et al. paper described a fixed Wikipedia index paired with a jointly-trained retriever and generator. Current answer engines swap in live web search or search APIs for the static index and let the model itself decide when and how often to query — closer to a tool-calling agent than the original single-pass retrieve-then-generate architecture.

Does strong SEO ranking guarantee AI citation?

No, but it helps clear the first hurdle. Google states a page must be indexed and snippet-eligible in classic Search to even qualify as an AI Overviews source. Passing that bar gets a page into the candidate pool; it doesn't guarantee it survives the relevance, trust, and extractability filtering that follows.

Does adding JSON-LD schema guarantee my page gets cited?

No. Google's own generative AI optimization guide states structured data "isn't required for generative AI search, and there's no special schema.org markup you need to add." It can still help disambiguate content type and authorship, but it isn't a documented citation trigger.

Why does my content get cited on one engine but not another?

Because each engine documents a different trigger for search and a different citation policy. Google's AI Overviews ground nearly every answer by design; Claude and Gemini's API treat search as a tool invoked only for certain query types; and how many of the consulted sources actually get shown as citations differs by product.

Sources

GEOCARA

Start your free trial

Audit your site and see how AI engines perceive you.

Start your free trial Run a free audit ↗
Back to the blog