ChatGPT

One line in the live chat capture asked for Reddit by name, put reddit.com in the domain slot, and set the window to 365 where every brand line in the same call got 30. The six brand names were inside the query with it. So it didn’t ask Reddit who the good tools are. It asked what people say about the six it had already picked.

Reddit came back as 84 of the 221 entries in that conversation’s pool, more than from any other source. There was no open-and-read step, so what entered the context was 84 snippets rather than 84 threads. The answer credited none of them. Every citation went to vendor pages.

A local coffee query then did it harder, site:reddit.com in the words and reddit.com in the slot, with a 3,650-day window. Ten years, on a question where news sites got 7 days.

That’s 2 conversations on one account, so treat the pattern as an observation. Two readings fit it. Reddit as an invisible input, feeding the verdicts while vendor pages collect the credits, or snippets fetched and then ignored with the wide window as a leftover habit. Nothing in the traffic separates them, because the wire can’t prove influence without citation. The fetching and the zero credits are the facts. The rest is interpretation, and I’ve said which is which.

Two of the new call types don’t search the web at all. They request interface.

genui_run|epl_schedule|{"fn":"schedule","league":"EPL","date_from":"2026-08-21","date_to":"2026-08-24","locale_override":"en-GB"}
genui_run|stock_chart|{"ticker":"NVDA","asset_type":"equity","market":"USA","locale_override":"en-US"}

A football schedule and a stock chart, called as functions with typed arguments. The stock chart arrived in the payload as a reference named stock_chart pointing at a widget on cdn.platform.openai.com, version 2.0, hydrated from a state payload, placement_type set to inline_reference. Reloading the conversation later showed a fresher price, so the component fetches live data on its own.

Local answers do it through a second route. The model emits a genui directive in the answer text itself, and the payload carries a client_defined_widget reference with category set to map, its pins wired to the entities the business lookup returned.

Neither surface carries a citation. The schedule credits no fixtures page and the chart links to nothing. Whole classes of query are moving onto components where the citation game every GEO tool measures doesn’t exist.

On 16 August the search tool call was JSON, {"system1_search_query":[{"q":"..."}]}, mirrored in a metadata field called search_queries. On 20 August, same account, same question, the call looks like this instead.

fast|Zendesk AI agents pricing 2026|30|zendesk.com
fast|best AI live chat support Intercom Gorgias Zendesk Ada Tidio Crisp reddit|365|reddit.com
length|long

One line per search, fields separated by pipes, and search_queries absent from the payload entirely. The fields after the query are optional. The number took six values across my captures, 2 on a stock price, 7 on football results, 30 on brand probes, 90 on earnings guidance, 365 and 3,650 on Reddit. Read as days, that’s 2 days to a decade, each matched to how fast the answer goes stale. I haven’t seen a spec, so the day reading is mine.

The call types are the other new layer. fast is the web search. product takes semicolon-separated product names and fired only on physical goods. business takes a location and either search phrases or venue names. image is an image search, and genui_run invokes a widget by name with JSON arguments. Each block closes with length|long, medium or short, the renamed survivor of the old response_length.

The domain field scopes a search to one site, and it can hold a list, theguardian.com;skysports.com came back on a single news line. site: operators still appear inside query text too, so brand targeting now has two forms in the same conversation.

This is the third format change since June, and the fastest. The full teardown has every captured line. If your tooling parses the fan-out, it wants the tool-call text now, not the metadata field.

Ask for the best AI note taking app, seven words with no brand in them, and the first search ChatGPT writes for itself ends Granola Notion AI Otter Fireflies Fathom Mem Limitless. Nothing has come back from the web at that point. I ordered every conversation by timestamp, first user message then first search query, so there’s no earlier result the names could have come from. They came out of the model.

The fan-out from the first two teardowns turns out to be this list being worked through. One search names the shortlist, then one site: probe per name, each aimed at that company’s own website. It was never a hunt for candidates.

In 21 of 27 conversations the first query held brands I never typed, and 11 of 13 unrelated categories did the same, down to the product line, with current model numbers like Roborock Saros and Eufy S1 Pro turning up unprompted. It fires whenever the model has to supply the products itself. Name your own brands and it takes yours verbatim. Ask a how-to and no search runs at all. Displacement queries reach for fresh names too, so “alternatives to Zendesk” produced Help Scout without being asked.

Two caveats. The lists move between runs, and re-running three categories kept language learning nearly still while web hosting swapped every vendor for a review site. And personalisation is in there, my meal kit query came back with Dubai in it, so these are my account’s shortlists rather than ChatGPT’s.

The mechanism is the structural part. One capture shows it, and you can reproduce it on your own account in two minutes with DevTools. The full working is in part three.

I split every brand in the sample into two groups, ones ChatGPT named in a query it wrote and ones that were only fetched during the search. The named group got mentioned in the final answer 68.9% of the time. The fetched-only group managed 2.1%, and 86 brands got recommended without their site being fetched in that conversation at all. A mention doesn’t need a crawl.

A second filter runs after the query, and it’s harsher. Of 3,554 retrieved pages across 57 conversations, 110 earned a citation. That’s 3.1%, roughly 62 pages fetched and 2 credited per conversation, so nearly everything gets read and almost nothing gets credited. Position inside the domain group predicts most of the difference. First position converted at 5.2%, third at 2.4%, sixth or later at 0.3%. Two tightly matched pages from one domain did best at 6.2%, and six or more collapsed to 1.7%, which is a domain competing with itself.

Relevance qualifies a page without picking it. The cited page sat in the top 5% of the retrieved pool for match against the claim being supported, and was the single best match only 20% of the time. Whatever makes the final selection stays server-side.

One brand in my data was fetched 66 times and never cited once. That’s a page problem, not an awareness problem, and retrieval counts alone would never show it.

One account, weighted towards software and AI tools because that’s what I ask about. Trust the columns and the ordering. Throw the decimals away.

The searches ChatGPT writes for itself now sit under a key called search_queries. Until early August 2026 that key was search_model_queries. Same content in the same place, new name. That part is structural, one capture shows it.

The count moved in the same window, and that part is directional from my own captures. Through July an answer typically ran about 12 searches. By the time I re-read the traffic for part three, the same kinds of question were running about 4. Fewer probes per answer means fewer domains fetched, which concentrates everything on the shortlist named in the first query.

This is another format move on top of July’s, and the lesson hasn’t changed. Read these payloads by the presence of a field rather than a hard-coded path, and re-check monthly. What was true in July won’t necessarily hold in September.

In June, every web source ChatGPT pulled carried a result_source label naming the pipeline that fetched it: serp, labrador, bright, oxylabs, and later bing. That field was the centrepiece of the first teardown.

Re-read the traffic today, on the same account, and it is gone. A live commercial search retrieved 203 sources across 80 domain groups, with zero pipeline labels anywhere in the stored payload. The sources are still there, grouped by domain with object references, but the “which scraper fetched this” tag is no longer exposed.

What replaced it is sharper. Each cited source is now bound to the exact answer sentence it supports, by character offset (matched_text, start_idx, end_idx), alongside a list of runner-up pages that backed the same claim and lost the visible citation. So the engine no longer tells you how a page was fetched, but it now tells you the precise line each page won.

Read this as: any tool or claim that depended on the pipeline label is now reading nothing on current traffic.

The model behind the “Instant” label used to be gpt-5-5. Today the default model slug is auto: the router that silently picks the model is now the default selection, not a hidden fallback.

From the model endpoint, the current line-up is gpt-5-3 (labelled “our latest and most advanced”), gpt-5-5, and mini variants of each, plus auto. Reasoning resolves to gpt-5-6-thinking, and it carries a new thinking_effort field. On a hard puzzle the router set that effort to "extended", so there are tiers of reasoning depth chosen for you per turn.

The practical consequence is the one from the original teardown, now sharper: your “Instant” benchmark is not stable, because the turn you think you are testing may be silently escalated to a reasoning model at an effort level you did not pick.

This one is why the source-pipeline finding took real work to confirm. A plain web-search turn’s request no longer returns the answer. It returns a small handoff (a token and a topic id), and the actual answer streams over a persistent WebSocket that opened when the page first loaded.

Previously this async pattern was reserved for the slow “Thinking” answers. Now it is the default path for ordinary search turns too. A pre-flight step mints a fresh transport token on every single turn.

Why it matters beyond plumbing: the readable layer for this kind of work has always been the browser network panel, after decryption. Moving the answer onto a socket opened before you can attach a listener makes it materially harder to watch a normal answer being built, unless you hook the page before it loads. The window is quietly closing, which is part of why a one-click tool that reads your own session, rather than a DevTools recipe, is now the realistic way in.

The clearest single demonstration that this is a moving target. Over 21 and 22 July, ChatGPT changed the shape of its stored retrieval payload twice.

First the flat per-source pipeline label began dropping out, and the runner-up pages moved onto the citation items instead. A day later the whole retrieval block moved again, nesting under a domain-grouped structure, and the source reference changed from a plain string into an object. Anything reading the old shape by a fixed path suddenly matched nothing and showed an empty result.

The lesson for anyone building on this: never read these payloads by a hard-coded path. Collect by the presence of a field, so a rename breaks one small thing instead of the whole read. This drift week is what set up the bigger change three days later, when the pipeline label vanished from the stored data entirely.

Two findings from the follow-up sweep, covered in full in part 2 of the teardown.

The runner-up layer. A field that was empty in June is populated now. For each fact ChatGPT states, the traffic lists the other pages that backed the same claim and lost the visible citation, sometimes a sibling page on the winner’s own domain, sometimes a direct competitor. You can read, claim by claim, exactly who you lost a citation to. (structural)

A fifth pipeline, Bing, but cohort-gated. Someone was served pages through a bing pipeline that had never appeared in my own traffic. The same review page reached them through Bing and reached me through a commercial scraper, in the same week; a free account in a third country saw a third setup again. So the source pipelines are per-cohort plumbing, load-balanced across accounts, not a single global system. (structural that it exists; directional on who gets which)

This is also the finding that first proved you cannot build a tier theory off one account, a rule that only became more important as the whole pipeline label later disappeared.

Where this all started, written up in full in the first teardown.

Reading the raw network traffic, every web source ChatGPT pulled carried a hidden result_source label naming one of four fetch pipelines: an open-web baseline, a licensed-content pipe, and two commercial web scrapers. ChatGPT’s “open web” was being fulfilled by competing scraping vendors, and the field told you which one served each result. (structural)

Before any search ran, a classifier filed the query into a use case, and that decided which pipelines fired. Some query types (how-to, definitions) never touched the web at all and were answered from training data. (structural)

And the directional half, from one account over a few days: on commercial queries a handful of review hubs dominated, Reddit was cited heavily while YouTube was retrieved and almost never cited, and for pricing the model opened the vendor’s own page and read the number straight from the HTML. (directional)

Almost every specific here has since changed, which is the whole reason this log exists.