# How Generative Engine Optimization Works: Retrieval, Fan-Out, Passages and What Your Site Controls

**How generative engine optimization works comes down to one pipeline: the assistant turns a question into several searches, retrieves candidate pages, cuts them into passages, picks the passages that answer the question most directly, and writes an answer that cites some of them. You cannot change the model, but you can control whether your pages are reachable, whether they parse cleanly, and whether they contain passages worth quoting.**

This post is the technical companion to our overview [What Is Generative Engine Optimization (GEO), and How Is It Different From SEO?](https://www.linkedin.com/pulse/what-generative-engine-optimization-geo-how-different-from-seo-pygpf/) on LinkedIn. That one defines the term. Here we open the box, show where a site owner has real levers, and give you snippets for each.

*Last updated: 15 November 2026*

## What is generative engine optimization, in one paragraph?

Generative engine optimization (GEO) is the practice of making your content easy for AI answer systems to retrieve, understand and cite. The term was formalised in a paper that defined generative engines as systems that gather information from multiple sources and summarise it with a language model, then tested ways for content creators to improve their visibility in those answers (Aggarwal et al., [arXiv 2311.09735](https://arxiv.org/abs/2311.09735), November 2023). Generative engine optimization is the engineering and editorial work that sits between "our page exists" and "the answer names us".

## How generative engine optimization works: the pipeline

Nobody outside the vendors can see the exact internals of ChatGPT, Gemini or Perplexity, so treat the steps below as a model. It matches what the public papers and documentation describe, not a leaked spec.

1. **Query understanding and fan-out.** The system rewrites your question into one or more search queries. Google says AI Overviews and AI Mode "may use a query fan-out technique", issuing multiple related searches across subtopics and data sources to build a response (Google Search Central, "AI features and your website").
2. **Retrieval.** Each query returns candidate documents from a search index or a live fetch. This is classic information retrieval, which is why SEO basics still matter.
3. **Chunking and passage selection.** Pages are split into smaller pieces, and the ones that best match the question are passed to the model. The original retrieval-augmented generation paper described this pattern: combine a language model's built-in knowledge with documents retrieved at answer time (Lewis et al., [arXiv 2005.11401](https://arxiv.org/abs/2005.11401), May 2020).
4. **Synthesis.** The model writes one answer from the selected passages, plus whatever it learned in training.
5. **Attribution.** Some systems attach links to the sources that supported the answer. Which sources get a link is a product decision, and it differs by engine.

[![How generative engine optimization works in five stages: query fan-out, retrieval, chunking and passage selection, synthesis, then citation](https://cdn.hashnode.com/uploads/covers/6af5acaf9e632a67d6ec0ccd/e1895ae0-a5d9-46d6-acc1-9537187b43d3.png)](https://www.linkedin.com/pulse/what-generative-engine-optimization-geo-how-different-from-seo-pygpf/)

Two consequences follow for anyone doing generative engine optimization. First, you do not compete as a whole page; you compete as a passage. Second, a page that was never retrieved cannot be cited, so crawl access comes before wording.

## Memory versus live search: two paths to a mention

An answer can come from the model's training data (memory) or from retrieval (live). The mix depends on the product and the question. Memory-based mentions reflect what the wider web said about you over time and move slowly. Retrieval-based mentions can change within days of a page change, because the system fetches fresh pages. When you test, record which mode you saw: an answer with source links usually involved retrieval.

## What can a website control? Four levers

This is the practical core of how generative engine optimization works for a site owner.

| Lever | Pipeline stage | What you control |
|---|---|---|
| Crawl access | Retrieval | robots.txt rules, firewall and CDN bot rules, status codes |
| Clean, parseable HTML | Chunking | Headings, semantic markup, text not hidden in scripts |
| Quotable passages | Passage selection | Direct answers, definitions, sourced numbers |
| Structured data and consistent facts | Synthesis and attribution | JSON-LD that matches visible text, same facts everywhere |

### Lever 1: crawl access (robots.txt for AI crawlers)

OpenAI documents separate robots for different jobs and says each setting is independent: a site can allow OAI-SearchBot to appear in ChatGPT search results while disallowing GPTBot, which relates to training use. It also lists ChatGPT-User for requests triggered by a user's action in ChatGPT (OpenAI crawler documentation). Google documents that a page must be indexed and eligible to show in Search with a snippet to appear as a supporting link in AI Overviews or AI Mode, with no additional technical requirements (Google Search Central, "AI features and your website").

A deliberate robots.txt looks like this:

```txt
# Let ChatGPT search and user-triggered fetches reach public pages
User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /

# Training crawler: your policy decision, independent of the two above
User-agent: GPTBot
Disallow: /private/

# Regular search crawlers feed Google and Bing AI features too
User-agent: Googlebot
Allow: /

User-agent: Bingbot
Allow: /

Sitemap: https://www.example.com/sitemap.xml
```

Check it with a script, not by eye. Python's standard library parses robots.txt:

```python
from urllib import robotparser

SITE = "https://www.example.com"
BOTS = ["OAI-SearchBot", "ChatGPT-User", "GPTBot", "Googlebot", "Bingbot"]
KEY_PAGES = ["/", "/services/", "/blog/how-it-works/"]

rp = robotparser.RobotFileParser(SITE + "/robots.txt")
rp.read()

for bot in BOTS:
    for path in KEY_PAGES:
        ok = rp.can_fetch(bot, SITE + path)
        print(f"{bot:14} {path:24} {'allowed' if ok else 'BLOCKED'}")
```

robots.txt is only half of access. A CDN or firewall rule can still return 403 to a bot that robots.txt allows, so also fetch a key page with each user-agent string from the vendor's documentation and confirm a 200 status.

### Lever 2: clean HTML that chunks well

Chunkers usually split on headings and paragraph boundaries. You cannot see the chunker, but you can make a clean split likely:

- One H1, then H2/H3 in a logical order, each heading phrased as the question it answers.
- Put the answer in the first one or two sentences under a heading, then the detail.
- Keep key facts in server-rendered text, not only in tabs, images or client-side scripts. Google's documentation says supporting content should be available as textual content, and that structured data should match the visible text on the page.
- Prefer real tables and lists for comparisons; they survive extraction better than a screenshot of a table.

### Lever 3: passages worth quoting

The GEO paper tested content-rewriting methods on a benchmark of queries and reported that GEO can boost visibility by up to 40% in generative engine responses, with the efficacy varying across domains (Aggarwal et al., arXiv 2311.09735). Treat that as the paper's finding from one benchmark, not a promise for every engine or site.

What a quotable passage looks like in practice:

- It answers one question in 40 to 80 words and makes sense without the paragraphs around it.
- It names the entity in full ("Example Co offers..." not "we offer...") because a lifted passage loses its context.
- Every statistic carries a source and a month or year.

### Lever 4: structured data and consistent facts

Google says there is no special schema.org markup needed for AI features and you do not need new machine-readable or "AI text" files to appear in them (Google Search Central, "AI features and your website"). So structured data is not a GEO trick. It is hygiene: it states who you are in a form that matches the visible page, which helps classic search features and removes ambiguity for any system that reads it. A minimal Organization block:

```html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Co",
  "url": "https://www.example.com/",
  "description": "Example Co builds scheduling software for dental clinics.",
  "sameAs": [
    "https://www.linkedin.com/company/example-co/",
    "https://x.com/exampleco"
  ]
}
</script>
```

And an FAQ block, only where the same questions and answers are visible on the page (see [FAQPage on schema.org](https://schema.org/FAQPage)):

```html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What does Example Co do?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Example Co builds scheduling software for dental clinics."
    }
  }]
}
</script>
```

Keep the `sameAs` links and the description identical to what your profiles say. Consistency across sources is the part of generative engine optimization that no single page edit can fix.

[![Four levers a site controls in generative engine optimization: crawl access, clean HTML, quotable passages, structured data and consistent facts](https://cdn.hashnode.com/uploads/covers/6af5acaf9e632a67d6ec0ccd/0973d950-9dd4-4795-a5c9-400cc591b853.png)](https://www.linkedin.com/pulse/what-generative-engine-optimization-geo-how-different-from-seo-pygpf/)

## Step by step: audit your own pages

Here is a short routine to apply the four levers to one page. It takes under an hour.

1. **List 10 buyer questions** for the page's topic, written as people type them.
2. **Run the robots check** above for the bots you care about, and fetch the page with a bot user-agent to confirm it returns 200.
3. **View the raw HTML** (not the rendered page) and confirm the answer text is present.
4. **Split the page into passages** and test each one, using the script below.
5. **Rewrite weak passages**: lead with the answer, name the entity, add a sourced number.
6. **Validate JSON-LD** and confirm it matches visible text.
7. **Ask the assistants** your 10 questions, note whether you are named and which sources are cited, and repeat monthly.

A small passage checker for step 4. It is a heuristic, not a model of any engine: it only flags passages that are too long, too thin, lack a number or a named entity, or open with a pronoun.

```python
import re, sys, requests
from bs4 import BeautifulSoup

ENTITY = "Example Co"          # your brand as it should appear in full
PRONOUNS = ("we ", "our ", "it ", "this ", "they ")

def passages(url):
    html = requests.get(url, timeout=20,
                        headers={"User-Agent": "passage-check/1.0"}).text
    soup = BeautifulSoup(html, "html.parser")
    for tag in soup(["script", "style", "nav", "footer"]):
        tag.decompose()
    heading, buf = "(intro)", []
    for el in soup.find_all(["h1", "h2", "h3", "p", "li"]):
        text = el.get_text(" ", strip=True)
        if el.name in ("h1", "h2", "h3"):
            if buf:
                yield heading, " ".join(buf)
            heading, buf = text, []
        elif text:
            buf.append(text)
    if buf:
        yield heading, " ".join(buf)

def flags(text):
    n = len(text.split())
    out = []
    if n > 120: out.append(f"long ({n} words)")
    if n < 25: out.append(f"thin ({n} words)")
    if not re.search(r"\d", text): out.append("no number")
    if ENTITY.lower() not in text.lower(): out.append("entity not named")
    if text.lower().startswith(PRONOUNS): out.append("opens with a pronoun")
    return out

for heading, text in passages(sys.argv[1]):
    f = flags(text)
    print(("OK   " if not f else "FIX  ") + heading[:60], "|", ", ".join(f))
```

Run it as `python passage_check.py https://www.example.com/page`. Not every passage needs a number, so read the output as a to-do list, not a score.

## GEO vs SEO: what changes in the pipeline

The honest answer to GEO vs SEO is that they share the first two stages. Retrieval is search, so crawlability, indexing, internal links and page quality still decide whether you are a candidate. Google states that its AI features are rooted in its core Search ranking and quality systems and that SEO best practices remain relevant (Google Search Central, "AI features and your website").

What is new sits at stages 3 to 5: passage-level competition, synthesis from several sources, and attribution rules. The shape of the outcome also differs. Pew Research Center found that Google users who saw an AI summary clicked a traditional result in 8% of visits, compared with 15% when no summary appeared (Pew Research Center, July 2025). If the answer absorbs the click, being named inside it becomes a goal of its own. For a fuller comparison of what carries over and what is new work, see our Medium piece [GEO vs SEO: What Carries Over and What Is Genuinely New Work](https://adrinafaleriro.medium.com/geo-vs-seo-what-carries-over-and-what-is-genuinely-new-work-5c2d7a9cad82).

| Question | SEO | GEO |
|---|---|---|
| Unit of competition | Page | Passage and entity |
| Success signal | Rank, click | Named, described accurately, cited |
| Stage that decides | Retrieval and ranking | Passage selection and attribution |
| How you test | Rank tracker, Search Console | Fixed question set, repeated runs |

## Generative engine optimization vs AEO

Generative engine optimization vs AEO is mostly a question of scope. AEO (answer engine optimization) grew out of formatting content so a search engine could lift one direct answer, as in featured snippets and voice answers. GEO covers every system that writes an answer from retrieved passages and memory, including assistants outside a search results page. In pipeline terms, AEO work lives mainly in stage 3, passage selection; GEO adds access, consistency and measurement around it. Our newsletter post [Two acronyms, one meeting](https://sigzenai.substack.com/p/two-acronyms-one-meeting-and-a-marketing) looks at how teams can use the two terms without arguing about them. In practice you write the same page for both.

## How to test whether it is working

Because answers vary between runs, one screenshot proves nothing. Keep a fixed question set, run each question several times on separate days, and log whether you were named and which URLs were cited. When something changes, change one thing at a time: a robots rule, a rewritten passage, a corrected profile. Retrieval-driven answers can respond within days to weeks; memory-driven ones move over months as models update and new mentions accumulate. Do not promise a ranking, and be wary of anyone who does, since the engines' selection rules are not published.

## Common mistakes

- **Blocking the wrong bot.** A blanket rule for unknown agents can hide you from the search bots you wanted.
- **Answers hidden in scripts.** If the text is only produced by client-side rendering, a fetcher may see an empty shell.
- **Pronoun passages.** "We help teams do this" cannot be quoted once lifted out of its page.
- **Schema that disagrees with the page.** Markup that contradicts visible text is worse than none.
- **Unsourced statistics.** A number with no source gives the model nothing to trust and readers nothing to check.
- **Treating the tactics as guaranteed.** The 40% figure is a benchmark result with variation by domain, not a forecast for your site.

## FAQ

### How does generative engine optimization work in simple terms?

Generative engine optimization works by making your pages easy to retrieve, split into clear passages and quote. The assistant searches, selects the passages that best answer the question, writes one answer and may cite sources. You influence access, structure and wording, not the model itself.

### What is the difference between GEO vs SEO?

SEO aims to rank a page in a list of results. GEO aims to get your brand named, described correctly and cited inside an AI-written answer. They share the retrieval stage, so strong SEO remains the base.

### Is generative engine optimization vs AEO a real difference?

Mostly in scope. AEO focuses on direct answers inside search features; generative engine optimization covers every assistant that writes answers from retrieved passages and memory. The daily work, such as direct answers, clear headings and consistent facts, overlaps heavily.

### Should I block GPTBot in robots.txt?

That is your policy decision. OpenAI documents that its crawler settings are independent, so you can allow OAI-SearchBot for ChatGPT search results and disallow GPTBot separately. Decide on training use first, then make sure you did not block the search bot by accident.

### Do I need special schema or an llms.txt file?

For Google's AI features, Google says you do not need new machine-readable files, AI text files or special schema.org markup. Standard structured data that matches the visible page is still good hygiene, and it is cheap to maintain.

### How long until I see a change?

Retrieval-based answers can shift within days to weeks after a page or access change. Memory-based answers change slowly as models are updated. Measure the same question set monthly and look at the trend.

## Wrapping up

How generative engine optimization works is less mysterious than the acronym suggests: a retrieval pipeline picks passages, a model writes the answer, and a few sources get credit. Open the gates for the right crawlers, ship clean HTML, write passages that survive being quoted out of context, and keep your facts identical everywhere. Then test with a fixed question set and judge the trend. For the plain-language version and a starting plan for small teams, read [our LinkedIn overview of generative engine optimization](https://www.linkedin.com/pulse/what-generative-engine-optimization-geo-how-different-from-seo-pygpf/).

Sigzen AI helps businesses get found, described accurately and recommended in AI search, and we run this kind of answer monitoring for teams that would rather read the report than maintain the scripts.

