Article contents
A generative engine does not answer from memory: it searches, reads, then writes
A language model on its own knows the world as it was at the end of its training, with gaps and approximations. To answer a question about current events or a purchasing choice, generative search products do not rely on that memory: they search for documents, extract passages from them and give them to the model to read before it writes. This architecture, retrieval-augmented generation or RAG, is common to ChatGPT with search, Perplexity, Claude with web search and Google's generated answers.
The chain has four steps: interpreting the prompt and breaking it down into queries, retrieving passages from an index, reranking and filtering those passages, then synthesising with source attribution. The details vary from one provider to another and part of it is undocumented. Google has publicly described its fan-out queries for AI Mode; OpenAI, Anthropic and Perplexity document their search crawlers; the rest comes from the technical literature on RAG and from our own measurements.
Step 1: the prompt is interpreted, then broken down into sub-queries
A prompt is not a query. “I run a twelve-person accountancy firm in Lyon, which invoicing software should I choose to move to e-invoicing?” contains an explicit intent, two contextual constraints, an implicit regulatory deadline and a size criterion. No page was ever written for that sentence. The engine therefore rewrites it into several short queries, close to what one types into a search bar, each covering one angle of the request.
This decomposition is the most visible of the four steps. Google has named it “query fan-out” and presents it as the heart of AI Mode; Perplexity, ChatGPT and Claude display in their interface the searches run before the answer. The number of queries depends on the question: a request for a definition produces one or two, a request for a comparison can produce around ten.
The consequence for a page is direct: it is never compared with the prompt, but with one of the sub-queries. A page that covers a topic “in general” matches none of them precisely. A section that answers an identifiable sub-query gets a chance every time that sub-query is generated, whatever the original prompt. That is what explains why a narrow, precise article appears in answers to questions it was never aimed at.
Step 2: retrieval works on passages, not on pages
Each sub-query interrogates an index. That index is not a list of whole pages: in most documented implementations, pages are split into segments of a few dozen to a few hundred words, and each segment is represented both by its keywords and by a vector that encodes its meaning. The search combines these two representations, which makes it possible to find a passage that answers the sub-query without repeating its exact terms.
This splitting changes the unit of competition. In traditional SEO, a whole URL is measured against other URLs. In generative search, a segment of your page is measured against segments from all other pages, including those on your own site. The engine does not read the page from top to bottom to extract its message; it picks the segment closest to the sub-query and evaluates it as it stands.
Three properties of a page follow from this mechanism.
- Each section must stand on its own. An answer spread across five paragraphs separated by digressions produces no strong segment; five average segments lose to one precise segment from a competitor.
- The section heading is part of the segment. Whether or not the splitting follows the headings, the subheading remains the best clue to the topic covered; if it repeats the wording of a sub-query, it aligns the segment with it.
- The segment must exist in the HTML the crawler receives. Whatever is injected by JavaScript after loading, hidden behind a consent banner rendered server-side or blocked at firewall level never enters the index. This is the first of the four conditions for a citation, and it is checked before any rewriting.
The index itself is built by dedicated crawlers: OAI-SearchBot for ChatGPT search, Claude-SearchBot for Claude, PerplexityBot for Perplexity, Googlebot for AI Overviews and AI Mode. They are distinct from training crawlers, and their crawl frequency is not published; in the server logs we analyse, it varies widely according to the site's reputation and the freshness of its content.
Step 3: candidate passages are reranked, deduplicated and filtered
Retrieval brings back far more segments than the model can read: dozens, sometimes hundreds per sub-query. The next step reduces that volume to a few passages. A reranking model scores each candidate on its ability to answer, by reading the query-passage pair rather than by vocabulary similarity. Filters are added, whose list the providers do not publish but whose effects can be observed: freshness for evolving topics, apparent reliability of the source, diversity of domains.
- 01CandidatesDozens of segments per sub-query, retained by lexical and semantic similarity.
- 02RerankingEach query-passage pair is scored on its ability to answer, not on its keywords.
- 03DeduplicationPassages that say the same thing in the same words are merged; only one survives.
- 04FiltersFreshness, apparent reliability of the source, diversity of domains.
- 05Model contextOnly a few passages, with their URL, are passed on for writing.
Deduplication penalises silently. If your presentation page says what your twenty competitors' pages say (“tailored support”, “a team of experts”), the engine sees twenty copies of the same passage and keeps only one, rarely yours. Conversely, a piece of data that you alone publish (a measured timeframe, a price, a named method) has no duplicate; it passes the filter every time it answers a sub-query.
The reliability filter is where the identity of the source comes into play: the engine asks itself whether it can rely on this passage. A page whose author and publisher are identified, consistent with what is found elsewhere and marked up in structured data, gives that evaluation more to hold on to than an anonymous page. We compare traditional and generative criteria in SEO vs GEO: what really changes in source selection criteria.
Step 4: the model writes and attributes
The selected passages are placed in the model's context window with an instruction: answer by relying on them and indicate where each claim comes from. The model does not copy; it paraphrases, merges, reorders. One sentence may combine two sources, and attribution is made by a link or a number after the sentence. Attribution errors exist, and the providers acknowledge them: a claim may be attached to a source that does not contain it exactly, a nuance may vanish in the paraphrase.
What this step asks of a passage comes down to four properties. They do not serve to get selected, but to survive the rewriting without distortion and to be attributed to the right entity.
- 1Self-containedUnderstandable without the previous paragraph: no “this one”, “this solution”, “as seen above”.Otherwise: the model fills the gap with its own assumption.
- 2Quantified and datedA number with its unit, a date, an explicit condition.Otherwise: the paraphrase rounds off or generalises.
- 3NamedThe entity speaking is in the passage: “at SEO360”, not “at our agency”.Otherwise: the citation loses your name in favour of the URL alone.
- 4UnambiguousOne claim per sentence, with no double negative and no irony.Otherwise: the model picks one reading, not always yours.
The third point is the most often neglected. On a site, “we” obviously means the company; taken out of the page, in a sixty-word passage, “we” no longer refers to anyone, and the model will cite “an agency” or the URL. Naming the entity in the important passages costs a few words and changes the way the brand appears.
What each step demands of a page
The table below links each step to what it demands and to the symptom observed when the demand is not met. This is our diagnostic grid: we work back up the chain to the step that discarded the page.
| Step | What the engine does | What the page must offer | Symptom if missing |
|---|---|---|---|
| 1. Decomposition | Rewrites the prompt into short sub-queries | Sections aligned with real sub-queries, in their vocabulary | The page is never a candidate, even on its own topic |
| 2. Retrieval | Looks for segments in an index | Complete HTML, accessible to AI search crawlers, split into self-contained sections | The page is absent from the index or produces no strong segment in it |
| 3. Reranking | Scores, deduplicates, filters | Data of your own, an honest date, an identified entity | The page is a candidate but always discarded in favour of another |
| 4. Synthesis | Paraphrases and attributes | Self-contained, quantified, named, unambiguous passages | The page is cited but distorted, or without the brand name |
Table: scroll horizontally.
The next diagram compares, across the four steps, a page written as direct answers and its original narrative version.
Illustrative data. What to read into it: the narrative version is still a candidate almost one time in two, but it drops off at reranking and synthesis; the rewriting work acts above all on steps 3 and 4.
Where the engines differ, and why that changes little in the method
The four steps are common to all, but each provider tunes them differently, which explains part of the gaps in citation share between engines for the same site.
- Google (AI Overviews, AI Mode) draws on its classic index: a page must first be indexed there. The fan-out decomposition is wide, which favours sites that cover an intent from several angles.
- ChatGPT decides whether to search or answer from memory; when it searches, it relies, according to OpenAI, on its own index and on third-party providers. A page absent from those indexes is never a candidate, even if it ranks well on Google.
- Perplexity searches systematically and cites abundantly, with numbered sources; the number of places per answer is higher there, but competition from third-party sources is stronger.
- Claude triggers search as a tool, when the question requires it; it keeps few sources and cites them precisely, which makes step 3 more selective.
These differences show up in the measurements, but they do not change what a page must be: self-contained sections, each aligned with a sub-query, accessible to search crawlers, backed by an identified entity and by data that exists nowhere else. Such a page is a candidate everywhere; the engines' settings then decide how often it is selected.
The typical drop-off points, step by step
When a page does not appear, the cause sits at a specific step, and fixing it at another step achieves nothing. Here are the most frequent drop-offs, sorted by step.
- Step 1. Subheadings that resemble no query (“Our approach”, “Why choose us”), on a page that nevertheless covers the right topic.
- Step 2. Main content rendered in JavaScript, a firewall that rejects
OAI-SearchBotorPerplexityBot, an answer scattered across the whole page with no section to carry it. - Step 3. Wording interchangeable with that of competitors, no visible date, an anonymous author and a company with no structured data.
- Step 4. Passages that refer back to the context (“this solution”, “as indicated above”), figures without units, promises without conditions.
The four conditions we use in audits, accessible, citable, identified and corroborated, map onto this chain: accessibility governs step 2, citability steps 2 and 4, identification and corroboration step 3. The diagnosis finds the step that discards the page; the action plan satisfies it, then moves on to the next.
What to remember
- A generative engine follows four steps: prompt decomposition, passage retrieval, reranking, cited synthesis. Each one discards pages.
- Your page is never compared with the prompt, but with short sub-queries; each section must target one, in its vocabulary.
- The unit of competition is the text segment, not the URL: a scattered answer produces no strong segment.
- Reranking deduplicates generic wording and filters on freshness and source identity; only data of your own gets through.
- A passage survives paraphrase if it is self-contained, quantified, dated, named and unambiguous.
Frequently asked questions
What is retrieval-augmented generation (RAG)?
It is the architecture of generative engines: before writing, the system searches for document passages in an index and supplies them to the language model, which relies on them to answer and cites their sources. It compensates for the limits of the model's memory, frozen at the date of its training. ChatGPT with search, Perplexity, Claude with web search and Google's generated answers work on this principle, with different settings.
Why is a page that ranks well on Google not necessarily cited by AI?
Because selection operates on text segments, not on URLs, and at steps where Google's ranking plays no part. A page can be first on a query and contain no self-contained section that answers the sub-query generated by the engine; it can also be discarded at reranking for wording identical to that of ten competitors, or not be indexed at all by AI search crawlers.
How many sub-queries does an engine generate from a prompt?
It depends on the complexity of the question and on the engine. A request for a definition produces one or two; a request for a comparison or a choice can produce around ten. Google has described this fan-out decomposition for AI Mode, and Perplexity displays the queries run in its deep research mode. The exact number is not published; what matters is that a page section targets a precise sub-query rather than the whole prompt.
Do you need to write one page per sub-query?
No, one section per sub-query is enough, provided it stands on its own. The index splits pages into segments; a long, well-structured page, where each subheading matches a real question and each first sentence answers it, produces as many candidate segments as it has sections. Multiplying short pages, on the contrary, spreads authority thin and complicates corroboration.
Can the engine distort what my page says?
Yes. At the synthesis step, the model paraphrases and merges several sources; a nuance can disappear, a figure can be rounded, a claim can be attached to a source that does not contain it exactly. The providers acknowledge these errors. The risk is reduced by writing self-contained passages, with figures accompanied by their unit and their date, one claim per sentence, and the name of the entity in the passage itself.
An SEO practitioner since 2001, Kamel Malek runs SEO360 (Alicante, Valencia, Madrid, Paris). He has published three books on visibility in generative engines, including Generative Engine Optimization and Rétablir les faits.
