A citable page and a coherent site are different things. A single well-structured passage can be lifted and cited on its own, that’s what the passage-level citability rules cover. A coherent site is a different achievement: it means the important things your site talks about have stable, governed identities, the relationships between those things are made explicit, and the claims you make about them can be traced back to where they’re actually proven. This article is about that second layer, which most AEO effort skips entirely because it doesn’t live inside any single page.
Key takeaways
- A citable page and a coherent site are different things. Citability is per-passage; coherence is sitewide, built from governed entities and traceable evidence.
- Entity architecture governs identity: what is this thing, and where does it live. Evidence architecture governs proof: what supports this claim, and where can it be checked. They’re two distinct layers, not one.
- Modern search systems resolve semantic relationships without exact-match wording. The real risk of inconsistent terminology is ambiguity for readers, schema, linking, and governance, not that a synonym becomes a second, unresolved entity.
- An Entity Registry and a Claim Registry are real operational artifacts this article hands you, not abstractions: canonical name, definition, home URL, aliases, and evidence for each entity; canonical value, scope, source, and last-verified date for each claim.
- Google confirms no special technical setup or schema is required for AI Overviews or AI Mode beyond ordinary Search eligibility. Structured data reinforces what’s already visible; it isn’t a citation hack.
What this article assumes you already have
This piece assumes a given page already clears the passage-level bar: the answer comes before the explanation, one section answers one question, no unstated context dependency, the heading states the actual question. Those rules, with worked before/after rewrites, live in What Makes a Page Easier for AI Answer Engines to Cite?, the page-level, applied-diagnostic layer this article builds on. If a page still fails that passage-level bar, fix that first. Sitewide architecture only pays off once the individual pages it connects are themselves worth citing. For the durable AEO/GEO methodology both articles apply, see the AEO/GEO playbook.
Correcting the exact-match assumption
A common version of this topic overclaims: that AI search requires identical wording everywhere, or “CRO,” “conversion rate optimization,” and “conversion optimization” will read as three unrelated things. Google’s own guidance runs the other direction. It says not to create separate content for every wording variation of a topic, because the underlying systems are built to understand topics and their relationships, not just match strings. Modern search doesn’t require exact-match wording to resolve “conversion rate optimization” and “conversion optimization” as the same idea.
The real problem with unmanaged terminology isn’t that a synonym quietly becomes a second, unlinked entity in some model’s internal representation. Nobody outside the model vendors can verify exactly how a given system resolves a variant, and this article doesn’t claim to know that. The real, controllable problem is what unmanaged terminology does inside your own operation: ambiguity for a reader, for whoever writes structured data and has to pick “the” name, for whoever builds internal links and has to guess which page is canonical, and for anyone auditing later who can’t tell drift from three genuinely different concepts. That’s a governance problem, solvable with a governance artifact, not a find-and-replace pass.
The fix is a canonical entity with accepted aliases, not one exact phrase mandated everywhere. Example: canonical entity name “Conversion Optimization,” accepted aliases “CRO” and “conversion rate optimization,” canonical home `/conversion-optimization/`. The prose stays natural. What changes is a documented, checkable answer to “what is the one true name and home for this thing,” instead of an assumption nobody wrote down.
Entity architecture: what is this, and where does it live?
Entity architecture is the layer that answers one question per important thing your site talks about: what is this, and where is its canonical definition? An entity, in this sense, is anything an AI system (or a new reader) has to identify as the same thing across multiple mentions to connect them: your company, a named capability, a named methodology, a client outcome cited as proof. Entity architecture doesn’t try to control every sentence that mentions a concept. It establishes, once, per entity: a canonical name, an accepted set of aliases, and a canonical URL that serves as that entity’s home, the page where its full definition actually lives.
This is a discipline problem more than a writing problem. A careful editor already applies it inside a single document: use one name for one thing, and don’t let a synonym quietly become an untracked second identity. Entity architecture extends that same discipline to the scale of an entire site, and writes the result down somewhere checkable instead of trusting it to memory.
Evidence architecture: what supports this claim, and where can it be checked?
Evidence architecture is a different layer, and conflating it with entity architecture is where a lot of sitewide AEO advice goes vague. Entity architecture asks what something is. Evidence architecture asks what proves a specific claim about it, and where that proof actually lives.
Two distinct roles matter here, and most content architectures don’t separate them:
- Canonical claim source: the one place on the site where the authoritative version of a claim is maintained and stated in full. This is where the number, the outcome, or the methodology detail actually lives, and every other mention of that claim should point back to it rather than restate it independently.
- Evidence source: what actually substantiates the claim. For a proprietary figure, that’s the internal record it was pulled from. For a claim referencing external research, that’s the original study, not a summary of a summary. For a case-study result, that’s the actual case study, not a bare number repeated on a landing page with nothing behind it.
A claim can have a clear canonical source and still have weak evidence behind it, and a claim can be well-evidenced internally but scattered across a dozen pages with no canonical source anyone points back to. Both are defects, and they’re different defects with different fixes: a missing canonical source gets fixed by designating one page as the claim’s home and linking to it; missing evidence gets fixed by actually locating or producing the proof, which no amount of internal linking substitutes for.
The Entity Registry
The Entity Registry is the operational artifact entity architecture produces. It’s a short, stable list, not something that grows with every new article. Each row is one entity, with these fields:
| Field | What it holds |
|---|---|
| Canonical name | The one name treated as authoritative for this entity |
| Entity type | Company, capability, named methodology, client outcome, or similar |
| Definition | A one- to two-sentence statement of what this entity actually is |
| Canonical URL | The page that serves as this entity’s home |
| Accepted aliases | Shorter forms, acronyms, or synonyms that are fine in prose as long as they tie back to the canonical entity |
| Deprecated names | Older working names that predate the current canonical one, kept on record so nobody reintroduces them |
| Related entities | Other registry entries this one is commonly discussed alongside |
| Supporting proof | The evidence or case-study links that back this entity’s claims, cross-referenced to the Claim Registry below |
| Structured-data identity | Where relevant, the Organization or entity-level structured-data properties that represent this entity, for example `name`, `alternateName`, and `url` on an Organization record (see Structured data, below) |
A worked row: Canonical name “Personalization,” entity type “capability,” canonical URL `/personalization/`, accepted aliases “website personalization,” “1:1 personalization,” related entities “Conversion Optimization,” “Experimentation,” supporting proof linked to the relevant proof pages. Building the registry is what makes an entity-consistency audit possible at all, because without a written canonical answer, “is this drift or is this fine” is a judgment call made fresh every time instead of a lookup.
The Claim Registry
The Claim Registry is the operational artifact evidence architecture produces, and it’s the direct fix for a specific, real failure mode: the same number appearing in slightly different forms across a site until nobody can say which version is correct. Each row is one claim, with these fields: canonical value, exact definition and scope, source, last-verified date, permitted shorthand, and prohibited interpretations.
A worked row makes the scope problem concrete. Canonical value: “7,000+ experiments and personalization experiences.” Scope: this figure counts both A/B tests and personalization experiences run across client programs; it is not a count of A/B tests alone. Permitted shorthand: “7,000+ experiments and personalization experiences” verbatim, on first use per page. Prohibited interpretation: restating the figure as counting A/B tests alone (dropping “and personalization experiences”) is not an interchangeable restatement, it narrows the claim’s scope and overstates a subcomponent as the whole. That distinction only exists if someone wrote down the claim’s exact scope once, in one place, instead of trusting that “close enough” paraphrases would stay close enough.
Claim → canonical claim record → supporting evidence → pages that reuse the claim is the chain a Claim Registry entry actually traces. For the figure above: the claim is the number itself; the canonical claim record is the Claim Registry row defining its exact scope; the supporting evidence is the internal program record the figure is pulled from; the pages that reuse the claim are every page that cites “7,000+ experiments and personalization experiences” and links back to its canonical claim source instead of independently re-deriving or rounding it.
The relationship graph
Entities and claims connect to each other, and that connective structure is worth drawing out explicitly rather than leaving implicit in prose. A capability page is an entity’s canonical home. Articles that discuss the capability link to that home. A proof page is a claim’s evidence source. Pages that cite the claim link to that evidence source instead of restating the number independently. The graph that results, when it’s actually governed, looks like a small number of canonical hubs (one per entity, one per claim) with many pages pointing inward at them, rather than the same information re-asserted independently on every page that touches it.
That’s the structural difference between a fragmented library and a governed one: fragmented means the same entity or claim exists in multiple disconnected forms across the site with no page anyone would call “the” canonical one; governed means every mention, wherever it lives, resolves back to exactly one canonical entity page and exactly one canonical claim source. The design brief for this article includes a visual contrasting both states directly (see Step 5 in this article’s companion design packet).
A worked audit: Personalization, end to end
Walking one real entity through the full model makes it concrete. Take Personalization, one of this site’s seven capability entities.
The registry entry, as it should read: Canonical name “Personalization.” Canonical URL `/personalization/`. Accepted aliases “website personalization,” “1:1 personalization.” Related entities “Conversion Optimization,” “Experimentation,” “CDP data.” Definition: using visitor data and behavioral signals to change what a page shows a specific visitor, distinct from experimentation (which tests a change against everyone) and CDP data (which supplies the signals personalization acts on). Evidence: linked to the relevant capability proof.
The audit walks the published library and finds four real defects. Article one discusses personalization under an older working name and doesn’t link to `/personalization/` at all: a deprecated term with no path back to its canonical home. Article two makes a proof claim but doesn’t link to the page where that result is actually substantiated: a missing evidence link. Article three links the word “personalization” to a general services page instead of the capability’s actual home: a link that exists but points at the wrong node. The capability page itself carries a structured-data name field that doesn’t match the alias used in two of the three articles: a variant mismatch between the page’s own prose and its markup.
The corrected graph: all three articles use either the canonical name or an accepted alias, and each links at least once to `/personalization/`. Article two’s proof claim links to its evidence source instead of standing alone. Article three’s link target is corrected to the capability page. The structured data is corrected to match the page’s own stated canonical name. Four defects, four specific, checkable fixes, no full rewrite of any article required.
Site audit method
- Build or update the Entity Registry and Claim Registry first. Everything below depends on having a written canonical answer to check against; without it, “is this drift” is a guess.
- Search the published library for each entity’s known variants (aliases and deprecated names both) and check whether each instance links to that entity’s canonical home at least once per page that uses it.
- Search the published library for each claim’s known values and check whether every restatement matches the Claim Registry’s exact scope, not a rounded or narrowed paraphrase.
- Check every proof claim for a working link to its evidence source, not just its canonical claim source; a page can point at the right hub and still fail to substantiate the claim if the hub itself has no real evidence behind it.
- Fix the link and the scope, not necessarily the word choice. The prose doesn’t need to become mechanically repetitive; the connection to the canonical entity or claim does need to exist.
- Re-run the audit on a fixed cadence, not once. A library that grows adds new variants and new claims faster than a one-time cleanup can catch.
- Introduce formal entity governance (a maintained registry, an assigned owner, a fixed audit cadence) once multiple authors or systems are contributing content, or once volume makes consistency hard to hold in one person’s head. That’s a mechanism-based trigger, not a page-count threshold. A single careful editor can often hold a much larger library coherent than a fast-growing library with several contributors from day one.
Structured data and technical reinforcement
Structured data has a real, limited role here, and it’s worth stating plainly what that role isn’t. Google is explicit that there are no additional technical requirements to appear in AI Overviews or AI Mode beyond ordinary Search eligibility, no special AI-specific schema exists, and Organization structured data (properties like `name`, `alternateName`, `url`, and `sameAs`) has no required fields and isn’t documented as an AI-citation lever. What Google does say is that structured data should match the visible content on the page.
That gives structured data one legitimate job in this model: reinforcing an entity that’s already made clear in the visible text, using the same canonical name and aliases the Entity Registry already established, so the markup and the prose agree instead of drifting apart (the exact defect the worked audit above found on the Personalization capability page). Structured data should not be treated as an AI-citation hack, a way to claim entity clarity the visible content hasn’t actually earned.
Agent-delivery infrastructure as a separate layer
Everything above is content architecture: what your pages say, how they’re named, and how they link to each other. There’s a separate, adjacent layer worth naming precisely because it’s easy to confuse with content architecture: delivery architecture, whether an automated agent can actually retrieve what your site already says.
Infrastructure sidebar: Scrunch AI’s Agent Experience Platform (AXP). Scrunch AI’s AXP sits as edge middleware in front of a site, integrating with CDNs, detects when an AI agent rather than a human browser or a search-indexing bot is requesting a page, and serves that agent a structured, machine-readable version of the content. Scrunch’s own documentation is explicit that search-indexing bots (Googlebot, Bingbot) are not routed through AXP and that organic search crawling and indexing stay unchanged; AXP addresses agent retrieval specifically, not Google Search or AI Overview eligibility. Scrunch AI became part of Sitecore following an acquisition Sitecore announced on June 3, 2026, so it’s referenced here as one illustration of the delivery layer, not evaluated as a standalone independent vendor.
The nuance worth stating directly: Google has no additional AI-Overview or AI-Mode requirements beyond ordinary Search eligibility, so nothing above is a prerequisite for appearing in Google’s AI search features. AXP’s routing targets a different, adjacent situation, other agent-retrieval contexts beyond Google’s own crawlers. Agent-facing delivery infrastructure is an emerging option worth knowing about, not a requirement for the content-architecture work this article is actually about.
Get started
Your minimum viable entity architecture, starting from nothing: the smallest version that’s still real work, not a reading exercise.
- List your five to ten most important entities (company, top capabilities, any named methodology) and give each a one-row Entity Registry entry: canonical name, canonical URL, two or three accepted aliases.
- List your three to five most-repeated claims (proof figures, methodology counts, named results) and give each a one-row Claim Registry entry: canonical value, exact scope in one sentence, source, last-verified date.
- Pick your two or three highest-traffic pages and check them against both registries: does every entity mention link to its canonical home, does every claim match its registry scope and link to its evidence.
- Fix what you find on those pages first, then expand the registries and the audit outward as you touch more pages for other reasons. Don’t attempt a full-library pass in one sitting.
That’s a maintainable starting artifact, not a finished system. It grows the same way the rest of your content library does: incrementally, as you touch pages for other reasons, checked against a written registry instead of memory.
Alex’s Perspective
Naming and proof drift is a governance problem long before anyone notices it page by page. It starts as one article using a slightly different phrase than the capability page, or one proof claim restated without its link, and neither looks like a problem in isolation. AI search makes the accumulated version of that drift more consequential, because a system trying to verify a claim across a site either finds a governed structure it can check or a pile of disconnected restatements it can’t. The fix was never a writing-quality fix. It’s an Entity Registry and a Claim Registry, maintained on a cadence, with an owner who actually checks new pages against them before drift has a chance to compound.
Alex Harris brings 26 years of digital experience and conversion optimization work to auditing marketing stacks for gaps between what a system was told and what it can actually verify, the same diagnostic instinct now applied to whether a site’s own entities and claims are governed clearly enough for an AI search system, or a new reader, to check them.
If you’re not sure whether your own content library has already fragmented its entities or let its proof claims drift, start with one entity: write down its canonical name, its aliases and its canonical URL, then check how the site actually uses them.


