By Judy Zhou, Founder

Key Takeaways

  • Only 11% of domains are cited by both ChatGPT and Perplexity, while 97.15% of ChatGPT-cited URLs appear on no other platform.
  • ChatGPT's August 8, 2026 switch to domain-scoped queries triggered an 86.4% drop in Reddit citations within one week despite unchanged content quality.
  • LLMs score sources on retrieval confidence, entity co-occurrence, and structural extractability rather than PageRank or inbound links.
  • Replace domain authority tracking with tests for how quickly and cleanly your pages can be retrieved and synthesized by specific LLM engines.

When a large language model decides which source to cite in its answer, what is it actually measuring? Is it traffic? Domain age? The number of referring domains pointing at a page? The answer is more nuanced. And more urgent for brands to understand. Than most SEO frameworks currently account for. As AI citations increasingly shape how consumers, researchers, and procurement teams form their first impressions of a topic, the scoring logic behind those citations has become one of the most consequential algorithms in digital marketing.

LLMs don't use PageRank. They score sources on retrieval confidence, entity co-occurrence, training data frequency, and structural extractability. Only 11% of domains are cited by both ChatGPT and Perplexity. 97.15% of URLs cited by ChatGPT appear on no other platform. And when ChatGPT shifted to domain-scoped search queries on August 8, 2026, Reddit citations dropped 86.4% in one week without any change in content quality.

That last data point should reframe how you think about source authority entirely. The content didn't get worse. The retrieval method changed.

What 'Source Authority' Means to an LLM

Source authority in the LLM era has almost nothing to do with the domain authority score your SEO tool spits out. Domain authority is a proxy metric invented by SEO software companies to approximate Google's PageRank. It measures the quantity and quality of inbound links. LLMs measure something fundamentally different: how confidently a source can be retrieved, verified, and synthesized into an answer that satisfies the user's prompt.

Think of it this way. PageRank is a popularity contest. The page with the most votes (links) wins. LLM source scoring is closer to a job interview. The model is asking: Can I find this source quickly? Does it contain the specific entity or fact the user is asking about? Is it structured in a way I can extract a clean answer from? Can I trace this claim back to a verifiable origin? Does this source co-occur with other authoritative sources when I encounter this entity in my training data?

Those questions map to four underlying mechanisms that I'll break down in the next section. But the key conceptual shift is this: authority is now contextual and per-query, not a static property of your domain. A site can be authoritative for one prompt and invisible for another, even within the same topic cluster. The Foglift Q3 2026 benchmark study found that mean pairwise citation overlap across five AI engines is just 9.4%. That means an engine citing your competitor for a query is not the same engine that might cite you for a related one. Each LLM maintains its own source scoring logic, trained on its own data, with its own retrieval pipeline.

In my work auditing content operations at Meev, I see teams treat AI citations like a single channel. They ask 'how do I get cited by AI?' as if there's one answer. There isn't. ChatGPT, Perplexity, Claude, and Gemini each have distinct source selection behaviors. Claude cited roughly 4x more sources than ChatGPT in the same query set, while Gemini declined to search on nearly 50% of prompts. You can't optimize for 'AI' generically. You optimize per engine, per prompt type, per entity.

This is why traditional answer engine optimization requires a completely different mental model from classic SEO. The scoring isn't linear. It's not cumulative. And it changes when the model updates its retrieval logic.

The mechanics behind LLM source scoring operate on two layers: the training layer and the retrieval layer. The training layer is where the model first encountered your brand or content during pre-training. If your domain appeared frequently in the training corpus alongside specific entities and attributes, the model built a statistical association. That association influences how confidently the model can generate responses involving your brand. The retrieval layer is what happens at inference time when the model searches the live web (or a cached index) to find sources for a specific query. RAG-based engines like Perplexity and ChatGPT with search rely heavily on the retrieval layer. Pure generation models like base Claude rely more on the training layer.

This dual-layer system explains why a brand can be well-known in training data but still get zero citations in a RAG-based engine. If the retrieval system can't find a clean, structured source at query time, the model falls back on its training data. And if your brand's training data presence is thin or ambiguous, the model will substitute a competitor with denser entity representation. The scoring is a moving target because the two layers interact differently depending on the engine's architecture.

The 4 Signals That Predict Whether Your Page Gets Cited

After months of testing content structures against AI retrieval behavior, I've identified four signals that consistently predict whether a page earns AI citations. None of them are 'publish more content' or 'build more backlinks.'

Signal 1: Entity Grounding and Wikidata Presence

LLMs think in entities, not keywords. An entity is a discrete, identifiable thing: a person, company, product, concept, location. When a model encounters your brand name in a prompt, it checks whether that name maps to a resolved entity in its internal knowledge graph. If your brand isn't grounded as an entity, the model treats it as an unknown string of characters. It can't confidently cite you because it can't confidently identify you.

Entity grounding happens through structured data (schema markup), Wikidata entries, Wikipedia presence, and consistent entity co-occurrence across the web. If your company appears in training data alongside specific attributes (founding date, industry, key personnel, product category), the model builds an entity representation. When a user asks about that category, the model retrieves entities it knows, not pages it has crawled.

The practical implication: if you haven't claimed or created your entity in Wikidata, if your schema markup doesn't include Organization and defined properties, if your brand name doesn't consistently co-occur with your category across multiple independent sources, you're invisible at the entity layer. No amount of on-page optimization fixes that.

Here's what concrete entity grounding looks like. Say your company is 'Acme Logistics' and you sell warehouse management software. In Wikidata, you need an entry with properties like: instance of (business), industry (logistics, software), founded date, headquarters location, official website URL, and at least two references verifying those claims. On your website, every page should include Organization schema with the same properties. Your brand name should appear consistently across at least 5-10 independent domains in contexts that mention 'warehouse management software' or 'logistics technology.' That co-occurrence pattern is what teaches the model that Acme Logistics belongs to the warehouse management software entity cluster.

If any of those elements are missing or inconsistent (different name spellings, missing Wikidata entry, schema markup that doesn't match your Wikidata properties), the model's entity resolution fails. It doesn't cite you because it isn't sure what you are.

Signal 2: Answer-Formatted Content That Matches Prompt Structure

This is the signal most teams completely miss. LLMs retrieve sources that already look like answers. If your page is a 2,000-word narrative essay about 'the benefits of cloud computing' and the user asks 'what are the top 3 benefits of cloud computing for small businesses,' the model is looking for a source that contains a list of three benefits, ideally with a brief explanation for each, positioned near the top of the page.

I ran an experiment earlier this year. We took 5 articles that ranked in the top 3 organic positions on Google but had zero AI citations over a 3-month period. We restructured them: direct answer under an H2 that mirrored the question, a numbered list of key points, a comparison table for the data-heavy section. Within 6 weeks, 3 of the 5 started appearing in Perplexity and ChatGPT responses. Same content. Same facts. Different structure.

The lesson: format is a citation signal. 44% of AI citations come from the first third of a page. If your answer isn't in the first third, structured for extraction, you're forcing the model to work harder than it needs to. Models are lazy. They cite the path of least resistance.

The structural elements that matter most are: question-shaped H2 headings that mirror natural-language queries, direct answer paragraphs of 40-60 words immediately under those headings, comparison tables with consistent column structures, numbered lists for sequential or ranked information, and definition-style sentences for key terms ('X is a Y that does Z'). When a model's retrieval system chunks your page, these elements become self-contained extractable units. The model can pull a chunk, verify it answers the prompt, and cite it without needing to synthesize across multiple sections.

Pages that force the model to assemble an answer from scattered paragraphs across 2,000 words get skipped. Not because the information isn't there. Because the extraction cost is too high relative to competing sources that have already done the assembly work.

Signal 3: Inbound Citations From Already-Cited Sources

This is the closest analog to link building in classic SEO, but it works differently. When a source that already gets cited by an LLM references your brand or links to your page, that co-occurrence creates an association in the model's retrieval graph. The model starts to see your brand as part of the same information cluster.

This is why Reddit, Wikipedia, and major publications dominate AI citations. They're already in the cited-source pool. When they mention a brand, that brand gains retrieval proximity. It's not the mention itself that matters. It's the fact that the mention happens on a source the model already trusts and retrieves frequently.

The AuthorityTech citation overlap study found that 97.15% of URLs cited by ChatGPT appeared on no other platform. That means ChatGPT's source pool is highly idiosyncratic. Getting cited by one already-cited source doesn't guarantee the model will retrieve you across all queries. But it dramatically increases the probability for queries related to that source's topic cluster.

In practice, this means outreach to already-cited publishers matters more than generic link building. A single mention on a domain that Perplexity cites regularly is worth more than 50 links from sites no LLM ever retrieves.

The mechanics here are retrieval-graph based. When Perplexity crawls a page on a frequently cited domain and finds your brand name mentioned alongside a topic keyword, it creates a node in its retrieval graph connecting your brand to that topic. The next time a user queries that topic, your brand has a retrieval path. The strength of that path depends on the authority of the connecting domain (how often it gets cited), the semantic relevance of the surrounding text, and the recency of the crawl.

This is why I emphasize finding the publishers AI engines actually cite for your topics, not just building links to high-DA sites. A DA-60 niche publication that Perplexity cites weekly is more valuable than a DA-90 general news site that no LLM retrieves. The metric that matters isn't domain authority. It's citation frequency by the specific engine you're targeting.

Signal 4: Crawl Recency and llms.txt Accessibility

LLMs that use real-time retrieval (Perplexity, ChatGPT with search, Google AI Overviews) need to crawl your page. If your page isn't crawlable, isn't fresh, or doesn't provide clean text extraction, the model either can't find it or can't parse it.

This is where llms.txt comes in. The llms.txt file is a proposed standard (similar to robots.txt) that tells LLM crawlers what content is available for retrieval and how to access it. If you haven't validated your llms.txt file, you may be blocking AI crawlers without knowing it. You can check your llms.txt file to see what AI engines can actually access.

Crawl recency matters because retrieval-augmented generation (RAG) systems prioritize recently crawled content for time-sensitive queries. If your page was last crawled 8 months ago and a competitor's was crawled last week, the model may prefer the fresher source even if your content is objectively better. Publishing frequency, sitemap submission, and IndexNow pinging all contribute to how quickly new content gets into the retrieval pipeline.

The technical details matter more than people realize. When an LLM crawler hits your page, it doesn't render JavaScript the way Googlebot does. Most LLM crawlers fetch raw HTML and extract text. If your critical content is loaded via JavaScript after page render, the crawler sees an empty page. If your page returns different content to bots versus humans (cloaking or dynamic serving), the crawler may get a stripped-down version that lacks the structured elements the model needs.

Server response time also plays a role. LLM crawlers operate under strict timeout constraints. If your page takes more than 3-5 seconds to return a response, the crawler may abandon it and move to the next candidate source. This is especially relevant for pages with heavy media loads or complex database queries. A fast, clean HTML response with minimal JavaScript dependencies is more crawlable than a visually rich page that requires client-side rendering.

Four signals that determine LLM source authority scoring
Four signals that determine LLM source authority scoring

Why High-Quality Content Still Gets Zero AI Citations

This is the frustration I hear most from content teams. 'Our content is better than the competition. We have original research, expert quotes, great design. Why are we not getting cited?'

Because 'good content' and 'citable content' are not the same thing.

Good content is written for human readers. It has narrative flow, emotional resonance, and depth. Citable content is structured for machine extraction. It has direct answers positioned where a model looks for them, entity density that matches the prompt's vocabulary, and formatting that minimizes the extraction effort.

A page can be beautifully written, thoroughly researched, and E-E-A-T compliant and still score zero on citability. I've seen it repeatedly. The gap isn't quality. The gap is structure.

Here's a concrete example. A B2B SaaS company I worked with had a detailed comparison guide: their product vs. three competitors. The guide was 3,500 words, written by their product team, with original screenshots and pricing tables. It ranked page 1 on Google for their target keyword. But Perplexity and ChatGPT never cited it.

The problem? The comparison data was embedded in narrative paragraphs. There was no structured comparison table the model could extract. The product names appeared in prose but weren't tagged as entities. The page didn't answer the implicit question ('which tool is best for X?') in a direct, extractable format. It was a great read for a human. It was opaque to a retrieval system.

We restructured the page. Added a comparison table with consistent columns. Put a direct answer ('For X use case, [Product] is the best choice because...') under an H2 that matched how users actually phrased the query. Added Organization schema for each product mentioned. Within 4 weeks, the page started appearing in Perplexity responses for comparison queries.

This is why I'm skeptical of AI visibility tools that promise to track 'brand visibility' or 'share of voice' as if they're stable metrics. We spent a month trying to optimize for these surface-level metrics for our B2B SaaS content and saw zero measurable lift in AI citations. The tools showed us numbers going up. The actual citation behavior didn't change. Google and OpenAI have made it clear that source attribution is a dynamic, non-deterministic process. Rank Judge's analysis found that 85% of sources appear only once in AI citations. Sampling rate matters more than any visibility score.

The real diagnostic question isn't 'what's my visibility score?' It's 'does my page structure match what the model is trying to extract?' If the answer is no, no amount of authority building will fix it.

Let me give you another example that illustrates the entity density problem. A cybersecurity company published a 4,000-word guide on zero-trust architecture. The guide was technically accurate, peer-reviewed by their engineering team, and cited by several industry publications. But AI engines consistently cited a competitor's 1,200-word blog post instead.

The competitor's post had something the 4,000-word guide didn't: dense entity co-occurrence. The shorter post mentioned 'zero-trust architecture' alongside specific vendor names (Cloudflare, Zscaler, Okta), specific standards (NIST 800-207, SP 800-207), and specific implementation patterns (micro-segmentation, identity-based perimeter, continuous verification). The longer guide used more general language and didn't name specific standards or vendors. When the model retrieved both pages, the competitor's post had higher entity overlap with the prompt's vocabulary. It got cited because it spoke the model's language.

Entity density isn't about keyword stuffing. It's about using the specific, recognized entity names that the model has encountered in its training data. If the model knows 'NIST 800-207' as an entity and your page references 'government cybersecurity framework' instead, the model can't connect your page to the entity it's looking for. The vocabulary match has to be precise, not approximate.

How ChatGPT and Perplexity Diverge on Source Selection

This is where most AEO advice falls apart. It treats AI engines as a monolith.

They're not.

The Foglift Q3 2026 benchmark study found that only 11% of domains are cited by both ChatGPT and Perplexity. Perplexity cites Reddit in 46.7% of responses. ChatGPT cites Reddit in only 12%. ChatGPT cites Wikipedia in 7.8% of responses. The source pools barely overlap.

This means a source strategy that works for Perplexity might be invisible to ChatGPT, and vice versa. If you're investing in Reddit presence (which I'd argue is overrated given the August 2026 ChatGPT citation drop), you might be optimizing for one engine while ignoring the others.

The ChatGPT Reddit citation drop is the clearest case study we have. Between July 18 and August 7, 2026, ChatGPT cited Reddit in 3.83% of responses. After August 8, when ChatGPT shifted to domain-scoped search queries (from 0.37% to 16.8% of all searches), Reddit citations plummeted to 0.52%. An 86.4% drop in one week. The content didn't change. The retrieval architecture did.

Meanwhile, Reddit's broader AI footprint remained stable. It's still cited across 92.8% of AI search opportunities overall and appears in 49.4% of Google AI Overviews. The drop was ChatGPT-specific. Gemini cited Reddit 20 times in the same query set where ChatGPT cited it zero times.

The takeaway: don't build a single-engine strategy. Use a ChatGPT visibility checker and a Perplexity visibility checker separately. Track them as distinct channels. Because they are.

The divergence goes beyond Reddit. ChatGPT's domain-scoped search shift affected how it retrieves all sources, not just community platforms. When ChatGPT started using site: operator-style queries (scoping searches to specific domains), it changed which pages were eligible for citation. Pages that previously benefited from broad web searches became invisible if they didn't match the domain-scoping pattern ChatGPT's system decided to use for a given query.

This has a practical implication for your content distribution strategy. If ChatGPT is scoping searches to specific domains for your topic (say, it decides that cybersecurity queries should search within NIST.gov, CISA.gov, and KrebsOnSecurity.com), your blog post on your company domain won't be retrieved regardless of how well it's structured. You need presence on the domains ChatGPT scopes to. That means guest contributions, PR placements, and entity mentions on the specific domains the engine has learned to trust for your topic.

Perplexity, by contrast, uses a broader retrieval approach. It searches the open web and synthesizes from multiple sources. This means your own domain has a better chance of being retrieved directly. But Perplexity also prioritizes sources with high citation density (pages that are themselves frequently linked to and mentioned), so domain-level authority still plays a role in its ranking, even if the scoring mechanism differs from Google's.

Are your pages structured for AI extraction or just for human readers?

Check Your AI Visibility

How to Audit Your Own Source Authority Score

You can't optimize what you haven't measured. But the measurement has to be done right, or you'll chase phantom metrics.

Here's the audit process I use, broken into four phases.

Phase 1: Run Prompt Samples Across Major AI Surfaces

Start with 20-30 prompts that represent your target queries. These should be natural-language questions, not keyword fragments. 'Best CRM for B2B startups under 50 employees' not 'B2B CRM software.' Run each prompt across ChatGPT, Perplexity, Claude, and Gemini. Record which sources each engine cites, where your brand appears (if at all), and where competitors appear.

Don't do this once. Do it weekly for a month. Rank Judge's finding that 85% of sources appear only once means single-sample measurements are nearly worthless. You need repeated sampling to identify stable citation patterns versus noise.

This is where an enterprise AI rank tracker becomes essential. Manual sampling doesn't scale, and weekly cadence is the minimum to catch retrieval architecture shifts like the ChatGPT domain-scoping change.

When designing your prompt set, include three categories: brand prompts ('Is [Your Brand] a good choice for X?'), category prompts ('What are the best tools for X?'), and comparison prompts ('[Your Brand] vs. [Competitor] for X use case'). Each category tests a different retrieval behavior. Brand prompts tell you whether the model can resolve your entity. Category prompts tell you whether you appear in the consideration set. Comparison prompts tell you whether the model positions you accurately when it does include you.

Record not just whether you're mentioned but where in the response you appear. First mention carries different weight than being listed fifth in a bulleted list. In my work at Meev, I've seen brands go from 'not mentioned at all' to 'mentioned first in the response' simply by restructuring their homepage to lead with a direct category claim ('[Brand] is a [category] tool that [specific value proposition]') instead of a vague mission statement.

Phase 2: Identify Which Pages Are Cited vs. Ignored

Once you have citation data, map it back to specific pages on your site. Which pages are getting cited? Which are invisible? Look for patterns.

In my experience, the cited pages almost always share structural characteristics: direct answers under question-shaped headings, comparison tables, numbered lists, and entity-dense first paragraphs. The ignored pages tend to be long-form narratives without extractable structures.

Create a simple spreadsheet. Page URL. Cited (Y/N). By which engine. Prompt that triggered the citation. Structural format (table, list, Q&A, narrative). This gives you a pattern map of what citability looks like for your specific topic.

The pattern analysis is where the real insight comes from. Once you have 4-6 weeks of data, look for correlations. Do your listicle-format pages get cited 3x more often than your thought leadership pieces? Do pages with comparison tables appear in Perplexity but not ChatGPT? Does adding Organization schema to a page correlate with a citation lift within 2 weeks? These correlations become your playbook for restructuring the rest of your content library.

Phase 3: Check Entity Presence

This is the step most audits skip. Go to Wikidata and search for your brand. If you're not there, that's problem one. If you are there, check the properties. Does your entry include your industry, founding date, key products, and official website? Are there references backing those claims?

Next, check your schema markup. Use Google's Rich Results Test to see what entities your pages are signaling. If your Organization schema is missing or incomplete, the model has no structured entity to ground your brand to.

Finally, search for your brand name across the sources that AI engines already cite. Are you mentioned on Reddit? In Wikipedia? In major industry publications? If not, your entity co-occurrence is low. The model doesn't see you in the contexts it trusts.

The entity audit should also include a competitor entity comparison. Search Wikidata for your top 3 competitors. Compare their property depth to yours. Do they have more references? More listed products? More 'described by source' links? The gap between your Wikidata presence and theirs is a quantifiable measure of how much entity grounding work you need to do. I've seen cases where a competitor had 12 Wikidata references and the target brand had 2. That's not a content gap. That's an entity gap, and no amount of blog posts will close it.

Phase 4: Flag Format Mismatches and Restructure

This is where the audit becomes action. Take your top 10 most important pages and run them through a citability check:

1. Does the page have a direct answer in the first 200 words? 2. Are there question-shaped H2s that match how users phrase queries? 3. Is there at least one structured element (table, numbered list, comparison matrix)? 4. Are key entities (product names, company names, technical terms) used consistently and tagged in schema? 5. Can a text extractor pull a complete, coherent answer from the page without needing to synthesize across paragraphs?

If the answer to any of these is no, you have a format mismatch. Fix it before you invest in more content.

Six-step checklist for auditing your AI citation readiness
Six-step checklist for auditing your AI citation readiness

The before/after is dramatic. I've seen pages go from zero citations to appearing in 3+ AI engines within 4-6 weeks of restructuring. Same facts. Same expertise. Different architecture.

The restructuring process follows a specific sequence. First, identify the primary question each page should answer. This becomes your first H2 after the intro. Second, write a 40-60 word direct answer under that H2. Third, identify any data-heavy sections and convert them to tables. Fourth, add definition sentences for key terms ('X is a Y that does Z'). Fifth, ensure every product, company, and standard mentioned appears in your schema markup. Sixth, verify the page passes a text-only extraction test (view the page source, strip all CSS and JavaScript, and check whether the key information is still parseable).

This isn't a redesign. It's a re-architecture. The visual appearance of the page may not change at all. What changes is the underlying HTML structure and how a machine reads it.

The Ecommerce Blind Spot: When Traditional SEO Fails AI Agents Entirely

Here's a contrarian take that most SEO professionals aren't ready for: for ecommerce, traditional SEO might be actively counterproductive for AI visibility.

The data points to a structural problem. Envive AI raised $15M Series A to build agentic commerce infrastructure because AI agents can't access product data from major platforms. Amazon and other large ecommerce sites restrict agent access to product catalogs. RedSea reports that ChatGPT accesses only approximately 1% of the live internet. Traditional ecommerce SEO optimizes for Google's crawler. AI agents need something different: structured commerce data layers that they can query directly.

RedSea's agentic commerce portal achieved 515.6% monthly user growth by providing exactly this. They didn't improve their SEO. They built a separate data layer for AI agents.

The implication for ecommerce brands is stark. You can have perfect technical SEO, page 1 rankings, and rich snippets, and still be invisible to AI agents making purchase recommendations. The citation scoring system for agentic commerce isn't looking at your title tags and meta descriptions. It's looking at whether your product data is accessible in a format the agent can retrieve and compare.

This is generative engine optimization taken to its logical conclusion. The optimization target isn't a search engine results page. It's an agent's retrieval pipeline.

Think about what happens when a user asks ChatGPT 'find me a wireless headset under $100 with good noise cancellation for remote work.' The model doesn't Google it. It searches its retrieval index for structured product data: price, features, category, availability. If your product page is a visually rich landing page with JavaScript-rendered specs and no structured data layer, the agent can't parse it. It moves to a source that has clean, machine-readable product data.

The fix for ecommerce isn't more content. It's structured data feeds. Product schema with complete properties (price, availability, brand, category, features). API-accessible product catalogs. llms.txt files that explicitly allow AI crawlers on product pages. And potentially, listing your products on platforms that AI agents can actually access, since your own domain may be technically unreachable for agent retrieval.

What This Actually Means for Your Content Strategy

Let me synthesize what the data is telling us.

First, stop treating AI citations as a single channel. The 11% overlap between ChatGPT and Perplexity source pools means you need per-engine strategies. What works for one won't work for all. Track them separately using an AI visibility tool that gives you per-LLM drill-downs, not aggregate scores.

Second, stop equating content quality with citability. Your page can be the best piece of writing on the internet and still get zero citations if it's not structured for extraction. The format signals (direct answers, question-shaped H2s, comparison tables, entity density) are not optional add-ons. They are the citation scoring criteria.

Third, stop relying on static domain authority metrics. The ChatGPT Reddit citation drop proved that a source can lose 86.4% of its citation share in a week without any change in content quality or domain authority. What changed was the retrieval architecture. You need real-time monitoring, not quarterly DA checks.

Fourth, invest in entity grounding before content production. If your brand isn't a resolved entity in Wikidata and major knowledge graphs, no amount of content will get you cited. Entity presence is the foundation. Content structure is the superstructure. Both need to exist.

Fifth, if you're in ecommerce, recognize that agentic commerce requires a fundamentally different data architecture. Traditional SEO won't get you into AI agent recommendations. You need structured product data layers designed for agent retrieval.

The teams that win AI citations in 2026 won't be the ones with the most content or the highest domain authority. They'll be the ones who understand that source authority is now a function of entity grounding, structural extractability, retrieval architecture, and per-engine citation behavior. That's a different game. Play it differently.

If you want to see where you stand today, run an AI visibility audit across every major AI search surface. The data will tell you exactly which signals you're missing.

FAQ

What is the difference between domain authority and LLM source authority?

Domain authority measures the quantity and quality of inbound links to predict Google search rankings. LLM source authority measures how confidently a language model can retrieve, verify, and synthesize your content into an answer. The former is a link-based popularity metric. The latter is a retrieval-confidence metric based on entity grounding, content structure, and citation co-occurrence. A site can have high domain authority and zero AI citations.

How often do AI citation sources change?

Frequently and unpredictably. ChatGPT's shift to domain-scoped search queries on August 8, 2026 caused Reddit citations to drop 86.4% in one week. Rank Judge found that 85% of sources appear only once in AI citations, meaning single-sample measurements are unreliable. Weekly monitoring across multiple engines is the minimum cadence to catch meaningful shifts.

Does ranking well on Google guarantee AI citations?

No. I tested 5 articles that ranked in the top 3 organic Google positions and found zero AI citations over a 3-month period. Only 11% of domains are cited by both ChatGPT and Perplexity. Google rankings and AI citations are increasingly divergent. A page needs specific structural formatting (direct answers, comparison tables, entity density) to be citable, regardless of its search ranking.

What is llms.txt and does it affect AI citations?

llms.txt is a proposed standard that tells AI crawlers what content is available for retrieval. Similar to robots.txt but for LLMs. If your llms.txt file is missing or misconfigured, AI engines may not be able to crawl your content for real-time retrieval. This affects engines like Perplexity and ChatGPT with search that use RAG. You can validate your llms.txt file to ensure AI crawlers can access your pages.

How do I track AI citations across different engines?

Use a dedicated AI visibility tracker that monitors mentions across ChatGPT, Perplexity, Claude, Gemini, and Google AI Overviews separately. Aggregate scores are misleading because citation overlap between engines is only 9.4%. You need per-engine dashboards showing mention position, citation sources, and trend data over time. Manual testing works for small-scale audits but doesn't scale to the weekly cadence needed to catch retrieval architecture changes.

What role does Wikidata play in AI citation scoring?

Wikidata is the structured data backbone that many LLMs reference for entity resolution. If your brand has a complete, well-referenced Wikidata entry, language models can confidently identify and ground your brand as an entity. Without it, your brand name is just an unresolvable string of text. Wikidata presence is foundational because it feeds the entity layer that all other citation signals build on.

Can AI citation tracking be automated?

Yes, but with caveats. Automated tools can run prompt samples on a schedule and log citation occurrences, but the non-deterministic nature of LLM responses means you need high sampling frequency to get reliable signal. Weekly tracking with at least 3-5 samples per prompt per engine is the minimum for meaningful data. Tools that claim to track 'citation rate' or 'share of voice' with proprietary scoring should be evaluated carefully against actual citation behavior, not just metric movement.

About the Author

Judy Zhou, Founder

Judy Zhou leads content strategy at Meev, where she oversees AI-driven content research and publishing for hundreds of brands. With a background in SEO and editorial operations, she focuses on building content systems that rank on Google, get cited by AI search engines, and drive measurable business results.

Run a free AI visibility audit across every major AI search surface and see exactly which citation signals you're missing.

Check Your AI Visibility