AI Can't Read the Web (Yet)

We ran a simple experiment. We asked one of the most advanced AI systems in the world — OpenAI's GPT-5.2 — to tell us about a real Shopify store. The store had cryptographically signed manifests, structured product data, machine-readable policies, and JSON-LD discovery signals embedded in every page.

What happened next was equal parts depressing and illuminating. It played out in three acts.

Act 1: The Hallucination

We asked GPT-5.2: "Can you look at shop.rootz.global and tell me about it?"

GPT never visited the URL. Instead, it searched its training data, pattern-matched "Rootz Global" to a completely different company, and confidently told us about "Rootz Global Entertainment LLC" — a brand selling hoodies, mugs, and swim trunks. It described products that don't exist on the site, from a company that has nothing to do with us.

The kicker? GPT mentioned that there were "other unrelated sites/brands with names like Rootz (e.g., a data tech company at rootz.global)" — identifying the actual Rootz as the unrelated one.

This isn't a minor mistake. This is the AI equivalent of calling a hospital and being told about a hardware store because they share a street name. GPT didn't just get the answer wrong — it never even tried to find the right answer. It searched its memory instead of visiting a live URL, and its memory was wrong.

Act 2: The Blindness

We pushed back: "Did you actually look at it? Can you look at https://shop.rootz.global"

This time GPT did visit the page. It correctly identified the store as selling digital products — research papers about AI-mediated commerce. It read the product titles and prices. Progress.

But it completely missed everything under the surface:

• Three JSON-LD Schema.org blocks (Organization, Product, WebSite with AI Discovery properties)
• Meta tags pointing to the signed manifest URL
• HTML comments listing all AI Discovery endpoints
• A visible footer badge saying "This store publishes structured data for AI assistants"
• A complete signed manifest at /apps/ai-discovery/manifest with operator name, email, legal entity, mission, sector, and cryptographic signature

GPT told us: "The homepage doesn't show much about who runs the site."

Meanwhile, the page source contained the operator name (Steven Sprague), email address, legal entity (Rootz Corp.), mission statement, three business sectors, AI usage policies (quoting permitted, training not permitted, summarization with attribution), and an ECDSA signature from the store's unique Digital Name.

The AI read the page like a tourist skimming a restaurant menu. It saw the food but missed the nutrition label, the health inspection certificate, and the ingredients list.

Act 3: The Awakening

We pasted the JSON-LD block from the page source directly into the chat:

"additionalProperty": [
  { "name": "ai-discovery-manifest",
    "value": "https://shop.rootz.global/apps/ai-discovery/manifest" },
  { "name": "ai-discovery-knowledge",
    "value": "https://shop.rootz.global/apps/ai-discovery/knowledge.json" },
  { "name": "ai-discovery-feed",
    "value": "https://shop.rootz.global/apps/ai-discovery/feed.json" }
]

GPT instantly understood everything.

It followed the manifest URL and analyzed the complete signed data structure. It read the product knowledge base. It checked the feed endpoint (empty — no blog posts yet). It understood the cryptographic signature model. It analyzed the AI permissions framework. It even gave useful technical feedback: the content.json capability URL needed verification, and the generatedAt timestamp had a timezone offset worth noting.

GPT called the discovery pattern "the real unlock" and described it as "giving AI agents a deterministic, standardized set of capability endpoints to fetch."

Same AI. Same page. Completely different outcome.

The Control Test

For comparison, we also pointed Claude (Anthropic's Opus 4.6) at the same page. Claude found all three JSON-LD blocks on the first fetch, identified the AI Discovery manifest properties, followed the manifest URL, and confirmed all endpoints were live and returning valid signed data.

Same page, same signals. One AI found the structured data immediately. The other needed it pasted into the chat window. Different agents have different capabilities today — and that inconsistency is exactly the problem.

What This Means

This experiment revealed three distinct failures in how AI agents interact with the web today:

1. AI searches about URLs rather than visiting them

GPT's first response was pure hallucination because it searched its training data instead of fetching a live URL. This is the most common failure mode. When someone asks an AI "tell me about this website," the AI defaults to what it remembers rather than what exists right now. Memory is stale. Memory is wrong. Memory pattern-matches to the wrong entity.

2. When AI does visit a page, it reads text and ignores structure

GPT's second attempt was better — it actually loaded the page. But it only read the visible text: product titles, prices, navigation labels. It completely ignored the machine-readable structured data: JSON-LD, meta tags, HTML comments, and discovery links. It treated the page as a document to summarize, not as a data source to query.

3. Once AI sees structured data, it understands it perfectly

The moment we pasted the JSON-LD into the chat, GPT demonstrated exactly the behavior we want from AI agents: it followed URLs, parsed structured data, understood permissions, analyzed signatures, and gave technical feedback. The data format works. The understanding is there. The gap is discovery.

The Nutrition Label for Websites

Think about food. Before nutrition labels, you had to guess what was in your food. The ingredients were there — physically inside the package — but they weren't accessible in a standardized, machine-readable format. The FDA didn't change the food. They changed how the food described itself.

That's what AI Discovery does for websites. Your store already has an identity, products, policies, and contact information. AI Discovery doesn't change your store — it adds a standardized, signed, machine-readable layer that tells AI agents exactly where to find that information and how to verify it.

Today, AI agents are like shoppers in a store with no labels, no aisle markers, and no price tags. They can see the shelves, but they have to guess what's on them. AI Discovery is the labeling system.

Bootstrapping the Standard

There's a chicken-and-egg problem here. AI agents don't look for AI Discovery signals because not enough websites publish them. Websites don't publish them because AI agents don't look for them.

But the history of the web shows how this resolves. Schema.org started the same way — a few websites added structured data, Google started using it for rich snippets, more websites adopted it, and now it's ubiquitous. robots.txt started as a convention on a mailing list. /.well-known/ paths started with a handful of implementations.

Every Shopify store that installs AI Discovery adds another example to AI training data. Every manifest published makes the pattern more recognizable. Every signed endpoint teaches future AI agents that websites can describe themselves in structured, verifiable formats.

We're at the robots.txt stage. The convention exists. The first implementations are live. The data format works — GPT proved that when it finally saw the data. Now we need adoption.

Why This Matters for Your Store

If you're a Shopify merchant, consider what happened in our test:

• An AI was asked about a store and described a completely different company
• When it visited the actual store, it couldn't tell who runs it despite that information being in the manifest
• It couldn't find the policies that say quoting is permitted and training is not
• It couldn't verify that product prices and descriptions are accurate and current

This is happening to your store right now. When a customer asks their AI assistant about your products, the AI is guessing. It might get the price wrong. It might describe a competitor's product. It might say you don't have a return policy when you do.

AI Discovery fixes this. Not by changing how AI works — but by giving AI the structured data it already knows how to read, in a place it can find.

As our GPT-5.2 test proved: the AI understands the data perfectly once it sees it. The problem is showing it where to look.