From Markup to Memory: Building an Open Web for AI Agents

Most websites already did their schema.org homework. Products carry Offer markup. Articles carry NewsArticle. Hotels carry LodgingBusiness. But AI agents still get stuck at the exact moment they need to do something with that information, not just read it. That gap was the subject of Andrea Volpini’s talk at “E-commerce for Humans and AI Agents,” a workshop jointly organized by W3C and GS1 as a hybrid event in Zurich this September.

Andrea’s argument, in one sentence: structured data for AI agents needs to become something an agent can navigate on its own, not just a block of code buried in a page. Without that, the agent has to guess. And it often guesses wrong.

Markup Tells Search Engines What a Page Is. It Doesn’t Tell Agents What to Do

Schema.org solved a real problem for search engines. It gave them a shared vocabulary to describe what is on a page: this is a product, this is an article, this is a hotel. AI agents need something more. An agent arrives with a task. It wants to discover something, compare options, check availability, and eventually buy or book. Every major AI company now has its own way of handling that task:

Andrea’s point: none of these protocols should own the underlying facts about a business. The open web already has the right layer for that, built from four familiar building blocks:

• URI: a stable web address for each thing
• HTTP: a way to fetch it
• RDF: a shared way to describe facts about it
• Links: connections between related things

Agent protocols will keep changing. The facts about your business, organized this way, should not have to change with them.

The Test: Markup Helped. A Navigable Page Changed the Result

WordLift did not just theorize about this. The team ran a real test across 349 domains, 7 conditions, and 2,443 evaluations. The same information about the same entities was shown to an AI agent in three formats, then evaluated with two different retrieval methods:

• Standard retrieval: the agent searches once and writes an answer from what it finds.
• Agentic retrieval (RAG): short for retrieval-augmented generation, the agent can search several times, follow links, and dig deeper before answering. This is the technique behind how most AI agents ground their answers in real data.

Here is what happened when each page format was scored against plain HTML:

The navigable page delivered four times the improvement of markup alone, a +29.6% lift in answer quality with standard retrieval and +29.8% with agentic retrieval. The gain came from making the page navigable, not from adding more code to it.

There was a second, more surprising result. On the Enhanced Entity Page, standard retrieval scored 4.69 and agentic retrieval scored 4.70, almost identical. Once the page itself is well structured, a smarter search technique adds very little on top. Agents spend a lot of effort compensating for poorly structured pages. Fix the structure, and that extra effort is no longer needed.

The Four Things That Turn a Page Into Memory

Andrea described four properties a page needs in order to become something an agent can genuinely use, not just cite. Most schema.org implementations are still missing at least one:

1. A stable web address (canonical URI): one address per entity that does not change every time the website gets redesigned.
2. Facts written as links, not prose: instead of a sentence the agent has to interpret, the fact points to another linked address the agent can follow directly.
3. Provenance: who published this fact, and when, so the agent can judge how much to trust it.
4. Declared capabilities: statements like “you can check availability here,” stated directly on the entity, instead of guessed from the surrounding text.

This is the idea behind Unentity Pages: making the entity itself a page an agent can visit and explore, instead of a piece of code hidden inside a page built for humans.

GS1 Already Solved Identity. Meaning and Action Are Still Missing

For commerce specifically, GS1 (the organization behind barcodes and product identifiers) already gives every product a stable identity: a GTIN, turned into a real web address through GS1 Digital Link, and described using GS1’s own shared vocabulary. That solves identity. Andrea’s talk added two layers most businesses still lack:

If an agent does not understand a business’s own vocabulary, having the right tool available does not guarantee it uses that tool correctly.

The Missing Bridge Between Schema.org and Tools

Schema.org describes what something is. WebMCP describes what an agent can do. In between sits what Andrea calls the action graph: a business’s own rules for what it fully automates, what it only describes, and what it hands off to a human or a partner.

Andrea used a hotel-booking example. An accommodation entity carries the usual schema.org details: amenities, location, prices. On top of that, the business declares its own action graph:

In plain terms: “you may check availability directly here, but you may not complete a booking without a human or partner system involved.”

This same pattern works well outside travel too:

Same underlying idea, three very different sets of allowed actions.

From Free to Paid: A New Way to License Content

One of the more interesting parts of the talk covered publishing, based on a project with Ippen Digital on its Merkur.de site. The model splits access into two layers, one free and one paid:

1. An agent reads the public Enhanced Entity Page: a summary, the facts, related entities, and where they came from.
2. The publisher decides whether those public facts are enough, or whether the question needs deeper, paid content, such as the full article text or a licensed excerpt.
3. If paid access applies, the agent requests a machine-readable offer: a price and a license, in a format the agent can read automatically.
4. Payment happens through an emerging standard for agent payments (AP2 or x402), which proves the agent really intends to pay, rather than assuming it does.
5. The agent receives the full, licensed content, along with its source and citation.

Public facts create interest. The publisher’s own rules put a price on the rest. This is the mechanism behind the AI content licensing approach being tested with Ippen Digital, and it turns a real worry publishers have (AI companies using their content for free) into a structured, paid transaction instead.

Real Results, Not Just Theory

None of this is theoretical for the brands already using it:

Two Open Problems Worth Watching

WebMCP is still new, and other speakers at the same workshop pointed out real gaps worth tracking:

Being Visible Was Never the Finish Line

The idea running through Andrea’s talk, and through the working group WordLift is helping shape at W3C and GS1, is simple: do not rebuild the open web inside every new agent protocol. Web pages built on stable addresses and linked facts should remain the shared source of truth. WebMCP is the new layer on top, for exposing what actions are allowed. A website is genuinely ready for AI agents once an agent can:

1. Find it: locate the one, stable version of an entity.
2. Explore it: move from that entity to related facts and entities.
3. Act on it: trigger declared actions without locking the business into one AI provider’s system.

Get those three right, and being cited stops being the ceiling. The entity itself becomes something an agent can actually act on.

Key Takeaways

• Markup alone is not enough. JSON-LD alone barely moved answer quality (+0.27 points). A fully navigable entity page moved it four times more (+1.07 points).
• A well-built page reduces how much the AI has to work. Agentic retrieval barely outperformed standard retrieval once the entity page itself was properly structured.
• Schema.org and WebMCP solve two different problems. One describes what something is. The other tells an agent what it is allowed to do with it. The link between the two is a business’s own action graph.
• The results are already measurable, from double-digit gains in AI Overview citations for eyewear and skincare brands to a live paid-access model for publishers.
• The ecosystem still has open gaps, from persistence across pages to accessibility for screen readers.

Try It on Your Own Entities

If your team has already invested in schema.org and is still asking why AI agents mention you but rarely act on your behalf, the fix isn’t more markup. It’s turning your entities into pages an agent can explore, and stating, in your own terms, what it’s allowed to do next.