How Modern Search Parses Entities (And Why It Changes Everything)

An entity is anything that is singular, unique, well-defined, and distinguishable: a person, place, organization, product, concept, or event. "Apple" the company is one entity; "apple" the fruit is another. The word is identical, the things are not.

Search engines store entities in knowledge bases like Google's Knowledge Graph, where each entity has an identifier, a set of attributes (what it is, what properties it has), and relationships to other entities (who founded it, what category it belongs to, what it's used for).

This distinction matters because it changes the unit of optimization. You don't optimize a page for a string anymore. You optimize a page to be the best available description of an entity, or of a specific relationship between entities, for a specific search intent.

When you type a query, the engine runs it through a pipeline that looks roughly like this:

1. Tokenization & normalization, the raw query is split into units and cleaned up (spelling, casing, stemming).
2. Named entity recognition (NER), the system identifies which tokens refer to entities: brands, people, products, concepts.
3. Entity disambiguation, ambiguous mentions are resolved using context. "jaguar speed" resolves to the animal; "jaguar f-type price" resolves to the car.
4. Intent classification, the engine decides what you want to do: learn, compare, buy, navigate.
5. Retrieval & ranking, pages are scored on how well they cover the resolved entities for the classified intent, using both classic signals and semantic relevance.

The same parsing runs on your pages at index time. Google extracts the entities your content mentions, maps them to Knowledge Graph nodes where it can, and builds a picture of what your page, and your whole site, is about. This is the mechanical basis of topical authority: a site whose pages collectively cover an entity cluster in depth becomes the statistically obvious source for that cluster.

Entity salience: not all mentions are equal

Parsing doesn't just detect entities, it scores their salience: how central each entity is to the document. A page about "Shopify SEO" that mentions Shopify in every section header, defines it early, and covers its attributes has high Shopify salience. A page that name-drops it once does not. You can see this yourself with Google's free Natural Language API demo, which returns salience scores for any text you paste in.

Once you accept that the engine reads entities, several classic SEO habits stop making sense, and several new ones become obvious:

The compounding effect is real: every page you publish either strengthens or dilutes the engine's confidence in what your site is about. Random acts of content dilute. A planned entity model compounds.

“The sites that win now aren't the ones that mention a topic the most. They're the ones the machine can model the most confidently.”

1. Define your central entity

Decide what your site is about at the entity level, your brand, your product category, your core discipline. Write it down as a one-line definition. Every cluster you build should connect back to it.

2. Map attributes and relationships

For each entity you want to own, list its attributes (features, properties, specs, definitions) and its relationships (competitors, alternatives, parent/child concepts, use cases). This list is your content plan, each attribute or relationship with search demand becomes a page or a section. This is exactly what a topical map formalizes.

3. Use consistent, canonical naming

Pick one canonical name per entity and use it consistently in titles, headings, anchors, and schema. Variation is fine in prose; the load-bearing positions should be consistent so disambiguation is trivial.

4. Ship structured data that mirrors your model

Schema.org markup is how you hand the engine your entity model directly. At minimum: Organization with sameAs links on the home page, Article with a defined author on every post, and FAQPage where relevant.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Permanent SEO",
  "url": "https://permanentseo.com",
  "sameAs": [
    "https://www.linkedin.com/company/permanentseo",
    "https://x.com/permanentseo"
  ],
  "knowsAbout": ["Semantic SEO", "Entity SEO", "Topical Authority"]
}

5. Link entities together intentionally

Internal links are relationship statements. Link every attribute page back to its entity hub with a descriptive anchor, and link related entities to each other where the relationship is real. See our full internal linking strategy for the architecture patterns.

6. Verify how machines read you

• Paste key pages into Google's Natural Language API demo and check that your target entity has the top salience score.
• Search your brand + category and check whether Google shows a knowledge panel or correctly associates you with the topic.
• Ask ChatGPT and Perplexity what your company does, LLM answers reveal how well your entity is established in training and retrieval data.

LLM-based engines, ChatGPT Search, Perplexity, Gemini, and Google's AI Overviews, don't rank ten blue links. They synthesize answers and cite the sources they trust for each entity and claim. Their retrieval layers are built on the same semantic representations described above, which means entity-first content is doubly rewarded: it ranks in classic search and it's the content AI systems can most confidently quote.

In practice, the pages that get cited share three properties: they define their subject explicitly, they structure facts so they're easy to extract (tables, lists, tight paragraphs), and they come from sites with an established entity identity. That's not a coincidence, it's the whole thesis of AI search optimization.