Chat GPT’s query fan-out is a behind-the-scene process that breaks down a single user prompt into multiple queries to determine what to answer in the output.
In short, it means running a series of variations of the main query, to address the semantic meaning and intent of it, before blending relevant chunks into an answer.
We’ll publish other deep dives on this process, including its rationale, purpose, and how it changes across different LLMs.
Executive Summary and disclaimer
In this experiment for a client in the domain reselling industry, we conducted a repeatable observation over a high-buying intent prompt to determine what web information influences the answer.
At a surface level, what we did is:
- Explored ChatGPT’s process after a BoFU query to compare domain service providers, observing its grounded search, thinking and comparison process, down to the user asnwer
- Used GPT model 5.1 to aggregate patterns and spot evident gaps between the fanout sequence – results and the brand content we want to optimize for.
- Isolated candidate topics, content structures, and quick technical wins that we could for tackle client’s brand and presented them as actionable recommendations, then:
- Used SEOritmo’s Tech Bender to create related schema markup assets at scale
- Used SEOritmo’s Make-Rev function to create SEO-optimized content drafts over those same recommendations
Disclaimer for this SEO case study
This case study documents the outcome of a repeatable fanout observation experiment on a specific BoFU query and a specific client context.
While the workflow is repeatable and scalable, the results should be interpreted as directional, not definitive.
It remains obvious that:
- A single execution can be influenced by transient factors (model sampling, retrieval volatility, ranking fluctuations, and source availability).
- To make findings more reliable, the same experiment must be repeated frequently over the same input prompt, ideally across multiple sessions, and then aggregated to identify stable patterns vs. outliers.
- The core method is scalable, but the the specific results aren’t
- LLM behavior, grounded search systems, ranking heuristics, and citation policies evolve frequently. Changes to any of these can materially alter:
- which sources are retrieved,
- which candidates are surfaced,
- how comparisons are structured,
- what “trust signals” are weighted.
- Some insights in this case study are necessarily inferential
- Recommendations were produced with the client’s specific product surface, positioning, documentation depth, and feasible operational actions in mind. This makes the study’s applicability less or non- valid across businesses, even in the same industry
Disclaimer – TL;DR
This case study is best used as:
- a repeatable experimental template for observing model behavior on commercial queries,
- a way to generate hypotheses and action candidates,
- and a starting point for iterative measurement rather than a one-time verdict on “how ChatGPT works” or “what will always win.”
ChatGPT’s query fanout experiment: why we ran it
BoFU queries like “best X for Y” don’t behave like classic SEO queries anymore: in ChatGPT, the user often gets a comparison table + recommendations built from a short list of sources, with brands either included as “candidate platforms” or excluded entirely.
Our goal was to observe (and document) the full grounded workflow ChatGPT uses for that decision, then translate it into actionable levers for brand inclusion and stronger “row-level” positioning.
What we tested – methodology, rationale, components
We executed a controlled “fanout observation” run:
- Environment – temporary chat (incognito), IP Spain
- Model – GPT 5.1 Instant
- Prompt (BoFU) – a high-buying intent query to get recommendation of the best domain platoforms: “Best platform for domain resellers”
Combining human analysis with proprietary GPT projects trained on specific clients characteristics, to spot and surmise content gaps (derived from the fanout sequence).
Core rationale and underlying assumptions
The core idea is to treat ChatGPT’s answer as the end of a pipeline with two distinct stages:
- Round 1: autonomous web search + document set construction
- Round 2: synthesis into a user-facing comparison (table + narrative)
That separation matters because optimization opportunities differ depending on whether you’re trying to:
- Enter the candidate pool (Round 1), or
- Win the wording/structure battle inside the final table row (Round 2).
Now, there’s a very important factor we have to point out here.
The biggest impact we can hope to have is by acting to influence the process in Round 1, meaning, adapting our web resources to better match with the retrieval process of a specific query.
As David McSweeney nicely put it in an article about how Chat GPT works:
“The output is non-deterministic. You’re trying to “GEO” or “AEO” a cloud formation.
I’ll concede there is some value in tracking directionality (e.g., “Is the sentiment generally positive?”, “are we showing up more”). But trying to reverse-engineer the algorithm based on the specific adjectives GPT 5.2 chose to use on Tuesday vs. Wednesday is a waste of time. There’s far too much noise.
The only part of this chain that is deterministic, the only part you can reliably engineer for, is the retrieval. The search bit.
If Thinky [one of ChatGPT’s model, editor’s note] doesn’t find you, you’re praying that the frontier model remembers you from a scrape 12 months ago. Which means, for the best chance of being cited, you need to rank in search. Gamble with your search rankings with GEO spam, gamble with your AI visibility.“
How we analyzed it – methodology and pattern observation
We captured and reviewed the artifacts ChatGPT exposes in grounded mode, then classified influence:
Round 1 (retrieval)
- We identified “hard influence” sources: URLs that appeared in the model’s content references / sources footnote (i.e., actually used to justify the answer).
- We also extracted the “candidate pool”: provider/platform names visible during search (even if not all made the final response).
Round 2 (synthesis)
- We inspected how the answer was formatted and what kinds of claims it preferred (short positioning lines, scannable features, simple “why it’s good” phrasing).
- We preserved the exact table-style framing because that’s the surface area where brand positioning either sticks or gets diluted.
What ChatGPT produced – output pattern)
For this BoFU query, ChatGPT returned a short intro + a comparison table labeled “Top Domain Reseller Platforms,” with per-platform “why it’s good for resellers” rows. Openprovider was included with a concise positioning line.
This matters because it implies a row-construction mechanism: the model looks for “copy-pasteable” fragments, clear descriptors, numbers, and role-based benefits—that fit neatly into a table cell.
Key findings: what influenced inclusion and wording
In this section we break down the specific signals and source patterns that most directly shaped which brands made the shortlist, and how each one was described in the final comparison.
A) “Hard influence” sources were a mix of:
- Official provider pages (used as factual anchors for features and positioning)
- Tutorials / “how to choose” explainers (supporting context)
- Community / forum discussions (social proof and “real-world” validation)
In the Round 1 “hard influence” list, we saw examples such as OpenSRS, Openprovider, Enom, ResellerClub, WHMCS community, LowEndTalk, and a Stablepoint article (Hexonet mention).
Takeaway – for BoFU comparisons, the model doesn’t only reward typical “best-of SEO pages.” It blends product truth (official docs), explainers, and crowd validation.
B) The two lever categories
Two areas of actions (levers) emerged, and we built our final insights and to-do list around them.
Lever 1: off-site levers (outside the client’s website)
ChatGPT seems to like:
- High-authority “best-of” lists (e.g., “best domain reseller platforms 2024/2025”), where recency counts
- Detailed comparison articles (4–10 providers, pros/cons, positioning)
- Explicit one-line summaries embedded in third-party content (“X is a reseller-focused registrar with…”)
- Topical authority fit (hosting/domains ecosystem publications—not random blogs)
Takeaway – these pages can decide whether a brand is even eligible to be mentioned or not.
Lever 2: on-site levers (on Openprovider.com)
ChatGPT looks for:
- A dedicated, unambiguous domain reseller platform page
- A keyword-explicit H1 (e.g., “Domain reseller platform for agencies & hosting providers”)
- A tight value prop block (“why it’s good for resellers” bullets: TLD count, pricing model, API, automation)
- Feature clarity with numbers (TLDs, accreditations, white-label, API, etc.)
- Trust/positioning sentences that can be reused verbatim in summaries
The bridge insight: why Round 1 vs Round 2 changes what you do
We explicitly mapped levers to pipeline risk:
- If Round 1 is weak (few strong mentions in trusted comparison docs), the client may never enter the candidate set.
- If Round 2 is weak (vague site wording, unclear positioning), the client may enter but get an inferior or generic row (or be completely omitted from the final shortlist).
Results: step-by-step actions list
What we actually did with the findings was the following.
Step 1: translate observations into an actionable recommendation set
We converted the two lever categories into a prioritized checklist, including:
- Off-site: like authoritative “best-of” lists with specific angles, comparison pieces, reusable summary lines of the clients, etc.
- On-site: like optimizing domain reseller-focused landing pages, tighten H1 and title hierarchies, positioning copy, add scannable payoffs and definitions that ChatGPT could safely reuse.
Step 2: use GPT 5.1 to aggregate patterns and pinpoint gaps
After collecting the fanout artifacts (sources, table framing, “candidate pool”) classified as “event: delta”, we used GPT 5.1 to:
- Cluster repeated patterns in what sources provided (what was easy to lift into a table row), and
- Highlight gaps between that pattern and the brand’s existing content/structure (what was missing to “win the row”).
Example of the raw data:
event: delta
data: {"v": [{"type": "search_result_group", "domain": "www.openprovider.com", "entries": [{"type": "search_result", "url": "https://www.openprovider.com/blog/best-domain-registrars", "title": "The best domain registrars of 2025", "snippet": "Dec 30, 2024 \u2014 Best domain registrars \u00b7 Openprovider \u00b7 GoDaddy \u00b7 Namecheap \u00b7 Porkbun \u00b7 CentralNic Reseller \u00b7 OpenSRS \u00b7 InterNetX.", "ref_id": {"turn_index": 0, "ref_type": "search", "ref_index": 15}, "pub_date": null, "attribution": "www.openprovider.com"}]}]}
data: {"p": "/message/metadata/search_result_groups", "o": "append", "v": [{"type": "search_result_group", "domain": "www.openprovider.com", "entries": [{"type": "search_result", "url": "https://www.openprovider.com/", "title": "Openprovider: Best Domain Registration and Reseller Platform", "snippet": "Openprovider is an ICANN-accredited domain registrar. We provide trusted digital identity for every business. Join our domain reseller program and grow with ...", "ref_id": {"turn_index": 0, "ref_type": "search", "ref_index": 0}, "pub_date": null, "attribution": "www.openprovider.com"}]}]}Step 3: create content drafts from the same recommendation set (Make-Rev)
We fed the prioritized recommendations into SEOritmo’s Make-Rev to generate SEO-optimized draft pages and sections aligned to the observed BoFU comparison frame:
- reseller-focused landing page draft
- “why it’s good for resellers” module
- comparison-friendly feature blocks and FAQs (structured to be extracted cleanly)
Step 4: deploy technical wins at scale (Tech Bender)
Finally, we used SEOritmo’s Tech Bender to generate schema markup at scale, ensuring pages are:
- clearer to index and parse,
- easier to extract into “row-level” facts (organization/product/service descriptors),
- more consistent across the site where the model expects structured certainty.
What this case study demonstrates (repeatable takeaway)
This experiment shows a practical way to do “AI search optimization” without guessing:
- Run a BoFU prompt in grounded mode under controlled conditions.
- Separate retrieval vs synthesis (Round 1 vs Round 2).
- Extract hard-influence sources and the candidate pool.
- Turn patterns into levers (off-site + on-site), mapped to where they affect the pipeline.
- Operationalize the recommendations into content and technical deployments using an SEO AI content tool (Make-Rev), and an automated technical SEO tool (Tech Bender).
If you want to start an AI-search/ SEO analysis tied to your business’ performances and characteristics, feel free to contact SEOritmo.