Query Fan-Out: Why AI Search Shows (or Hides) Your Page for Questions You Never Targeted

Type "best running shoes for flat feet if I'm training for a marathon" into Google's AI Mode. You asked one question. Behind the glass, Google didn't run one search. It ran a fistful of them — stability shoes, overpronation, marathon cushioning, arch support — and stitched the answer together from all of them. Your page can win a slot in that answer for a phrase you never put on it. It can also get left out of a question you were sure you owned.

That hidden step has a name: query fan-out. It's a big part of why AI search feels unpredictable, and it quietly rewrites what "ranking" even means. This is the deep dive on one mechanism from how LLMs actually work — that post introduces fan-out in passing; here we open it all the way up.

One question becomes many searches — and your page can win, or lose, each of them separately.

What query fan-out actually is

A traditional search engine takes your query, matches it against an index, and hands back a ranked list of ten blue links. One query in, one ranked list out. You optimized a page for a keyword, and if you ranked, you were visible. Simple deal.

AI search breaks that one-to-one deal. Before it writes a single word of an answer, the engine expands your one prompt into many smaller sub-queries — each aimed at a different subtopic, angle, or implied sub-question — runs a separate search for each, gathers the results, and only then synthesizes a reply. One question in; many searches run; one blended answer out. It does this because a good answer to a messy real-world question needs to cover several things at once, and your single phrasing rarely names all of them.

Google named the technique directly. Its Search Central docs say both AI Overviews and AI Mode "may use a 'query fan-out' technique," issuing "multiple related searches across subtopics and data sources." Google's I/O announcement puts it in plainer words: AI Mode "uses our query fan-out technique, breaking down your question into subtopics and issuing a multitude of queries" on your behalf.

A worked example: one query, from prompt to citations

Let me trace a single real query through the whole machine, because the abstract version hides where pages actually win and lose. Say someone asks an AI engine: "what's the best CRM for a small real-estate team that also does email marketing?"

Step 1 — Interpret. The model first reads the prompt and works out what it's being asked. It pulls out the entities (CRM, small team, real estate) and the constraints (also does email marketing). No search has happened yet — this is pure language understanding, the thing covered in how LLMs work.

Step 2 — Decide to search. The model judges whether its own training is enough or whether it needs live results. For a "best X for Y" question where freshness and specific products matter, it reaches for the web tool. Google frames the whole point of grounding as a way to "reduce model hallucinations by basing responses on real-world information." A question like this one almost always triggers a search.

Step 3 — Fan out. Here's the step that matters. The engine doesn't search the user's sentence verbatim. It breaks the question into subtopics and issues several searches at once — Google's own words for AI Mode are "breaking down your question into subtopics and issuing a multitude of queries simultaneously." For our CRM question the fanned-out sub-queries might look like best CRM for real estate agents, small business CRM with built-in email marketing, real estate CRM pricing, CRM email automation comparison, and CRM for small teams reviews. Five searches, none of them the sentence the user typed.

Step 4 — Retrieve a wide net. Each sub-query pulls back a large candidate pool. The system is deliberately greedy here — it wants recall, so it over-fetches. Anthropic's retrieval writeup gives a clean public number for the shape of this: it performs "initial retrieval to get the top potentially relevant chunks (we used the top 150)." Across five sub-queries that's a big, messy pile of candidate passages — far more than can fit in an answer.

Step 5 — Rerank hard. A separate, cheaper step scores every candidate for how well it actually answers its sub-query, then throws most of them away. Anthropic again: "using a reranking model, give each chunk a score... select the top-K chunks (we used the top 20)," and they note reranking "provides better responses and reduces cost and latency because the model is processing less information." 150 down to 20. This is the cut where most pages lose.

Step 6 — Synthesize. The model now writes one blended answer from the survivors. It's reading a handful of passages across all the sub-queries and composing prose that satisfies the original question — the CRM that's strong on real estate and has email marketing and fits a small budget. Passages that each nailed one sub-query get woven together into a single recommendation.

Step 7 — Attach citations. Finally it links out, and this is the subtle part: the pages it links are a subset of the pages it read. OpenAI's web-search docs say it plainly — the "sources" field "returns the complete list of URLs the model consulted," and "the number of sources is often greater than the number of citations." You can be consulted and still not appear as a visible citation.

Notice what that trace means for your page. There were at least five chances to get pulled in, one per sub-query. You didn't need to rank for "best CRM for a small real-estate team that also does email marketing" — nobody writes that exact page. You needed to be the cleanest answer to one of the five sub-queries the engine invented. Win "small business CRM with built-in email marketing" decisively and you can land in an answer to a question you never saw.

How each engine fans out

Fan-out isn't a Google quirk. Every major AI answer engine does some version of it, because grounding an answer in live results means deciding what to search for first.

• Google AI Mode and AI Overviews run the explicit fan-out described above — breaking one question into subtopics and issuing many related searches across sources.
• Gemini's grounding pipeline does the same under the hood. Google's developer docs say that once search is on, "the model automatically generates one or multiple search queries and executes them," then synthesizes the results — with the stated goal of helping "reduce model hallucinations by basing responses on real-world information." If you want the engine-specific detail, we've covered whether Gemini actually searches the web separately.
• ChatGPT does it too, and its web-search docs expose the tell: a response's "sources" are the complete list of URLs the model consulted, and "the number of sources is often greater than the number of citations." It consulted many pages — across many sub-queries — and showed you only a few.
• Perplexity is built on the loop. Its help center says it "searches the internet in real-time, gathering insights from top-tier sources" before writing a cited answer, and its Research mode "performs dozens of searches automatically" for a single prompt. We dig into whether Perplexity really searches the web separately.
• Microsoft Copilot and Bing reformulate and expand too. Microsoft's Deep Search writeup describes GPT-4 taking the query and "expanding it into a more comprehensive description," then "rewriting the query on my behalf, and searching for those variations too" — and for an ambiguous prompt it uses GPT-4 to spell out each possible intent and searches them separately. Whether Copilot reaches for the web on a given turn is its own question, covered in whether Copilot searches the web.

Not every engine fans out equally hard. The heaviest expanders are the deliberate "deep" and "research" modes: Perplexity's Research mode runs "dozens of searches automatically," and Bing's Deep Search is explicitly a slower path that Microsoft says "can take up to 30 seconds," which is why it isn't run on every query. Google's AI Mode fans out aggressively by design. A plain chat turn in ChatGPT or Gemini with search on may fan out to only one or two queries — or skip searching entirely when the model thinks it already knows. Rule of thumb: the more a product markets "reasoning," "deep," or "research," the wider the fan-out, and the more separate sub-queries you have a shot at winning.

One honest nuance worth conceding: Google says engines "may use" fan-out — not always — and no engine publishes the actual sub-queries it ran, how many, or how it weighted them. We know the mechanism exists and is on by default in these products. We do not get a receipt for any single answer.

How many sub-queries — and why you can't see them

A fair question at this point: how many sub-queries does one prompt actually become? The honest answer is that nobody outside the engine knows for any given run, and that opacity is the whole problem.

Three things make the count impossible to pin down from the outside. First, nothing is published per answer. Google says its products "may use" fan-out and describes the technique, but no engine prints the list of sub-queries it ran, how many there were, or how it weighted them. You see the answer and the citations, never the search plan behind them.

Second, the count is variable, not fixed. Deep and research modes advertise dozens of searches; a quick factual turn might fan out to one, or skip searching altogether. The same product fans out wide for a broad comparison and barely at all for "what time is it in Tokyo." The number is a function of the question's breadth and the mode you're in, decided fresh each time.

Third, and most important for anyone trying to test this: it's sampled and non-deterministic. Ask the same engine the same question twice and you can get different sub-queries, a different candidate set, and a different citation list. The model samples its next tokens; the live index shifts under it. A page cited this morning can be gone this afternoon with nothing changed on your end.

Put those together and one conclusion falls out: a single screenshot of "look, we're cited" — or "look, we're not" — is close to meaningless. It's one sample from a noisy, hidden, run-to-run-variable process. The only honest way to read your standing is a rate measured over many prompts and many runs, which is the whole reason I keep pushing citation rate over anecdotes. One answer is a coin flip. A hundred answers is a signal.

Why this changes what "ranking" means

Here's the part that matters for your content, and it cuts both ways.

The upside: you can get cited for questions you never literally targeted. If your page cleanly answers "do stability shoes help overpronation," it can surface in the marathon-shoe answer above even though the word "marathon" never appears on it — because one of the fanned-out sub-queries was about overpronation, and you won that sub-query. Fan-out quietly rewards pages that cover a subtopic well, not just pages that match a head term word-for-word. This is a big part of the mechanical reason AEO and classic SEO pull apart, which is the whole subject of AEO vs SEO and what AEO is.

The downside is the mirror image. If you only optimized the single head term — one big page targeting "best running shoes," nothing addressing the implied sub-questions around it — you're invisible for most of the fan-out. The engine ran ten searches; your site was only built to answer one. Every sub-query you don't cover is a seat at the table you gave up before the answer was even written.

Found but not cited: the retrieve, rerank, synthesize, cite funnel

Winning a sub-query's search isn't the finish line. It's the qualifying round. Between "the engine searched for something you could answer" and "your link appears in the answer" sit three more gates, and a page can die at any of them.

Each fanned-out search pulls back a wide candidate set, and then a separate step reranks it down hard. Anthropic's own retrieval writeup is a clean illustration: it retrieves the top 150 candidates, then reranks to a top 20, because "reranking provides better responses and reduces cost and latency because the model is processing less information." Retrieved means found. Cited means you survived the rerank, the synthesis, and the citation step. So "we weren't mentioned" is really four different failures wearing one coat. Each has a different fix, and you can't fix what you can't tell apart.

Failure 1 — the engine never fanned out to a sub-query you'd win. The answer was built from subtopics you simply don't cover. Nothing about your page quality matters here; you weren't in the running. Fix: widen coverage. Map the real sub-questions around your topic (the next few sections are a whole method for this) and publish something that cleanly owns each one.

Failure 2 — it fanned out there, but you weren't retrieved. The sub-query ran and your page wasn't in the candidate pool at all. Usually that's a reach problem: the crawler can't fetch or render the page, the relevant answer isn't in the HTML, or the page is too off-topic for that phrasing to surface. Fix: make the page fetchable and parseable — server-rendered answer text, no robots block on the AI crawlers, the key passage in the initial HTML — and make sure a page actually targets that sub-question's language.

Failure 3 — you were retrieved, then reranked out. You made the 150 and not the 20. The reranker read your passage and judged something else a more direct answer to the sub-query. Fix: tighten the passage. State the sub-question's answer in the first sentence or two of a self-contained block, with the specifics — numbers, names, conditions — right there. Rerankers reward passages that are unambiguously about the thing being asked.

Failure 4 — you survived the rerank and still weren't cited. You were one of the roughly twenty the model read while writing — OpenAI calls these the "sources" — but it synthesized your point without linking you, or cited a competitor that said the same thing more quotably. Remember the gap: being consulted isn't being credited. Fix: be the most quotable, most specific source for the claim. Original data, a crisp definition, a clear stat with its context — the thing a model would rather point at than paraphrase.

The practical payoff of splitting these apart is that your fix is completely different depending on where you're dying. Failure 1 is a content-strategy problem. Failure 2 is a technical-SEO problem. Failures 3 and 4 are a writing problem. Guess wrong and you spend a quarter fixing the thing that wasn't broken. (The full seven-step version of this funnel lives in how LLMs work.)

What to actually do about it

Fan-out rewards a specific shape of content. Four moves:

1. Cover the whole subtopic cluster, not just the head term. Map the sub-questions a real person has around your main topic, and make sure something you own answers each one. Think in topic clusters, not single trophy pages.
2. Answer the implied sub-question directly. Fan-out generates literal sub-queries, so put literal answers in your copy. A section that restates the question and answers it in the first two sentences is exactly what a reranker scores well.
3. Make one section cleanly answer one sub-query. Self-contained blocks win. If the fact and the reason it matters sit in the same short section — rather than the claim in one place and the context three scrolls away — a chunk boundary can't separate them, and the reranker scores the whole, relevant thing.
4. Stay crawlable and retrievable. None of this counts if the engine's crawler can't reach or parse the page. Blocked in robots.txt, rendered client-side with nothing in the initial HTML, or gated behind a login, and you're never even a candidate for any sub-query.

For engine-specific tactics, getting cited by Gemini and the Perplexity citations playbook go deeper on each.

Content built for fan-out

Fan-out quietly rewrites the brief for what a good page is. The old brief was "one page, one keyword, rank it." The fan-out brief is "cover a question space so well that whatever sub-query the engine invents, something you own answers it cleanly." Here's what that looks like in practice, with the do and the don't for each.

Topic clusters, not trophy pages. A single 5,000-word "ultimate guide" to a head term is built for the old one-query world. Fan-out shreds it, because the engine runs ten searches and your one page can only be about so many things at a hub level. Do: build a cluster — a hub page plus a focused page for each real sub-question, interlinked. Don't: pour every subtopic into one monster URL and hope it ranks for all of them. Ten focused pages give the reranker ten clean targets; one sprawling page gives it a muddy one.

Passage-level, self-contained answers. Engines don't retrieve whole pages; they retrieve passages, and a reranker scores each chunk on its own. If the claim is in one paragraph and the context that makes it credible is three scrolls away, a chunk boundary can split them, and the chunk that gets scored is missing half the point. Do: keep the fact and the reason it matters in the same short block. Don't: bury the answer under 600 words of throat-clearing — the model may never read down that far.

Question-shaped headings. Fan-out generates literal questions. Headings that mirror those questions give retrieval an exact surface to match and give the reranker a clear signal of what a section is for. Do: write H2s and H3s as the question a person would type — "how much does X cost," not "pricing." Don't: use clever or vague headings ("the money bit") that match nothing a person would actually search. As a bonus, question-form headings are also how FAQ schema gets generated.

Semantic, server-rendered HTML. If the answer only exists after JavaScript runs, some crawlers never see it. If the page is a soup of nameless divs, the structure that tells a parser "this heading owns this answer" is gone. Do: put the answer in the initial HTML, inside real headings, lists, and paragraphs. Don't: rely on client-side rendering for the content that matters, or block the AI crawlers in robots.txt — the AI search glossary lists the bots to allow, and your server logs tell you whether they actually got through.

Structured data where it genuinely fits. Schema won't force a citation, but it labels your content in a machine-legible way — FAQ, HowTo, Product, Article — and that labeling helps the right passage get matched to the right sub-query. Do: mark up content that is genuinely structured, like a real FAQ or real product specs. Don't: staple schema onto content that doesn't match it; mismatched markup helps no one and can get flagged.

Internal linking that names the sub-topics. Descriptive anchor text tells crawlers how your cluster fits together and passes authority to the narrow pages that answer narrow questions. Do: link from the hub to each sub-answer with anchor text that is the sub-question. Don't: rely on "click here," and don't orphan your deepest, most answer-shaped pages where nothing links to them.

Freshness, honestly applied. For questions where recency is part of the answer — pricing, "best X in 2026," anything that changes — engines lean toward recently updated sources. Do: update the pages where currency matters, and show it (this post carries a visible last-updated date for exactly that reason). Don't: fake freshness by bumping a date with no new substance. That's padding, and it's the same instinct that makes a page worse for humans too.

From keywords to questions: finding your fan-out gaps

All of this depends on one thing you don't have yet: the actual list of sub-questions the engines are fanning out to in your space. You can't read their internal sub-queries, but you can reconstruct a very good approximation from the places where real people ask real questions. Five sources, roughly in order of value:

• Google's "People also ask" and autocomplete. Type your head term and read what Google suggests and what the PAA box unfolds. These are literal, common, question-shaped phrasings — close cousins of the sub-queries an engine would generate on its own.
• Reddit and niche forums. This is where people ask the messy, constraint-loaded questions they'd never type into a search box: "is X worth it if I already have Y." It's also a corpus the engines lean on heavily, which is its own topic in the Reddit AI citations playbook.
• Your own sales and support questions. The questions prospects ask before buying, and the ones customers ask after, are sub-queries with money attached. Your support inbox and sales-call notes are a goldmine most teams never mine for content.
• Competitor gap analysis. Where does a rival get cited and you don't? Every one of those is a sub-query they answered and you didn't — a content gap, named. Watching where competitors get mentioned in AI search turns this from guesswork into a list.
• The answer engines themselves. Ask them your head question and read the sub-points they return and the "related questions" they offer. That's the fan-out, partially reflected back at you.

This is the honest place for a tool pitch, because gap-finding is the one part of fan-out you genuinely can't eyeball at scale. You can read a PAA box by hand; you can't hand-track a hundred prompts across nine engines, run after run, and spot every sub-query where a competitor turns up and you don't. Turning those missing sub-queries into a named list is exactly what FixAEO is built to do. And if you sell products rather than content, the same gap-finding maps straight onto getting your products recommended by AI.

Why fan-out is pulling AEO away from classic SEO

Fan-out is a big part of the mechanical reason answer-engine optimization and classic SEO have stopped being the same job. In the ten-blue-links world, one query mapped to one ranked page, so the game was "own this keyword." Fan-out breaks that map: one question becomes many hidden searches, and the thing being ranked is a passage, scored for how directly it answers a sub-query you never saw. You can hold the number-one blue link for a head term and still be absent from the AI answer sitting above it, because that answer was assembled from sub-queries your trophy page doesn't address. The skills still overlap — crawlability, good writing, authority — but the target moved from "rank a page for a keyword" to "own the answer to a question." That split is the whole subject of AEO vs SEO and what AEO is, and fan-out is the clearest single mechanism behind it.

How to see your own fan-out

You can't read Google's internal sub-queries directly. What you can do is approximate the picture: track a realistic set of prompts, watch which ones mention you, and watch where you drop out. That's the job FixAEO does — it samples your prompts and their fan-out across nine AI engines, shows which crawlers (GPTBot, Google's bots, and the rest) actually hit your pages, and scores visibility as a citation rate rather than a one-off screenshot. Pair that with monitoring where competitors get mentioned and the invisible sub-queries start to surface: the ones where a rival shows up and you don't are your content gaps, named.

Common mistakes

A few patterns I see over and over once people learn that fan-out exists:

• Chasing one trophy page. Pouring everything into a single head-term guide and leaving the sub-questions uncovered. The engine fans out; your one page can't own ten subtopics at once.
• Reading one screenshot as truth. "We're cited!" or "We're invisible!" from a single answer. It's one sample of a sampled, hidden process — check back an hour later and it may flip.
• Burying the answer. Making the model scroll past 600 words of preamble to reach the thing it needs. Retrieval and reranking work on passages, so lead with the answer.
• Clever headings that match nothing. "The money bit" instead of "how much does it cost." Fan-out generates literal questions, and vague headings give it nothing to match.
• Assuming retrieved means cited. Treating a consulted "source" as a win. Sources outnumber citations; being read isn't being credited.
• Blocking or JS-walling the answer. Robots-disallowing the AI crawlers, or rendering the key text client-side so it never lands in the HTML. You can't win a sub-query you were never a candidate for.
• Faking freshness. Bumping the date without changing the substance. It doesn't fool rerankers for long, and it makes the page worse for people.

Frequently asked questions

Is query fan-out the same as semantic search?

No, though they're related. Semantic search is about matching meaning rather than exact keywords within a single search. Fan-out happens one level up: the engine first splits your one question into several distinct sub-queries, then runs a search — often a semantic one — for each. Semantic matching is how each sub-query gets resolved; fan-out is the decision to run several searches in the first place.

How many sub-queries does an AI engine generate per question?

There's no fixed number, and no engine publishes it per answer. A narrow factual question might trigger one search or none; a broad comparison in a "deep" or "research" mode can trigger dozens. Perplexity says its Research mode "performs dozens of searches automatically." The count scales with the breadth of the question and the mode you're using.

Can I see the actual sub-queries an engine ran?

Not directly. Google confirms the technique exists and describes it, but the engines don't expose the sub-query list, the candidate set, or the weighting for any given answer. The best you can do is approximate it — from People Also Ask, related-question boxes, and tools that track prompts and citations across engines over time.

Does query fan-out help or hurt my content?

Both, depending on how your content is built. It helps if you cover a topic cluster well, because you can get cited for sub-questions you never literally targeted. It hurts if you only optimized one head-term page, because you're invisible for every sub-query you don't address. The mechanism rewards breadth of genuine coverage over a single trophy page.

Why does my page get found but not cited?

Because retrieval, reranking, synthesis, and citation are four separate steps. You can be retrieved into the candidate pool, then reranked out, or read during synthesis and still not linked. OpenAI notes that "the number of sources is often greater than the number of citations" — being consulted and being credited aren't the same thing.

Do all AI engines use query fan-out?

Every major answer engine does some version of it, because grounding an answer in live results means deciding what to search for first. Google names it directly for AI Mode and AI Overviews; Gemini, ChatGPT, Perplexity, and Microsoft Copilot all reformulate or expand queries under the hood. How aggressively they fan out varies by engine and by mode.

How do I optimize for query fan-out?

Map the real sub-questions around your topic, give each its own self-contained section that states the question and answers it up top, keep the fact and its context in the same block, use question-shaped headings, and make sure AI crawlers can actually fetch and render the page. Then measure your citation rate across engines over time, not a single answer.

The checklist

• List the sub-questions around each head term. If you can't answer one, that's a fan-out seat you're forfeiting.
• Build clusters, not trophy pages — a hub plus a page per sub-question, interlinked with descriptive anchor text.
• Give each sub-question its own self-contained section that states the question and answers it up top.
• Write headings as the literal question a person would type, so retrieval has an exact surface to match.
• Keep the fact and the reason it matters in the same block, so a chunk boundary can't split them.
• Keep the answer text in the initial, server-rendered HTML, and mark up genuinely structured content with schema.
• Confirm AI crawlers can actually fetch and render the page — check a server log, not just Google indexing.
• Update the pages where recency is part of the answer, and skip the ones where it isn't.
• Measure the rate your brand gets cited across engines over time, not a single answer, because fan-out and sampling together make one screenshot close to meaningless.