Query fan-out and section citability in AI search

The traditional search pipeline was straightforward: a user typed a query, the engine looked it up in an inverted index, and the ranking systems returned an ordered list of URLs. Google AI Mode, AI Overviews, ChatGPT Search and Perplexity add a step in between. Before an answer is written, one question can be turned into several related searches, and the answer cites the pages those searches found.

That step does not run on every question. In the Ahrefs study discussed below, ChatGPT answered about 6 in 7 prompts without searching the web at all. When a search does run, though, the answer is assembled from specific passages, tables and code samples rather than from a ranked list of ten links, so it matters which parts of a page can stand on their own.

#What is query fan-out and how it works in large language models

Query fan-out is Google’s name for splitting one question into several searches that run at the same time. Google’s guide to generative AI features defines it as “a set of concurrent, related queries generated by the model to request more information and fetch additional relevant search results to address the user’s query” (Google Search Central). Its example: for “how to fix a lawn that’s full of weeds”, the fan-out queries might include “best herbicides for lawns”, “remove weeds without chemicals” and “how to prevent weeds in lawn”.

Google used the term when it announced AI Mode on 5 March 2025, describing a technique that issues “multiple related searches concurrently across subtopics and multiple data sources”. On 20 May 2025 it added Deep Search, which uses the same technique and “can issue hundreds of searches” (Google blog). Google’s AI features documentation says both AI Overviews and AI Mode may use fan-out, and that the two features may use different models and techniques, so their answers and links vary.

How many sub-queries run depends on the product. Ahrefs analysed 66.6 million free, logged-out ChatGPT responses and their 15 million fan-out queries from August and September 2026 (Ahrefs). Only 14.4 percent of responses searched the web, and those ran about 1.6 fan-out queries on average. In the same article, Ahrefs lists Suganthan Mohanadasan’s logged-in tests with 15 to 40 fan-outs on a Thinking model, and Peec data where 56.5 percent of prompts had two or more. Free sessions search less than paid or reasoning models.

Consider an enterprise technical prompt:

What is the best headless WordPress setup for a 50,000 product WooCommerce catalog with multi-region ERP synchronization?

Vendors do not publish their full pipelines. The sequence below is a generic description of retrieval-augmented generation, which Google says its AI features rely on, with an illustrative fan-out for this prompt:

1. Reading the question: the model identifies the subjects (WordPress, headless architecture, WooCommerce, ERP) and the constraints (50,000 products, several regions).
2. Generating related searches (the fan-out stage), for example:
   • Query 1: WPGraphQL vs REST API batch query latency 50k WooCommerce products
   • Query 2: Headless WooCommerce ERP webhook queue congestion mitigation
   • Query 3: Astro SSR vs Next.js static build performance high SKU catalog
   • Query 4: WooCommerce High-Performance Order Storage database memory footprint
3. Retrieval: Google says it relies on its core Search ranking systems to retrieve relevant pages from its index. Suganthan Mohanadasan tested this on Gemini’s API: a request about a page that never existed produced searches but no hit in his server log, because grounding reads Google’s index, not the live page (Suganthan Mohanadasan).
4. Reviewing the retrieved pages: the systems review specific information from those pages.
5. Writing the answer with links: the response shows clickable links to pages that support the information in it.

The consequence for content teams is that one page can be considered for several of these related searches, as long as it answers them in text the engine can find. Google adds a limit: creating separate pages for every fan-out query, primarily to manipulate rankings or AI responses, violates its scaled content abuse spam policy.

#Why self-contained sections earn citations

Generative engines cite specific sections, not pages as a whole. That is the starting point of Lumar’s guide to section citability: “In our experience, generative search engines cite specific sections of content, rather than pages as a whole” (Lumar). Lumar presents this as practitioner experience, not a measured study, and gives no word counts or citation percentages.

Its section test has five checks: the section answers one question, makes sense without the surrounding text, contains the facts it needs (units, versions, conditions), stays on one topic, and has enough detail without drifting. On length, Lumar says only that very short sections lose context and very long ones mix ideas, and that “there’s no simple way to measure the ideal section length”. Google goes further for its own features: there is no requirement to break content into small pieces, and no ideal page length.

#How to write paragraphs that do not depend on surrounding context

A citable section delivers its point without the paragraph before it. Lumar asks whether a section contains pronouns like this, it or they without a clear reference, or phrases like “as mentioned above”. Suganthan Mohanadasan’s grounding checker flagged the same problem in his own article: the sentence “It then retries the request with a PAYMENT-SIGNATURE header” scored 8 percent for making sense on its own, because nobody knows what “it” is once the sentence is pulled out. Consider this weak example:

This technology significantly accelerates page load times while lowering server costs…

Out of context, “this technology” refers to nothing. A self-contained version names the subject and states a fact that can be checked:

Google AI Overviews and AI Mode can show a page as a supporting link only if the page is indexed and eligible to appear in Google Search with a snippet.

The second sentence names the products, the condition and the result. It can be quoted on its own without changing its meaning. Suganthan adds the honest caveat: he has not demonstrated that making a sentence stand alone increases its chance of being cited, so treat this as an editorial check rather than a ranking factor.

#Why the opening sentence under a heading matters

Lumar lists “early clarity” among the traits generative systems may favour: key information introduced upfront. A section that opens with an anecdote or a rhetorical question takes longer to state its point, and a passage pulled out of the page may not include the later sentences.

Writing the answer first (BLUF, bottom line up front) is a simple way to apply this. The opening sentence below a heading gives the definition or verdict. The sentences after it add benchmarks, edge cases and implementation details.

#What concrete facts work better than marketing adjectives

Words like revolutionary, game-changing, seamless and next-generation carry no checkable information. Lumar’s “dense facts” trait and its “necessary facts” check point the same way. Sections that are easier to quote usually contain:

• Measurements with units (milliseconds, megabytes, requests per second).
• Exact names and versions of software, protocols and specifications (HTTP/3, PHP 8.4, OAuth 2.1, RFC 9110).
• The conditions under which a statement holds, and the cause behind a result.

#Why tables and specifications suit AI citations

Lumar’s examples of sections more likely to be cited include step-by-step processes and specifications. Both hold facts that make sense on their own, which is what a comparison table does too. We found no published study that measures how much more often tables are cited than prose, so the case for a table is clarity: when the content is a comparison across the same attributes, a table states it without the reader (or a parser) having to untangle sentences.

The following table contrasts classic SEO assumptions with what the sources above say about generative search:

#How to connect your site to Wikidata so entities are unambiguous

Google does not describe Wikidata as a trust signal for Gemini or AI Mode. Its guide says structured data is not required for generative AI search and that there is no special schema.org markup to add, while recommending structured data as part of normal SEO for rich results. What Suganthan Mohanadasan does document about Gemini is more practical:

• The Gemini API returns groundingMetadata with the searches Gemini wrote (webSearchQueries), the pages it used (groundingChunks) and the links between those pages and parts of the answer (groundingSupports).
• The cited sources change between runs of the same question, so one test is an anecdote. He runs each query five times and counts recurrence.
• In his September tests, publishers whose robots.txt disallowed Google-Extended were cited in 0 of 10 runs, against 6 of 6 for publishers that allowed it.

#JSON-LD with Wikidata entities for WordPress and Astro

Linking the topics of an article to Wikidata QIDs is still useful for disambiguation: “Astro” the framework and “Astro” the company name stop being the same string. This site uses about and mentions for that. Note that knowsAbout belongs on a Person or Organization, not on an article:

{
  "@context": "https://schema.org",
  "@type": "TechArticle",
  "headline": "Query fan-out and section citability in AI search",
  "description": "Technical guide to query fan-out and self-contained content sections.",
  "inLanguage": "en",
  "author": {
    "@type": "Organization",
    "name": "wppoland.com",
    "url": "https://wppoland.com",
    "knowsAbout": [
      {
        "@type": "Thing",
        "name": "Search engine optimization",
        "sameAs": "https://www.wikidata.org/wiki/Q180711"
      },
      {
        "@type": "Thing",
        "name": "Web development",
        "sameAs": "https://www.wikidata.org/wiki/Q386275"
      }
    ]
  },
  "about": [
    {
      "@type": "Thing",
      "name": "Large language model",
      "sameAs": "https://www.wikidata.org/wiki/Q115305900"
    },
    {
      "@type": "Thing",
      "name": "Information retrieval",
      "sameAs": "https://www.wikidata.org/wiki/Q816826"
    }
  ]
}

The markup makes it explicit which entities the article is about. It does not by itself earn citations, and Google says so.

#What AI search crawlers and AI providers expect

Two things changed in 2026 for teams doing generative search work. On the policy side, iPullRank’s Mike King points out that Anthropic’s 2026 Usage Policy update, published on 8 October and effective 12 November, prohibits using Claude to manipulate the sources that search engines or AI systems draw answers from, for example with networks of sites posing as independent (iPullRank). The same article notes that Google treats fan-out page spinning as scaled content abuse. Both lines point at the same playbook: manufactured independence and mass-produced pages.

On the technical side, the constraint is rendering. Vercel and MERJ reported in December 2024 that none of the major AI crawlers rendered JavaScript, including OpenAI’s and Anthropic’s, while Gemini uses Googlebot’s infrastructure and renders fully (Vercel).

#How to serve content AI crawlers can read

To make sure the crawlers behind ChatGPT, Claude and Perplexity see the content, the infrastructure should follow three principles:

1. Put the content in the server HTML: a single-page application that fills an empty container in the browser shows these crawlers an empty page. Astro static output, server rendering or a classic WordPress theme sends the text in the first response.
2. Use semantic HTML where it fits: article, section, header and definition lists (dl, dt, dd) mark topic boundaries more clearly than utility-class divs. Google’s guide adds that perfect semantic HTML is not required and that it mainly helps people using screen readers.
3. Check what the crawler received: fetch the page without JavaScript (curl, or the URL Inspection tool for Googlebot) and confirm the text is there.

#How to build fact cards in WordPress and Astro code

A fact card is an editorial pattern, not a ranking signal: a box that states one fact with its unit, conditions and source, so the claim survives being quoted on its own. It maps directly onto Lumar’s “necessary facts” check. Making the source and metric required fields keeps editors from publishing a claim without them.

Here is an Astro component for that pattern:

---
interface Props {
  entityName: string;
  claim: string;
  metric: string;
  sourceUrl: string;
  sourceName: string;
}

const { entityName, claim, metric, sourceUrl, sourceName } = Astro.props;
---

<aside class="fact-card my-6 p-6 border-l-4 border-emerald-600 bg-slate-50 dark:bg-slate-900 rounded-r-lg">
  <p class="text-xs font-mono uppercase tracking-wider text-slate-500 mb-2">{entityName}</p>
  <p class="text-lg font-semibold text-slate-900 dark:text-slate-100 mb-2">{claim}</p>
  <p class="text-sm font-medium text-emerald-700 dark:text-emerald-400">
    <strong>{metric}</strong>, source: <a href={sourceUrl}>{sourceName}</a>
  </p>
</aside>

The card renders as plain HTML in the server response. It deliberately avoids ClaimReview markup: that type is meant for fact-checking organisations reviewing someone else’s claims, not for a publisher’s own statements.

#How to register a fact card block in WordPress Gutenberg

In WordPress, the same pattern works as a custom Gutenberg block or an ACF block. The PHP render template should output nothing when a required field is empty, rather than inventing filler text:

<?php
/**
 * ACF block template: fact card
 *
 * @param array $block Block settings and attributes.
 */

$entity_name = get_field( 'fact_entity_name' );
$core_claim  = get_field( 'fact_claim' );
$metric      = get_field( 'fact_metric' );
$source_url  = get_field( 'fact_source_url' );

if ( ! $core_claim || ! $source_url ) {
    return;
}
?>
<section class="fact-card border border-slate-200 p-5 rounded my-4">
    <h3 class="text-base font-bold text-slate-800 mb-1"><?php echo esc_html( $entity_name ); ?></h3>
    <p class="text-slate-700 text-sm leading-relaxed mb-3"><?php echo esc_html( $core_claim ); ?></p>
    <p class="text-xs font-mono text-emerald-700">
        <strong><?php echo esc_html( $metric ); ?></strong>,
        <a href="<?php echo esc_url( $source_url ); ?>"><?php esc_html_e( 'source', 'textdomain' ); ?></a>
    </p>
</section>

Editors then cannot publish a card without a claim and a source.

#How to serve clean Markdown to AI crawlers with Cloudflare Workers

Some AI agents ask for Markdown with an Accept: text/markdown header. wppoland.com answers such requests from its Cloudflare Pages middleware, which runs on Workers: it strips scripts, styles and navigation from the rendered HTML and returns the main content as Markdown, with a canonical Link header pointing at the HTML page.

1. Smaller payload: a single request to this article on 17 October 2026 returned 248,112 bytes of uncompressed HTML and 27,215 bytes of Markdown.
2. Fewer layout artefacts: headings, lists and tables arrive as Markdown structure instead of nested markup.
3. Same URL, separate cache entry: the HTML response carries Vary: Accept, so caches do not serve the Markdown version to browsers.

Google Search does not use this. Its guide says you do not need Markdown or other special files to appear in Google Search, including its generative AI features. The Markdown response is for other agents that request it.

#What enterprise commerce queries decision-makers ask in generative search

In enterprise commerce, the related searches reflect integration problems. A technical director might ask Gemini or Perplexity about re-platforming:

How to decouple WooCommerce with Astro for a multi-currency store handling 10,000 orders daily with SAP ERP sync?

A fan-out for this prompt could split it into searches such as:

• WooCommerce WPGraphQL order ingestion throughput under 10k daily volume
• Stripe and Adyen multi-currency webhook reconciliation in headless Astro
• SAP S/4HANA REST API synchronization queue bottleneck mitigation in WordPress
• PCI-DSS compliance scope reduction when decoupling checkout on Cloudflare Pages

A general overview page has little to offer each of these searches. Google’s guide recommends “non-commodity” content with first-hand experience, and Ahrefs reports that ChatGPT has been shifting citations from sites that summarise to sources that produce the information. For a commerce integrator, that means publishing what only the team has measured: webhook latencies under load, queue retry strategies, memory profiles at high order volume.

#How to audit your site for AI search readiness in 6 steps

To check whether content meets these standards, run this six-step review:

+-------------------------------------------------------------------+
|                  SECTION CITABILITY REVIEW WORKFLOW               |
+-------------------------------------------------------------------+
                                  |
                                  v
         [ STEP 1: Pronoun scan across paragraph openers ]
                 (Replace "it", "this", "as above")
                                  |
                                  v
       [ STEP 2: Answer-first check beneath headings ]
              (Definition or verdict in the first sentence)
                                  |
                                  v
     [ STEP 3: Tables for comparisons and specifications ]
               (Same attributes compared? Use a table)
                                  |
                                  v
        [ STEP 4: Entity markup check ]
               (about and mentions QIDs match the text)
                                  |
                                  v
       [ STEP 5: Repeated prompt tests in AI engines ]
               (Several runs per query, count recurrence)
                                  |
                                  v
     [ STEP 6: Crawler access and log inspection ]
               (robots.txt, CDN rules, GPTBot, ClaudeBot)

1. Paragraph pronoun audit: scan paragraph openers. If a section begins with it, they, this approach or as stated above, replace the pronoun with the name of the technology or concept.
2. Heading answer-first review: check that the first sentence beneath every H2 and H3 states the answer before the background.
3. Table check: where a section compares several items across the same attributes (parameters, plans, benchmarks), use an HTML table.
4. Entity markup check: confirm that the QIDs in about and mentions resolve to the entities the text actually discusses.
5. Repeated prompt testing: submit the related searches to Perplexity, ChatGPT Search and Gemini several times each, because citations change between runs. Use Search Console’s Generative AI performance report for Google’s own features.
6. Access and log analysis: confirm that the site is included in generative AI features in Search Console, that robots.txt and CDN rules allow the crawlers you want (Googlebot, OAI-SearchBot, PerplexityBot, ClaudeBot), and watch server logs for their status codes and crawl frequency.

#How to architect web content for generative answer engines

Generative search does not replace technical SEO. Google’s own position is that optimising for generative AI search is still SEO: a page has to be indexed and eligible for a snippet, and chunking, llms.txt and special markup are not required. The published data on fan-out is narrower than the claims around it: ChatGPT’s free model searched in 14.4 percent of responses in the Ahrefs sample, and Gemini’s cited sources change from run to run.

What holds up across the sources is plain: sections that answer one question in their own words, facts with units and sources, content in the server HTML, and information the team has measured itself rather than summarised from others.