Agentic SEO: Preparing Your Site for AI Agents and the Universal Commerce Protocol

For two years the AI search question was about citation: will an AI engine read my page and quote it in an answer. That question has not gone away, and our guide to Generative Engine Optimization covers it in depth. But Google’s 2026 AI optimization guidance opened a second front that is newer and moves faster: agentic experiences. (For a plain reading of that guidance overall, see Google’s official AI optimization guide, explained.) The shift is from an AI that reads your site to an AI that acts on it.

This guide explains what agentic experiences actually are, how an AI agent perceives a page differently from a crawler, what the Universal Commerce Protocol is trying to standardize, and what you can do today to be ready, without rebuilding your site around a protocol that is not finished yet.

From Reading to Acting

A traditional crawler fetches your HTML, extracts text and links, and moves on. A generative engine does the same and then synthesizes an answer. Both are passive. They consume your content.

An agent is different. A browser agent visits your site on a user’s behalf and tries to complete a task: find a product within a budget, fill a form, compare three options, start a checkout, book a slot. It does not just read the page. It interacts with it the way a person would, clicking, typing, scrolling, waiting for things to load.

This is already shipping in early forms. Browser-driving agents from the major AI labs can navigate a site, and Google’s guidance explicitly tells site owners that browser agents may access their website to perform analysis or act for a user. The relevant question is no longer only “can the AI read this page” but “can the AI operate this page without getting stuck.”

How an Agent Sees Your Page

This is the core mental model, and it is good news if your technical SEO is already solid.

An agent does not see your page the way a human sees the rendered design. It sees something much closer to what an assistive screen reader sees: the accessibility tree built from your semantic HTML. Button elements that are actually buttons, form fields with real labels, headings in order, links with meaningful text. The same structure that makes a page accessible to a person using assistive technology is, broadly, the structure that makes it operable by an agent.

This means the work overlaps heavily with things you should already be doing:

• Semantic HTML. A <button> that is a real button, not a <div> with a click handler the agent cannot find. A <form> that is a real form. Inputs tied to labels.
• Predictable structure. Stable, meaningful DOM. An agent that found the “Add to cart” control yesterday should find it today. Layouts that reshuffle randomly or hide critical controls behind opaque scripting break agent task completion the same way they break accessibility.
• Clear action text. “Add to cart” beats an unlabeled icon. “Continue to payment” beats “Next” with no context. The label is what the agent reasons about.
• Honest state. If an action failed, the page should say so in the DOM, not only through a visual color change an agent cannot interpret.

If you run a technical SEO audit and a full-site crawl regularly, much of this surfaces already: forms without labels, controls that are not real elements, status codes that lie about success or failure. A crawler that reports these issues is, increasingly, reporting agent-readiness issues too. Our SEO crawler guide covers how a complete crawl exposes this layer.

Structured Data in an Agentic Context

It is worth being precise here, because this is where hype tends to take over. We argued in the GEO guide that structured data is useful but not an AI ranking lever, and Google’s guidance is explicit about not over-investing in it. That nuance still holds for agentic experiences, with one practical addition.

For an agent trying to complete a transaction, machine-readable facts about a product (price, availability, identifier, currency) reduce ambiguity. If an agent has to infer the price from a styled span that might be a strike-through old price, it can get it wrong. Clean structured data for commerce-relevant entities is genuinely helpful for agents acting on your site, in a way that goes beyond rich results.

That is not a reversal of our position. It is the boundary of it: structured data is not a magic ranking input for AI answers, but for an agent executing a task, unambiguous machine-readable facts at the decision points (price, stock, shipping, the thing being acted on) lower the failure rate. Use it where an agent has to make a decision, not as a blanket ritual. Our schema markup guide covers where it pays off.

The Universal Commerce Protocol

Google’s guidance points at emerging protocols, and the Universal Commerce Protocol (UCP) is the one to understand at a high level even though it is early.

The problem UCP tries to solve: today, every agent navigating a checkout is essentially screen-scraping a UI built for humans. That is fragile. A small layout change can break an agent mid-purchase. A standardized commerce protocol would let an agent and a site exchange the structured facts of a transaction (catalog, cart, price, fulfillment, payment handoff) through a defined interface instead of by guessing at the DOM.

What this means for a site owner in practical terms, today:

• It is not a thing you implement this week. The protocol is not stabilized. Building against a moving target now is wasted effort, exactly the kind of premature optimization the GEO guide warns about with llms.txt.
• The foundation is the same regardless. A clean, crawlable, semantically structured site with honest status codes and unambiguous commerce data is the prerequisite for any agentic protocol. That work is not speculative, it pays off for SEO, GEO, accessibility, and agents simultaneously.
• Watch, do not chase. The right posture is the same one Google recommends for GEO generally: keep the technical foundation solid, follow the protocol as it stabilizes, and do not rebuild your stack around a draft.

What Not to Do

Agentic SEO is new enough that the bad advice has already started. A few patterns to avoid:

• Agent-only hidden content. Serving different content to detected agents than to users is cloaking. It carries the same risk profile as any cloaking, and the reranking and spam patterns we describe in the year-in-title and core update piece apply to manipulation here too.
• Agent-specific manifest files. There is no evidence a special “agents.txt” style file is read or needed, and this is the same pattern we documented for llms.txt: a proposed file with no adoption is not a strategy. If a real standard emerges, it will be announced.
• Blocking everything out of fear. Some operators want to block all agents at the robots.txt level. That is a legitimate choice for some content, but blanket-blocking agentic traffic also blocks the users those agents act for. Decide deliberately, per the trade-offs in our robots.txt and AI bots guide, not reflexively.
• Rebuilding around UCP now. Covered above. The protocol is a draft.

A Practical Agent-Readiness Checklist

None of this requires a new discipline. It requires doing the technical fundamentals well enough that an agent, like a screen reader, can operate the page.

1. Audit semantic HTML. Real buttons, real forms, labeled inputs, ordered headings. Fix controls that are <div>s pretending to be interactive.
2. Stabilize critical paths. The search, add-to-cart, and checkout controls should be findable and consistent, not regenerated with random identifiers each load.
3. Make state explicit in the DOM. Success, failure, and validation errors should be in the markup, not only in color or motion.
4. Tighten commerce data. Unambiguous price, availability, currency, and identifier at the point an agent decides. Structured data where a decision happens.
5. Decide your agent access policy. Choose deliberately what you allow at robots.txt, knowing agents act for real users.
6. Keep the SEO foundation. Crawlable, fast, honest status codes, clean internal linking. The same audit that serves SEO and GEO serves agents.
7. Watch the protocols, do not chase them. Track UCP and similar work. Implement when stable, not before.

How Seodisias Helps

Agent-readiness is, in practice, a technical-quality question, and most of it is visible in a thorough crawl. Seodisias surfaces the layer agents depend on:

• Structural integrity. Heading order, form and label presence, control semantics, the same signals that affect accessibility and agent operability.
• Honest status codes. Pages that return 200 while failing, soft errors, and redirect chains that confuse both crawlers and agents mid-task.
• Commerce data presence. Whether structured data exists and is consistent on the pages where a decision happens.
• Internal link and path health. So an agent following a task does not hit a dead end the same way a crawler does.

The point is the one this whole guide keeps making: there is no separate “agentic stack” to buy. There is a clean, well-structured, honest site, audited regularly, which happens to be what SEO, GEO, accessibility, and AI agents all need at once.

The Bottom Line

Agentic experiences are real and early. The shift from AI reading your site to AI acting on it is genuine, and Google now names it explicitly. But the preparation is not a new ritual or a draft protocol you scramble to implement. It is the accessibility-grade technical foundation you should already be building: semantic HTML, predictable structure, honest state, unambiguous data at decision points.

Do that, watch the Universal Commerce Protocol as it matures, ignore the agent-only files and cloaking shortcuts, and you are ready for the agentic web for the same reason you are ready for AI search: a clean, well-structured, trustworthy site works everywhere, whether a person, a crawler, an answer engine, or an agent is the one arriving.