An entity is a resolved, machine-readable identity for your company that is distinct from your website. Without one, engines treat every mention of your name as an unlinked string rather than evidence about you.
Resolution is the whole job. Fifty mentions that a machine cannot tie to one identity are worth less than five that it can.
The word gets used loosely enough to be useless. In practice it means something specific and testable: a thing with an identifier, a set of statements attached to it, and enough agreement across sources that a machine will merge them rather than keep them apart.
What is an entity, precisely?
Take the definition from the systems that actually implement it. Wikidata’s introduction describes items as uniquely identified by “a Q followed by a number, such as Douglas Adams (Q42),” each carrying a label, a description and aliases. Facts about the item are statements, which “consist of a property and a value.”
That is an entity in the strict sense, and it has three parts.
- What it is
- A stable key that is not your name and not your URL. A Wikidata Q-number is the canonical example.
- Why it matters
- Names collide and domains change. The identifier is what survives both.
- What it is
- Property and value pairs: founded in, headquartered at, industry, founder, product.
- Why it matters
- These are the attribute answers an engine can give confidently, because they are stored as facts rather than inferred from prose.
- What it is
- References from other sources pointing at the same identity rather than at a similar name.
- Why it matters
- Resolution is what converts scattered mentions into accumulated evidence about one company.
Why does an unresolved name break everything downstream?
Because an unresolved name is a string, and strings do not accumulate. If a review site, a podcast transcript and a comparison page each mention you, and nothing connects those three mentions to one identity, a model sees three unrelated strings that happen to look alike.
This is the difference between being talked about and being known. It also explains a pattern that confuses people: a brand can have real market presence and still be absent from AI answers about its own category, because presence in prose is not the same as presence in a graph.
It is the upstream cause of the split in entity problem vs content problem AI visibility. A content problem is “the page does not answer the question.” An entity problem is “the machine does not know which company this page is about.”
How do machines decide two names are the same thing?
Through explicit assertions, mostly. The sameAs property exists for exactly this: schema.org defines it as the “URL of a reference Web page that unambiguously indicates the item’s identity. E.g. the URL of the item’s Wikipedia page, Wikidata entry, or official website.”
Google frames the same mechanism in its own terms. Its organization structured data documentation says the markup “can help Google better understand your organization’s administrative details and disambiguate your organization in search results,” and describes sameAs as pointing to “a page on another website with additional information about your organization.”
The operative word in both is disambiguation. You are not describing yourself for a human reader. You are telling a machine which of several similarly named things you are.
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Example Analytics",
"alternateName": "ExampleAnalytics",
"url": "https://example.com/",
"logo": "https://example.com/logo.png",
"sameAs": [
"https://www.wikidata.org/wiki/Q000000",
"https://www.linkedin.com/company/example-analytics/",
"https://www.crunchbase.com/organization/example-analytics"
]
}sameAs array is the part doing the work. Without it the block describes a company; with it the block claims an identity that other sources already reference.Does adding this markup put you in AI answers?
No, and it is worth being blunt because the opposite is widely sold. Google’s documentation on AI features states there are “no additional requirements to appear in AI Overviews or AI Mode, nor other special optimizations necessary,” and that there is no special structured data to add and no new machine-readable files to create. The requirement is that a page “must be indexed and eligible to be shown in Google Search with a snippet.”
Entity work is not a markup trick that gets you into AI answers. It is disambiguation, and its payoff is accuracy rather than admission.
So what does it buy? Correctness. When an engine is confident which company you are, it answers attribute questions about you from stored facts rather than from guesswork, and it stops blending you with a similarly named company. That is the difference between an answer that is wrong about your pricing and one that is right, which is the failure mode in AI giving wrong information about my product.
What does an unresolved company look like in practice?
Three symptoms show up together, and any one of them on its own is usually something else.
The first is confident wrongness about basic facts. An engine states your headquarters or your founding year incorrectly and does not hedge, because it has merged you with a company that shares part of your name.
The second is inconsistency between engines on those same facts. Genuine uncertainty produces hedging in every engine at once. Disagreement between engines points at different source sets, which is a resolution failure rather than a knowledge gap.
The third is being described accurately but generically. The engine knows what you do and cannot say what distinguishes you, because the statements attached to your identity stop at category membership. That one is the mildest and the most common in B2B, and it is what a thin entity looks like from the outside.
What actually builds an entity?
Four things, in rough order of effort against payoff.
alternateName rather than in circulation.Step three is the slow one and the one that compounds. Being named on sources the engines already trust is what moves you from a string to a thing, and it is the same mechanism that decides whether you get mentioned at all, covered in how large language models decide which brands to recommend.
How do you tell whether it worked?
Ask engines attribute questions rather than opinion questions. “Who founded X” and “where is X headquartered” test resolution directly, because a model with a resolved entity answers them consistently and a model without one either hedges or invents.
Then check consistency across engines. If three engines agree on your founding year and one is confidently wrong, the wrong one learned from a source the others did not, and that source is findable. Track those attribute answers alongside your visibility numbers, because they move on a different clock: entity resolution improves over model generations, while retrieval responds in days, a split covered in mention rate vs citation rate.