ChatGPT

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.