llms.txt vs Schema Graph: what does ChatGPT actually cite, and what does it ignore?

"Traffic is dropping, CPC is climbing, and leadership is asking why we even have content."

The pressure builds with every quarterly report - falling organic traffic from Google combines with rising lead-acquisition costs, while client shortlists form inside ChatGPT, Perplexity, and Gemini, where the brand disappears despite years of investment in content. On top of that comes a hiring freeze, quota pressure, and the CFO's question of why the content budget has no connection to pipeline. UTM attribution shows zero-click, so the sales team only sees part of the picture, and the CMO has to explain why the brand doesn't appear in the answers the client reads before the first contact. In this reality, vendors promise: just add an llms.txt file and models will start citing the site. Budget flows into an element whose effectiveness can't be verified, while leadership hears it's a "long-term investment in AI visibility."

Why an AI visibility budget can burn up on a file nobody queries

Market data from mid-2026 shows this concern is well founded - an SE Ranking study of around 300,000 domains found no link at all between having an llms.txt file and how often those domains were cited by major language models. An analysis of OtterlyAI logs over a 90-day period, covering 62,100 AI bot visits, revealed that only 0.1 percent of those visits targeted the /llms.txt file, while an average content page received roughly three times more visits. Audits by GEO practitioners confirm that GPTBot, ClaudeBot, and Google-Extended practically never request this resource during standard crawl sessions. Google explicitly states it doesn't use llms.txt as a ranking signal, either in classic search or in AI Overviews. Models ignoring the file during standard sessions means the budget flows into an element that answer-generating systems don't read in any of the audited scenarios.

This problem is bigger than one file. Zero-click means more and more purchase decisions end inside an AI interface, and UTM doesn't capture that path. A client's shortlist forms in ChatGPT, Perplexity, or Gemini before a salesperson gets the first signal. A brand that doesn't make it into the answer doesn't make it into the conversation either. For the VP of Sales, that's lost pipeline; for the CMO, it's a content budget disconnected from sales; and for leadership, it's the question of why pay for content nobody sees. That's exactly the moment the temptation appears to buy a quick fix: a file, a package, a promise. The data shows that llms.txt is currently the weakest possible choice when it comes to real impact on citation by AI models.

What llms.txt really is, and what Schema Graph really is

There are two different approaches to AI visibility on the table - and only one of them is backed by data. Before I get into the mechanics, here's the definition you can quote to leadership:

llms.txt is a declarative file on the site owner's side that models don't actually query in practice; Schema Graph is a machine-readable entity graph, actually used to build and cite AI answers.

The longer version reads like this: llms.txt is a declarative Markdown file placed in a domain's root directory, which as of mid-2026 shows no measurable effect on how often brands are cited by major language models. Schema Graph is a machine-readable entity graph based on structured data, and it's one of the real foundations of visibility in AI search. This distinction shifts attention from the site owner's declaration to elements actually read during answer generation. The difference between llms.txt and structured data is fundamental: the first is an instruction for a courier taped to the inside of the door, the second is the address, company name, and product list written in a format the model reads without friction. The entity graph is a layer of relationships: company, product, author, review, date, place. Models use this layer to build answers and for citation by AI models.

Schema Graph is not one file. It's an organized set of structured data describing who the company is, what it sells, who authored the content, what relationships exist between products and services, what questions customers ask, and what the correct answers are. When a model is looking for a precise fact to insert into an answer, a page with a clear entity graph is easier to process than anonymous text. llms.txt tells the model what the site owner would like it to know. Schema Graph tells the model what is fact and how those facts are connected. This difference decides whether a page even enters the candidate pool, whether it supplies a paragraph matching a sub-query, and whether it makes the narrow citation shortlist.

How ChatGPT chooses sources: from query to citation

When does web retrieval even trigger?

ChatGPT triggers web retrieval in only 18-35 percent of interactions, and in the rest the answer is generated purely from the model's parametric memory. ZipTie.dev estimates around 18 percent, an analysis based on Ahrefs data suggests around 35 percent, but in both cases most conversations don't reach out to the live web. Retrieval is triggered by specific signals in the query: requests for freshness (references to years, "latest," "this week"), unfamiliar or local entities the model has weak priors on, and verifiable claims such as prices, addresses, regulatory dates, or court rulings. In B2B SaaS this looks like: "best B2B marketing automation tools in 2026" or "current prices for lead-scoring solutions for SaaS." If queries in your category don't generate these signals, there's nothing to optimize. How many queries in your category even trigger web retrieval? That's the first question to ask before signing a contract with any "AI visibility" vendor.

Fan-out and sub-queries

When retrieval kicks in, the model breaks the query into narrower sub-queries. The query "how to improve brand visibility in AI search in B2B SaaS" splits into sub-queries about factors driving ChatGPT citations, the effectiveness of the llms.txt file, and the role of schema.org structured data in AI Overviews. Sub-queries often don't contain the brand name, so you enter the candidate pool through entities and topics, not through branding. This is where Schema Graph starts to work: if a page has clearly marked entities and relationships, the model more easily connects it to the sub-query. Without that, it's a fight for exact phrase matching, which falls apart with fan-out anyway.

Two layers of the candidate pool

ChatGPT pulls candidates from the Bing index and from GPTBot's own crawl. GPTBot's crawl works independently of Bing ranking, so a freshly indexed page can make it into an answer despite a weak classic ranking position. This shifts priority from "Google ranking" to "regular freshness and unambiguous entities." For the CMO, this means a content hub updated quarterly can enter the game faster than an old page that's held the top position for years. For the VP of Sales, it means a client's shortlist may include a company that isn't a classic SEO leader but has its structured data in order and fresh answers to questions. In practice, it's worth watching two layers: the Bing index provides classic reach, and GPTBot's crawl provides a chance at freshness and niche entities.

Parametric memory and the data cutoff

In non-retrieval mode, the answer is generated purely from the model's parametric memory. The training corpus is on the order of hundreds of gigabytes - one analysis puts it at around 570 GB - and everything published after the cutoff date is invisible in this mode. That's why brand presence in training data correlates with citations. This explains why "adding a file today" can't fix a brand's absence from the model. If a company isn't in the training data and the query doesn't trigger retrieval, the model doesn't know it. Schema Graph and content hubs don't work instantly, but they build a layer models can read once retrieval kicks in. Over the longer term, brand presence in training data and a consistent entity graph work together: the first gives recognizability, the second gives precision.

The five-step pipeline

1. Query rewrite and fan-out - the model rewrites the question into narrower queries, often without the brand name, so entities and topics matter more than branding.
2. Pulling candidates from Bing and GPTBot's crawl - fresh pages can get in regardless of classic ranking, which rewards updating hubs.
3. Reranking for relevance, domain authority, and freshness - a domain with a clear entity graph has an edge over an anonymous page.
4. Paragraph extraction - the model pulls out specific sentences, so H2/H3s and Q&A blocks make it easier to match a paragraph to a sub-query.
5. Assigning 3-6 citations - the page that delivered a precise, ready-to-paste fact wins.

Used vs cited: what you won't see in a traffic report

A page can shape an answer behind the scenes without getting a citation. In standard mode ChatGPT cites 3-6 links, while in deep research mode it uses dozens or hundreds of sources and still cites narrowly. That means a traffic report will never show the full picture. The metric of visibility is citation. If a page is used in the background but doesn't appear in the links, your UTM won't record that event. That's why a 20-query test in ChatGPT, Perplexity, and Gemini is the only way to see whether a brand enters the answer, even if it doesn't enter analytics. Without that test, leadership sees only falling traffic and rising CPC, not that the brand is helping shape an answer it doesn't get credited for as a link.

Three citation gates and Schema Graph's role

Schema Graph operates at three citation gates - from being pulled in as a candidate page, through matching a paragraph to a sub-query, to being chosen for the narrow shortlist of three to six links. Each gate has different requirements.

• Gate 1: pulled in as a candidate. The model has to find the page at all. Clearly marked entities, an entity graph, and structured data help the system connect the page to the topic even when the sub-query doesn't contain the brand name.
• Gate 2: matching a paragraph to a sub-query. The model doesn't read the whole page, it extracts paragraphs. H2s and H3s phrased as questions, Q&A blocks, and short answers at the start of a section increase the chance a fragment gets selected.
• Gate 3: selection for the narrow citation shortlist. Even if a page is used in the background, a visible link only goes to a few sources. Pages with structured data describing the company, products, authors, and their relationships are easier for a model to process when it's looking for precise facts to insert into the generated answer.

Schema Graph operates in a layer the model actively uses during information extraction. It's a structure the model can read and use. If a vendor only talks about the llms.txt file and doesn't mention entities, the data graph, H2/H3s, and Q&A blocks, they're selling a layer models don't query. In practice, this means an AI visibility budget should primarily fund an organized entity graph, matching content to sub-queries, updating hubs, and regular tests of at least twenty queries.

What actually affects citation: data, not declarations

According to an Ahrefs study of 1.4 million queries, citation is determined by the semantic match between the title and URL and the sub-query - the single strongest signal in the entire dataset. Analyses by Sellm.io and BrandMentions indicate that page structure, domain authority, and brand presence in training data correlate with ChatGPT citations. For llms.txt, the correlation with citations is zero in the SE Ranking study of 300,000 domains. This is the evidentiary core: a declarative file cannot replace an entity graph, freshness, and answer structure.

In August 2026 at AGAPE Automation Systems, I ran 20 queries through ChatGPT, Perplexity, and Gemini - the brand appeared in 7 answers, and after cleaning up the Schema Graph and updating the hubs, it rose to 11 in a retest after 30 days. That's one data point, but it shows the direction: a change in the structured-data layer and content built around questions translates into citation by AI models. You don't have to take vendors' word for it - you can measure it yourself. All it takes is a baseline, a fixed set of questions, and a retest after 30 days to see which page elements actually affect a brand's appearance in model answers.

The fair other side: when llms.txt makes sense

The cost of the file is low, so it's worth treating as an experiment. If you have the resources, add llms.txt, check your server logs, and compare bot visits to /llms.txt with visits to content pages. The problem starts when a vendor sells it as the core of a GEO strategy. Methodological caveat: no provider publishes full system specifications, so conclusions come from observing behavior and correlations, not from insight into the code. At the scale of 300,000 domains, 62,100 bot visits, and 1.4 million queries, the direction is clear. llms.txt works fine as a cheap test, while the foundation of AI visibility remains Schema Graph, the entity graph, and content matched to sub-queries. If budget is limited, it's better spent on organizing structured data and updating hubs than on a file models don't query.

How to check this for yourself

Build a baseline count of brand citations in AI. Pick a fixed set of 20 queries that a client in your category would type into ChatGPT, Perplexity, and Gemini. Check server logs for bot visits to /llms.txt. Retest after 30 days. A 6-8 week horizon gives you data you can present to leadership. An AI visibility budget delivers greater results when allocated to an organized Schema Graph, updating content hubs, and regular tests of at least twenty queries. Such tests let you independently measure which page elements actually affect a brand's appearance in model answers. Instead of "AI visibility" packages, fund the layer models actually read: the entity graph, structured data, H2/H3s, Q&A blocks, and fresh hubs.