Becoming an Entity

Search stopped being about words a long time ago, and most marketing teams never got the memo. For a decade the job was to match strings: find the phrase people typed, put it on a page, point links at it, and wait. That system is gone.

Modern search engines and generative AI systems do not primarily index documents. They query knowledge graphs, networked databases where facts are stored as discrete, interconnected nodes bound by defined relationships. When someone asks ChatGPT or Google who founded your company, the answer does not come from a page that ranks. It comes from a node that exists. You can publish two hundred excellent articles and still be invisible to an AI assistant, because the assistant is not looking for articles. It is looking for a thing it recognises.

01Why did search move from strings to things?

Read that second number carefully. The number of facts grew far faster than the number of entities: the graph is not mainly hunting for new things to know about, it is deepening what it knows about things it has already accepted. Getting in is the hard part; once you are in, the system wants more detail about you.

What an entity actually is

In the patent literature an entity is something singular, unique, well-defined, and distinguishable. Keywords are linguistic and suffer polysemy: the token "Java" is a language, an island, and a slang word for coffee. An entity sidesteps all of it, each concept gets a unique machine identifier that resolves the ambiguity everywhere at once. "Tour Eiffel" and "Eiffel Tower" are not two similar things; they are two labels on one node. Every node is assembled from the same five components:

That last row is where authority actually lives. A node with attributes but no edges is a lonely record; a node with dense, corroborated edges into other well-established nodes is an entity the system trusts. Content connected to fifteen or more recognised entities has been observed at a 4.8-fold increase in AI Overview selection probability, and brands present in a recognised graph score around 35% higher on overall AI visibility, the same topical-authority effect that lands B2B brands on AI shortlists.

Reading the identifiers

Google's machine identifiers come in two flavours, and the prefix is diagnostic. The /m/ prefix is a legacy Freebase ID (migrated before 2015, usually deep cross-graph references); the /g/ prefix marks an entity created natively inside Google's graph from crawling and structured data. A company founded after 2015 has a /g/ ID or none at all, which means your node was built from what Google could scrape and reconcile, only as good as the signals you have published. That is the lever. Wikidata uses QIDs for items (Q5 is human) and PIDs for properties (P31 is "instance of"); every fact is a QID joined to a value through a PID.

02Why does this matter more now than it did in 2019?

The first layer is static, you can only hope you were in the corpus. The third layer you already influence with publishing and technical accessibility, which is where most RAG-facing effort already goes. The middle layer, the knowledge graph, is free to edit and it is where confidence comes from. When an entity is established in a recognised graph, generative models stop hedging: the output moves from "claims to be" to simply "is".

That third outcome is the expensive one, and it is exactly what hallucination-proofing your brand is built to prevent.

03What is an Entity Home, and why does it go first?

The three gates

Entity data is evaluated in sequence, you do not get partial credit for skipping ahead.

Understandability is a markup-and-plain-copy problem. Credibility means systems verify your assertions against roughly three independent, high-confidence sources before accepting them, one source is a claim, two is a coincidence, three is a fact. Deliverability means a brilliant entity architecture behind a JavaScript wall crawlers cannot render is one nobody will ever see. Underneath all three sits the NEEATT frame (Notability, Experience, Expertise, Authoritativeness, Trustworthiness, Transparency); notability is the anchor, you cannot be a trusted authority until the system has decided you are a distinct you, which is how E-E-A-T became an AI signal.

The schema layer

Declaring an Entity Home means nested JSON-LD in the head of the canonical URL. Four properties do the structural work, and this is the same @graph discipline behind schema for AI citations:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Corporation",
      "@id": "https://example.com/#organization",
      "name": "Enterprise Quantum Systems",
      "legalName": "Enterprise Quantum Systems Inc.",
      "url": "https://example.com",
      "foundingDate": "2016-03-15",
      "founders": [
        { "@type": "Person",
          "@id": "https://example.com/about/team#john-smith",
          "name": "Dr. John Smith" }
      ],
      "sameAs": [
        "https://www.wikidata.org/wiki/Q11223344",
        "https://www.crunchbase.com/organization/enterprise-quantum-systems",
        "https://www.linkedin.com/company/enterprise-quantum-systems"
      ],
      "mainEntityOfPage": { "@type": "WebPage", "@id": "https://example.com/about#webpage" }
    },
    {
      "@type": "WebPage",
      "@id": "https://example.com/about#webpage",
      "url": "https://example.com/about",
      "name": "About Enterprise Quantum Systems",
      "mainEntity": { "@id": "https://example.com/#organization" }
    }
  ]
}

{}

Three things people get wrong: they omit @id and wonder why the markup validates but nothing happens; they point sameAs at profiles that do not link back, breaking the reciprocity the echo depends on; and they duplicate the same organisation schema on every page, telling the crawler they have four hundred organisations instead of one.

Triggering a Knowledge Panel without Wikipedia

A Wikipedia article triggers a Knowledge Panel in roughly 52% of brand searches; organisations with no Wikipedia article still get panels in roughly 28%. So Wikipedia is a strong accelerant and a poor strategy, it is governed by a volunteer community with an active deletion culture, you do not control the page, and a botched attempt can get your domain blacklisted.

Step two is where most programmes quietly fail, it is unglamorous data-janitorial work with no dashboard payoff, so it gets deferred, and every later step is then built on sand.

04How do you engineer Wikipedia and Wikidata for entity SEO?

Wikidata is a free, open, secondary knowledge base built on RDF triple principles. Items (QIDs) carry labels, descriptions and aliases; facts are Statements, an item joined to a value through a property. Three structures turn a bare triple into something trustworthy: qualifiers add temporal and contextual parameters (start time P580, position held P39); references carry provenance (every statement should cite an external source, unreferenced statements are the first thing patrollers strip); and external identifiers (VIAF, ISNI, registry numbers) bridge your item into third-party databases. A Wikidata item with fifteen well-referenced, qualified statements and six external identifiers is worth more than a Wikipedia stub nobody maintains.

Batch reconciliation with OpenRefine

Adding one company by hand works; a product catalogue or author roster does not. OpenRefine is the standard tool: reconciliation programmatically matches unstructured text cells to unique QIDs, the moment your private spreadsheet joins the public graph.

Step four is the one people skip, and it prevents the worst failure mode in the discipline: confidently attaching your facts to the wrong node. Match on name alone and you will eventually merge yourself into a defunct Brazilian logistics firm.

SPARQL for people who do not write SPARQL

You query Wikidata through its SPARQL service. You do not need fluency, you need to read the namespace prefixes because they carry the meaning: wd: names a specific item, wdt: is the truthy predicate to a value, p:/ps:/pq: reach statement nodes and their qualifiers, and wdtn: builds external-identifier URIs when you federate out. Two queries earn their keep. The first catches duplicate external identifiers, run it quarterly, it takes seconds and catches the silent corruption that surfaces eighteen months later as a mysteriously wrong Knowledge Panel:

# Catch one external identifier attached to two or more items
SELECT ?item (GROUP_CONCAT(?extId; separator="|") AS ?idJoined)
WHERE {
  ?item wdt:P10701 ?extId.
}
GROUP BY ?item
HAVING (COUNT(?extId) >= 2)

The second federates the query service against another endpoint's SPARQL using a SERVICE block, constructing valid IRIs with BIND and CONCAT. Federation is where this stops feeling like SEO and starts feeling like data engineering, which is the correct feeling, you are maintaining records in a distributed public database.

# Federate the Wikidata query service out to another endpoint
SELECT ?wikidataItem ?factgridItem ?extID WHERE {
  ?wikidataItem wdt:P8168 ?extID .
  SERVICE <https://database.factgrid.de/sparql> {
    ?factgridItem wdt:P39 ?extID .
  }
  BIND(IRI(CONCAT("https://www.wikidata.org/wiki/", ?extID)) AS ?constructedIRI)
}
LIMIT 50

05How do you audit what Google actually knows about you?

import requests, json

ENDPOINT = "https://kgsearch.googleapis.com/v1/entities:search"

def audit_entity(query_string, api_key, entity_type=None):
    params = {"query": query_string, "key": api_key, "limit": 5, "indent": True}
    if entity_type:
        params["types"] = entity_type
    r = requests.get(ENDPOINT, params=params)
    if r.status_code != 200:
        raise Exception(f"API request failed: {r.status_code} {r.text}")
    results = []
    for item in r.json().get("itemListElement", []):
        node = item.get("result", {})
        results.append({
            "name": node.get("name"),
            "mid": node.get("@id", "").replace("kg:", ""),
            "types": node.get("@type", []),
            "description": node.get("description", "N/A"),
            "official_url": node.get("url", "N/A"),
        })
    return results

if __name__ == "__main__":
    print(json.dumps(audit_entity("OpenAI", "YOUR_KEY", "Organization"), indent=2))

Run it on a schedule and store the output. Four things are worth alerting on, and none of them show up in a rank tracker, though all of them change how an AI assistant describes you: the MID changes or disappears (your node was merged, split or dropped); the official URL stops pointing at your domain (someone else captured the binding); the description shifts (Google's understanding of what you are has moved, possibly toward a competitor's category); or a namesake starts outranking you for your own brand string.

06What entity SEO tools and metrics actually matter now?

Rank position is not dead but it is no longer sufficient. Three generative metrics are becoming standard: Share of Model (the proportion of generative answers in your category that reference your entity, the new share of voice); citation likelihood (how well your structure aligns with retrieval mechanisms); and contextual sentiment and accuracy (what models actually say about you). Start with the third because it needs no vendor: ask five models ten questions about your category once a month and write down what they say. You will learn more in an hour than most dashboards tell you in a quarter, and it pairs naturally with a prompt-to-citation measurement stack.

07What's the twelve-month build sequence?

Phase one assigns each entity a dedicated Home URL with nested JSON-LD (@id, @type, mainEntity, complete scalar properties) and body copy that plainly states function, parent, founding details and people, marketing copy about what you enable customers to achieve is useless here, say what you are. Phase two reconciles historical records with OpenRefine and mints or updates QIDs with statements, qualifiers and external identifiers, it can start while phase one runs but not before, because Wikidata statements should reference the Entity Home. Phase three is the Digital Brand Echo made real: harmonise every fact across directories and registries, establish bidirectional sameAs, and add independent secondary citations through high-authority press and original research, the same earned corroboration that AI engines already trust. Phase four runs scheduled API inspections, tracks Share of Model and sentiment, and re-validates schema so external changes never silently disconnect your node.

08What does this add up to?

Winning here is not the same as winning the old game, and it compounds differently, the same reason winning Google is no longer winning AI. Become a thing the machine knows, and the rest of your content finally has somewhere to attach.