How AI Search Decides What to Cite

When ChatGPT, Perplexity, or Google's AI Mode answers a question with citations, the common assumption is that the cited pages "ranked #1." They did not. There is no single ranked list. What you are looking at is the output of a multi-stage retrieval pipeline, and every stage quietly decides which pages survive to become a citation.

This is not a guess about a black box. The broad shape of the pipeline is corroborated by the engine makers themselves. OpenAI describes how ChatGPT search rewrites a question into one or more search queries and can run a further, more specific search after reading the first results, and Google documents the "query fan-out" its AI systems use to break one question into many. What follows maps that public backbone onto what we consistently observe when we run the deployed engines under controlled, repeated conditions in 2026 and shows where generative engine optimization (GEO) actually has leverage.

The pipeline, in one paragraph

A generative answer is produced roughly like this: the model first decides whether to retrieve at all (the gate); if it retrieves, it rewrites the question into machine queries and often fans them out (query rewriting / fan-out); each query returns a candidate set from an underlying index (candidate generation); the candidates are reordered by relevance (reranking); a subset is read and its claims are attached to generated sentences (grounding / attribution); and finally a short passage from each source is surfaced as the citation snippet (extraction). Optimization is not "rank higher." It is "survive more of these stages, for more of the queries the model actually issues."

Stage 1: The retrieval gate: does it even search?

The first and most underappreciated stage is a decision, not a search. The model weighs its parametric knowledge (what it already holds from training) against the value of retrieving. For a large class of questions (how-to advice, general concepts, "is X worth it" judgments) it answers from memory and never touches the web.

This has a hard consequence most GEO advice ignores: for a query that does not trigger retrieval, no page can be cited, however well it is optimized. The gate is not a fixed rule you can look up. In our repeated-prompt observations it behaves probabilistically, so the same question can open the retrieval path on one run and answer from memory on the next. The lesson is that "does this query retrieve?" is itself something to be measured, not assumed.

Stage 2: Query rewriting and fan-out

If the gate opens, the model rarely searches your literal question. It rewrites it into cleaner machine queries and, for anything non-trivial, fans out into several. This decomposes a broad ask into sub-queries, adds qualifiers, and often issues a second, more specific wave after reading the first. Both OpenAI and Google describe versions of this publicly; the behavior itself is not in dispute.

Two properties matter for optimization. First, the rewrites are non-deterministic: ask the same question repeatedly and the exact query strings differ almost every time. Second, the fan-out usually includes a refinement wave that gets far more specific than the opening query, narrowing toward exact product names, specifications, or sub-questions. In our observations, much of the citing happens on that later, specific wave rather than on the broad opening query. The implication: you cannot optimize for "the query," because there isn't one. You optimize for a distribution of derived queries.

Stage 3: Candidate generation

Each machine query hits an underlying index and returns a candidate set. This is the stage that behaves most like classic search, and it is where public discoverability is decisive: a page the index cannot surface for the issued query never enters the pool, so nothing downstream can save it. Crawlability, indexation, and server-side rendering are not "nice to have" here. They are the entry ticket. If your facts render only after client-side JavaScript, the retrieval layer can see an effectively empty page.

Stage 4: Reranking

The candidate set is then reordered by a relevance model, a reranker that scores each candidate against the query. (The exact architecture is not disclosed by the engines; what is observable is the behavior.) This is where lexical and semantic alignment between the query and the page's title and opening lines does real work. It is also where a lot of GEO folklore quietly fails: the reranker is scoring relevance to the issued query, not length, keyword density, or the presence of a particular schema type. Pages win this stage by matching the specific tokens of the query that was actually issued, such as a product name, a spec, or a constraint.

Stage 5: Grounding and attribution

The surviving sources are read and used to ground the answer: sentences are attached to sources so the model can cite them. This is the step that converts a candidate into a citation, and it is the least observable from the outside. Engines do not expose which passage was ingested or how a claim was attributed. What we can say is that grounding favors sources that state the relevant fact plainly, in a form that maps cleanly onto the claim being made. A page that contains the answer as a discrete, checkable statement is a better grounding target than one that merely discusses the topic.

Stage 6: Extraction: citable claims have to live in visible text

Finally, a short passage is surfaced as the citation snippet. Here a common piece of advice needs narrowing. Structured data (JSON-LD) genuinely helps search systems understand and discover a page. Google states as much plainly. But in our observations the citation snippet itself is drawn from the rendered page body, the visible text a reader sees, not from the structured data. Facts that live only in JSON-LD, or that appear only after JavaScript executes, tend not to show up in the quoted snippet. Keep your schema because it aids discovery. If a fact is worth citing, it also has to exist as a plain sentence in the visible, server-rendered body.

The pipeline is general. Your failure point isn't.

Everything above is the shared machinery. It holds for any brand in any category, which is exactly why it doesn't tell you what to change. The pipeline is general; the stage where your pages disappear is specific, and it is not visible from the outside.

Which of your prompts open the gate at all? Which derived queries recur for your category, and which are one-offs? At which stage (candidate generation, reranking, or grounding) do your pages drop out, and why? None of those are general knowledge. They are measurements, and they differ by brand, category, and market.

Turning those answers into citations is its own discipline: the work of raising how often a brand enters the candidate set and how often it lands in the recommended distribution. A field guide like this one explains why that work matters; doing it is a separate thing, and it begins with measuring where your own pages fall out, not with reading about the general path. Most of the market is still optimizing for a keyword box, and the pipeline filters them out at a stage they never thought to measure.

FAQ

Does ChatGPT use Bing's index?

ChatGPT Search is widely understood to draw on Bing or Microsoft's search infrastructure, but OpenAI does not publicly document one exclusive underlying index. Our repeated tests did not strongly support a Bing-only explanation. Citation overlap was at least as consistent, and in some runs more consistent, with other search engines. The safer conclusion is that observed citations do not prove that ChatGPT uses Google's index, Bing alone, or any single index. The six stages above still hold regardless of which provider or combination sits underneath.

If my page has perfect schema, will it get cited?

Structured data helps you get discovered and understood, but in our observations the quoted snippet comes from the visible body. Treat schema as a discoverability aid, not the source of the citation, and make sure the citable fact also exists as plain text.

Why did my page rank on Google but never get cited by AI search?

Because "ranking" and "surviving the pipeline" are different outcomes. A page can be indexed and even rank while still failing the gate (the query didn't retrieve), the fan-out (the model issued different queries), or grounding (the fact wasn't stated as a discrete claim).

What's the first thing to check?

Whether your target query class retrieves at all. That is something to measure on your own prompts, not to read off a general rule. A query class that opens the gate for one brand's prompts may stay closed for yours.

Aeolo maps the queries AI engines issue, tracks where your pages enter or drop out of retrieval, and shows which sources win the citation. Request beta access to find where your brand is missing from the answer.