EntityMap for AI Search SEO: Useful Discipline or Another Magic File?

SEOs should be suspicious when a new root-level file arrives with AI attached to the pitch.

We have seen the pattern before. A new file appears. A few people describe it as a way to help machines. Then the market turns it into a shortcut: publish this file, get more visibility, win more citations, feed the LLMs.

That is where EntityMap could go wrong.

The more interesting reason to take it seriously comes from Sylvain Deaure's note about publishing one for 1492.Vision. The hook is not that he blindly believed another AI file. It is that he started from the skeptical position. He was wary of llms.txt, markdown copies for bots, and schema claims that outrun evidence.

His objection was the right one: search engines and LLMs can read HTML, separate machine files can become spam surfaces, and any machine-readable claim should be checked against visible content.

So why publish an EntityMap anyway?

Because the useful version does not try to replace the site. It declares the load-bearing structure of the site: entities, predicates, relations, and evidence tied to real URLs.

For AI search SEO, the question is not "Can we add another file?" The question is "Can we make the site's entity model explicit, evidence-backed, and testable?"

What EntityMap Actually Declares

EntityMap v1.0 is a structured site-level index. The core deployment pattern is simple:

• entitymap.json at the site root.
• entitymap.html as a human-readable companion.

The format centers five pieces:

• Entities.
• Relations.
• Evidence chunks.
• Attribution.
• Verification status.

In plain English, EntityMap tells a machine:

• These are the core entities this site declares.
• These are the relationships between them.
• These are the source URLs that support the claims.
• This is who published the declaration.
• This is the verification status of the declaration.

That is why "semantic sitemap" is a useful mental model. A normal sitemap points to URLs. EntityMap points to the entity model behind those URLs.

It should not copy every page. It should not become a second version of the website. It should not invent claims the visible site cannot support.

The hard work is choosing what belongs in it: brand and organization entities, people, services, products, topical clusters, predicates, relations, evidence URLs, and the chunks that support each claim.

If the team cannot agree on those pieces, file generation is premature.

The 1492.Vision Example Makes This Concrete

The source pack for this article verified a live implementation on 1492.Vision. Both URLs returned HTTP 200 during the June 22, 2026 check:

• https://1492.vision/entitymap.json
• https://1492.vision/entitymap.html

The JSON file included these values:

That matters for two reasons.

First, the example is live and inspectable. We are not talking only about a specification page. There is a real JSON file and a real HTML companion that SEOs can review.

Second, the verificationStatus is honest. The file is self-declared. That means 1492.Vision is publishing its own entity declaration. It does not mean an AI assistant, search engine, or independent certifier has endorsed every claim.

That status should shape the SEO reading of the file. Use it as evidence to inspect, not proof to overstate.

EntityMap Is Not Schema, llms.txt, Or A Sitemap

EntityMap becomes easier to evaluate when it is separated from adjacent tools.

The schema comparison is especially important.

Ahrefs tracked 1,885 pages that added JSON-LD and found no major AI citation uplift in Google AI Overviews, AI Mode, or ChatGPT. That is useful because it measures outcomes instead of repeating a theory.

It also has limits. Critics including Mark Williams-Cook and Gianluca Fiorelli have argued that the test should not be stretched into "all structured declarations are useless." It tested a specific schema intervention on pages that were already being cited.

So the sober read is simple:

Schema markup should not be sold as a direct citation lever. EntityMap should not be sold that way either.

EntityMap has a different promise. It centralizes entities, relations, and evidence at the site level. That may help retrieval and review. It definitely helps the team audit whether the site can support its own claims.

The Real Value: Entity Discipline

Most sites do not have an entity file problem. They have an entity alignment problem.

The service page uses one phrase. The case study proves a stronger claim but is buried. The author bio carries trust signals that never connect to the article. Internal links connect by template instead of meaning. Schema repeats facts that the visible page barely supports.

EntityMap makes that easier to see.

To write a useful file, the team has to choose:

• Which entities matter most?
• Which relations are worth declaring?
• Which claims can be proven?
• Which URLs support each claim?
• Which declarations should be removed because the site cannot support them?

That is why the exercise has value even before any AI system fetches the file.

A weak EntityMap is not just a weak file. It is a diagnostic report on the site's entity strategy.

The best result may be a list of pages to fix:

• Rewrite a service page so it supports the declared entity.
• Add internal links from proof assets to service pages.
• Clean schema so it matches visible facts.
• Strengthen author and organization signals.
• Remove vague claims that the business cannot prove.

That is real SEO work. It connects directly to the same discipline behind AI SEO, AI SEO audits, and technical content systems that need to be readable by people and machines.

The SEOFrancisco Framework: Declare, Evidence, Align, Test

Declare

Start with the entity model, not the file.

List the entities the site can defend:

• Organization.
• People.
• Services.
• Products.
• Tools.
• Case studies.
• Topics.

Then define the predicates and relations in plain English. What is the brand known for? Which person is connected to which service? Which case study proves which capability? Which topic cluster supports which offer?

If the team cannot explain that in a document, the JSON should wait.

Evidence

Every declared claim needs a source URL.

Evidence should be visible on the page. That can include service copy, headings, author bios, case studies, citations, product pages, tool pages, or schema that matches the content.

EntityMap should point to evidence. It should not create evidence.

The audit question is direct: if a claim has no visible supporting page, why is it in the declaration?

Align

The entity story has to match across the site.

Check these layers:

• Page copy.
• Headings.
• Internal links.
• Author bios.
• Organization and person schema.
• Case studies.
• Navigation and footer.
• entitymap.json.
• entitymap.html.

If those layers disagree, fix the site before treating the EntityMap as publish-ready.

This is where EntityMap connects to normal SEO fundamentals: information architecture, internal linking, schema hygiene, and proof-led content.

Test

Publishing is not the finish line.

Test whether the file improves understanding:

• Ask an LLM to summarize the business using only the EntityMap.
• Ask live AI assistants about the brand and service categories before and after deployment.
• Check server logs for requests to entitymap.json and entitymap.html.
• Compare AI answers against the source URLs.
• Track citations, mentions, and answer accuracy over time.

The goal is not to prove that the file exists. The goal is to see whether machines describe the brand with more accuracy and less invention.

The EntityMap Decision Matrix

How I Would Test EntityMap On A Real Site

Here is the testing SOP I would use for a client site.

1. Save a baseline of current AI answers for the brand, primary services, core people, and category questions.
2. Crawl the site and list candidate entities from visible pages.
3. Choose the entities the business can defend with proof.
4. Map every claim to a source URL and page section.
5. Remove claims that lack visible evidence.
6. Align page copy, internal links, schema, author bios, and case-study links.
7. Generate entitymap.json.
8. Generate the entitymap.html companion.
9. Publish both files at the root.
10. Add discovery signals from the spec, such as a head link to JSON where appropriate, sitemap inclusion for the HTML companion, and a footer link if it fits the site.
11. Validate the files.
12. Ask a model to summarize the business using only the EntityMap.
13. Ask live assistants the same baseline questions again.
14. Check logs for file fetches.
15. Review answer accuracy, citations, and invented claims over several weeks.

The single best quick test is simple: give the file to a model with no other context and ask it to explain the business.

If the answer is vague, the file is vague. If the answer makes claims the site cannot prove, the file is too loose. If the answer is accurate and evidence-aware, the declaration is doing its first job.

Where SEOs Can Overclaim This

EntityMap can be useful and still be easy to oversell.

Avoid these claims:

• EntityMap guarantees ChatGPT citations.
• EntityMap guarantees Google AI Overview inclusion.
• EntityMap rewrites what a model already learned.
• EntityMap replaces schema.
• EntityMap replaces content and internal linking.
• EntityMap is adopted by a specific AI system because the file is discoverable.

The sources support a narrower claim:

EntityMap gives a site a compact, inspectable entity and evidence declaration. If a retrieval system reads it, the file can provide context. If no system reads it, the process can still improve entity alignment across the site.

That is a useful claim. It is also a testable claim.

This is the same standard I would use for any AI visibility tactic. Prompt tracking by itself is weak evidence. I covered that in AI visibility prompt trackers. JavaScript rendering screenshots by themselves are weak evidence too, which is why server logs matter in AI assistants and JavaScript rendering. EntityMap should be held to the same bar: inspect, deploy, monitor, compare.

Should You Publish One?

Publish an EntityMap if you can treat it like an audit deliverable.

That means you are willing to:

• Remove unsupported claims.
• Fix weak evidence pages.
• Align schema with visible facts.
• Strengthen internal links.
• Monitor logs and answer quality after launch.

Do not publish one because a vendor says it will get you cited by AI systems.

For SEOFrancisco, the practical view is this:

EntityMap is not a shortcut into AI search. It is a way to make your entity strategy harder to fake.

That is enough reason to test it on the right site.

FAQ

Is EntityMap a guaranteed way to get cited by ChatGPT or AI Overviews?

No. EntityMap can provide a compact entity and evidence declaration. It does not guarantee citations, rankings, or AI answer inclusion.

Does EntityMap duplicate website content?

No. It centers entities, relations, evidence chunks, attribution, and verification status. It should point to source pages instead of copying full pages.

What is the EntityMap HTML companion?

It is the human-readable entitymap.html file that sits alongside entitymap.json. It helps humans inspect the declaration without reading raw JSON.

Who certifies the claims in an EntityMap?

Files can be self-declared. The live 1492.Vision file checked for this article used verificationStatus: self-declared, so it should be read as publisher-declared evidence, not independent certification.

Is EntityMap the same as schema?

No. Schema marks page-level facts. EntityMap declares a site-level entity and evidence model. A good implementation should make both layers agree with visible page content.

Is EntityMap the same as llms.txt?

No. llms.txt is usually framed as source guidance for LLM consumers. EntityMap is a structured declaration of entities, relations, and evidence.

What should I test after publishing?

Test file accessibility, companion-page visibility, LLM summaries from the file alone, live assistant answers before and after launch, server-log fetches, and whether AI answers use real evidence pages instead of invented claims.

Should small sites use it?

Small sites can use the exercise if they have clear entities and proof pages. If the site is thin, start by improving the pages that would support the declaration.

About the Author