How AI engines decide what to cite: a 2026 teardown

AI engines do not rank ten links and hand you a list. They read a handful of pages, lift the sentences that answer the question, and put a name next to each one. This teardown walks through the seven properties those quoted sentences and their pages tend to share, why each one exists, and what to change on your site this week.

Nothing here is a ranking secret. Every signal below follows from how retrieval-augmented answering works: fetch candidate documents, extract passages, attribute the ones used. Once you see the mechanism, the checklist writes itself.

First, the mechanism

A generative answer is assembled, not remembered. When someone asks ChatGPT, Perplexity, or Google's AI mode a question with a live answer, the system runs a search, fetches a set of pages, and gives the model those documents as context. The model then writes an answer and attaches sources to the parts it took from them.

Three consequences fall straight out of that, and they explain almost everything else in this post:

• The unit of citation is a passage, not a page. The model needs a sentence it can lift and attribute without editing it into something you never said.
• The document has to arrive. If the fetch returns an empty shell, an error, or a blocked response, your page is simply not in the candidate set.
• Attribution is a risk decision. Putting your name next to a claim is the engine vouching for you a little. Signals of who published the claim, and when, matter more than they ever did for blue links.

The seven signals

Here they are in the order we check them, with the reasoning behind each.

01 Quotable, self-contained sentences

An engine takes one or two sentences into its answer. If your key claim is the fourth clause of a ninety-word paragraph, and it opens with "this also means," it cannot be lifted cleanly. Passages that survive extraction are short, complete on their own, and contain their own subject.

Compare these two. "As we've discussed, this typically takes around a fortnight in most cases." Versus: "A standard GeoTest Site Analysis returns a report in under 15 minutes." The second one is a sentence a model can drop into an answer with your name after it. The first one is unusable outside its paragraph.

Do this: open every important section with one sentence that states the claim in full. One idea per sentence. No pronouns pointing backwards. No "this," "that," or "the above" in the first line of a section.

02 Facts, numbers, and specifics over adjectives

"Fast shipping" is not a fact; it is a mood. "Ships in two business days" is a fact, and it is the kind of thing an answer needs. When a model is comparing three vendors for a user, the vendor whose page contains numbers is the one it can describe concretely. The others get a vague sentence, or nothing.

The same applies to price. A page that says "contact us for a quote" gives the model nothing to work with when the user asked "how much does X cost." A page with a starting price, even a range with conditions, becomes the answer.

Do this: take the three adjectives you are proudest of and replace each with a number you can defend. Then put those numbers in their own sentences, not inside a marketing paragraph.

03 Structured data that says what the page is

Schema.org markup in JSON-LD tells a machine, without inference, that this page is a product, a service, a local business, an article with an author, or a set of questions and answers. It is the difference between a parser deducing your business name from a logo and reading it from a field labelled name.

In the current GeoTest rubric, structured data is worth 18 points out of 100. It is weighted that highly not because markup is magic, but because it is the cheapest unambiguous signal available: an afternoon of work that removes an entire class of misreading. Organization, WebSite, Article or BlogPosting, Breadcrumb, Product where relevant, and FAQPage cover most sites.

Do this: add Organization and WebSite sitewide, then the page-type node on each template. Validate with a structured data testing tool before you move on.

04 A visible, checkable author and publisher

Anonymous content reads like an anonymous tip. A named author with a real bio, an About page that establishes why that person would know, and an Organization node tying the site to a real company all give a model a reason to attribute rather than paraphrase.

This is the part most B2B sites skip and most publishers get right. If your best explainer page is signed "Admin" or nothing at all, you are asking to be quoted without credit at best.

Do this: byline every substantive page, link the byline to an author page, and connect both to your Organization schema.

05 Depth on one page instead of thinness across ten

Retrieval rewards coverage. A single page that answers a question and its eight follow-ups will be pulled into far more answers than eight pages that each answer one thing badly, because each of those follow-ups is a separate query that has to find a document.

The trap is padding. Length with nothing in it does not help; a model does not reward you for six hundred words of throat-clearing. What helps is that the page contains more answerable specifics: prices, steps, constraints, exceptions, definitions, comparisons.

Do this: pick your single most commercially important topic and build one cornerstone page that covers it completely, then link the thin pages into it rather than competing with it.

06 Freshness you can see

When two sources support the same claim, a visible and recent date is a reasonable tiebreaker, and models are told a lot about recency by the page itself: a published date, a "last updated" line, current years in the copy, and a dateModified field in schema.

Be honest about it. Changing a date without changing the content is the kind of thing that erodes trust with both readers and engines. Update the substance, then update the date.

Do this: put a real published and updated date on every article, mirror it in schema, and set a calendar reminder to revisit your top five pages quarterly.

07 Text that exists before JavaScript runs

This is the one that silently disqualifies everything above it. If your site is a client-rendered React, Vue, or page-builder app, the server may return a near-empty HTML shell that only becomes a page once the browser executes the bundle. Crawlers differ in whether they render JavaScript, how long they wait, and how much they retry. Google's own JavaScript SEO documentation has flagged rendering dependencies for years, and Google is the most patient crawler in the set.

The safe standard is simple: your important content should be in the server response. Server rendering, static generation, or a prerendered fallback all satisfy it. Browser-based audits structurally cannot catch this failure, because they run the JavaScript before they look.

Do this: fetch your own page the way a crawler does, with JavaScript disabled, and read what comes back. If the headline is missing, fix that before anything else on this list.

How the seven map to the GEO rubric

GeoTest scores six weighted categories out of 100. The seven signals distribute across them like this:

Crawler accessibility carries the fewest points and matters the most, which looks like a contradiction until you notice that a site failing it usually fails four other categories at the same time, because the crawler never saw the content that would have earned them.

What we do not claim

Two honest caveats, because this field is full of confident numbers with nothing behind them.

First, no external tool can see inside an engine's ranking. What is observable is which sources appear in answers, what those pages have in common, and what changes when you change the page. The seven signals are a model of the mechanism, not a leak from one.

Second, the weights in the GeoTest rubric are a considered judgement about which properties matter, published openly on our methodology page so you can disagree with them specifically. They are not derived from a survey and we do not present them as one.

A one-week plan

1. Day 1 — check what the crawler receives. Run a scan, or fetch your top pages with JavaScript off. Fix the raw response first if it is empty.
2. Day 2 — schema. Organization and WebSite sitewide, plus the correct page-type node on your templates. Validate.
3. Day 3 — bylines and About. Name the author, write the bio, link them together.
4. Day 4 — rewrite openers. First sentence of every section becomes a standalone claim.
5. Day 5 — put the numbers in. Price, timeline, coverage, capacity, whatever your buyers ask.
6. Day 6 — add the questions. Eight real buyer questions with direct answers and FAQPage markup.
7. Day 30 — re-test. Structural fixes should be visible by then. If nothing moved, check what the crawler actually received.

Frequently asked questions

How do AI engines choose which sources to cite?

In broad terms: the engine retrieves a set of candidate pages, extracts passages that answer the question, and attributes the ones it uses. That means citation is won at passage level, not page level. A page gets cited when it contains a short, self-contained, factual statement that answers the question directly, on a page the crawler could actually read, from a source it has some reason to trust.

Is getting cited by ChatGPT the same as ranking on Google?

No. Ranking is a list of ten positions competing for a click. Citation is a handful of sources folded into one answer, usually with no scrolling and no second page. A site can rank well and never be cited, most often because its key facts are buried in prose or absent from the server response.

Does word count affect citation?

Depth helps, but length alone does not. A long page that repeats itself is no more citable than a short one. What depth buys you is coverage: more of the specific sub-questions a buyer asks are answered somewhere on the page, so more retrieval attempts land on it.

Do I need schema markup to be cited?

No, but it removes guesswork. Schema.org JSON-LD states in machine-readable terms what the page is, who published it, and what the questions and answers on it are. In the GeoTest rubric, structured data is 18 of 100 points, because it is the cheapest way to make a page unambiguous.

How long does it take for changes to show up in AI answers?

It depends on when each engine next fetches your pages, which varies by engine and by site. Structural fixes such as server-rendered text and schema are detectable on the next crawl; authority signals from other sites accumulate over months. Re-test roughly every 30 days rather than daily.

What is the single most common reason a site is never cited?

The crawler did not receive the content. Client-rendered pages can return an HTML shell that only becomes a real page after JavaScript runs, and crawlers differ in whether and how long they render. If the raw server response is empty, nothing else on this list matters.