Is Your Website Ready for AI Shopping Agents?
By Mobina
Most websites aren't ready. AI shopping agents like Comet and Claude for Chrome can already read a pricing page perfectly, then stall at checkout, forms, or comparisons, usually over one unlabeled button, not a broken site. The fix is native HTML controls, real labels, then clean schema, in that order, and it usually takes about a week.
An AI agent visited your pricing page this morning. It read every word correctly, summarized your plans without a single error, and then got stuck trying to add the cheapest one to a cart, on a button your own team built without a second thought. Nobody noticed. Nothing in your analytics tells that visit apart from a person who opened the tab and left. Your site has a new kind of visitor, and most products were never tested against it.
Here's the shift in full, before the rest of the piece unpacks each row:
| What most teams still assume | What's actually true right now | What to do about it |
|---|---|---|
| AI traffic on your site mostly reads and cites pages | It's increasingly trying to finish tasks on them: checkout, forms, side-by-side comparisons | Test whether an agent can complete something, not just describe it |
| A failed agent visit is a security or SEO issue | It's a UX issue first. The same components that fail a screen reader fail an agent | Fix native controls, then labels, then schema, in that order |
| This is a 2027 problem, plenty of runway left | Agent traffic could be 25 to 35 percent of enterprise web activity by the end of this year | Run the three-task test on your own site this week |
We've written before about what it takes to be the page a model chooses to cite. Your Website Has a New Reader covers that ground: answer-first writing, sections built to survive being lifted out of context. That work hasn't stopped mattering. It just stopped being the whole story the moment the reader started reaching for the mouse.
The browser grew hands
Claude for Chrome went from around 40,000 installs in December to over 10 million by June, crossing a million as early as February. Perplexity dropped Comet's paywall in March and rolled it out free across desktop, iOS, and Android. OpenAI's standalone Atlas browser, by contrast, is being shut down. It stops working August 9, folded into the ChatGPT desktop app and a Chrome extension instead. Chrome itself has a preview of WebMCP running, which is the early version of Google shipping agentic browsing by default, plausibly within a couple of stable releases.
None of that traffic looks unusual in a dashboard, and that's a different problem than the one we've written about before. Crawler traffic comes from data centers and at least announces itself as something other than a person. A browsing agent doesn't. It's sitting inside someone's real, logged-in session, on their home connection, running an errand while they make coffee. Industry estimates put agent-generated traffic at 25 to 35 percent of enterprise web activity by the end of this year. You are probably already hosting some of it. You just can't see which visits they were.
Reading is solved. Acting isn't.
Congratulations: you've built a site for a genius librarian who lacks thumbs.
We call this the Completion Gap: the distance between an agent that can describe your product in six languages and one that can actually buy the damn thing.
- 1.A 2026 field test put 4 major browser agents through the ringer. The results were less "Skynet" and more "toddler in a cockpit."
☑︎ Native HTML controls? Handled fine.
☑︎ Accessible labels and clean schema? Agents breezed through.
☐ Custom widgets and JS-only buttons? Total mechanical failure.
While most product teams are still figuring out where to put the "Submit" button, the adults in the room are moving on:
- The Plumbing: Microsoft, Salesforce, and ServiceNow are already using the Model Context Protocol (MCP) so agents don't have to guess what they're looking at.
- The Strategy: Gartner has already crowned "AI-native development" as a top strategic theme for the year.
The bar has moved. It's no longer "Can a human use this?" It's "Can a human, or the algorithm they sent to do their chores, actually finish the task?"
Where it actually breaks
| An agent usually handles this fine | An agent usually gets stuck here |
|---|---|
| Reading and summarizing page content | A checkout that needs a drag, hover, or custom slider |
| Following standard links and menus | A "buy" button that's a styled <div> with an onClick handler, not a <button> |
| Extracting a pricing table with clear schema | A multi-step form with no labels on the inputs |
| Answering "what does this page offer" | Completing "select plan, apply code, confirm" in one pass |
The pattern underneath all four rows is the same. Agents fail exactly where a screen reader would also fail. That's not a coincidence, and it's the part worth sitting with for a second: the accessibility work most teams already deprioritized is turning out to be the same work that makes a product usable by the other kind of visitor showing up now.
The three-task test
You don't need a research budget to find out where you stand. Open Comet, Copilot Mode, or ChatGPT's agent mode on your own site and try three things.
Phase 1: The "Toddler in a Cockpit" Diagnostic Test
Don’t panic. Just see where the robot gets confused.
- 1.Task 1: The Shopping Test: Add your cheapest plan or product to a cart. Can the agent actually reach the checkout? If not, congratulations, you have a "broken" checkout that no human reported because humans just complain or leave.
- 2.Task 2: The Contact Test: Find your demo or contact request form. Can the agent fill out the fields and hit submit? If the agent stares at it blankly, your form is effectively invisible.
- 3.Task 3: The Comparison Test: Ask the agent to compare your product page to a direct competitor’s. If it fails, your data structure is likely too "artistic" and not "informational" enough.
Phase 2: The "Fix-It" Hierarchy
Follow this exact order. Most failures cluster on step one, so don't bother with a total redesign until you’ve done this. It’s a week of work, not a total overhaul.
- Priority 1: Native Controls (The "Divitis" Cure)
- The Crime: Using a <div> with an onClick handler as a "button."
- The Fix: Swap it for a real <button> element. Replace your custom, convoluted, "fancy" dropdowns with standard <select> elements.
- Why: If the agent can't "click" it like a browser does, it doesn't exist. You aren't being creative; you're being invisible.
- Priority 2: Labels (Don't Assume Psychic Ability)
- The Crime: Expecting an AI to guess what a field means based on context.
- The Fix: Give every single input a clear, semantic label. Yes, even the ones a human knows intuitively.
- Why: AI isn't psychic. If the label isn't explicitly there, the agent is flying blind.
- Priority 3: Schema Markup (Structured Data > Marketing Fluff)
- The Crime: Keeping pricing tables as pretty, unparseable text blocks.
- The Fix: Structure your pricing tables as actual data.
- Why: A pricing table an agent can parse as data is worth more than a page full of brilliant, persuasive marketing copy that the agent just treats as "background noise."
If your site relies on custom JS widgets, drag-and-drop sliders, or "styled divs" to function, assume they are invisible to the AI. Build for accessibility (the screen reader crowd), and you’ll accidentally build for the agentic crowd, too.
Structure is the briefing you can't give it
Right now, two different rooms in your office are having two very loud (and mostly useless) arguments about AI agents:
- The IT & Security Room: "Should we let these things on our network?"
- The SEO Room: "Is schema markup the silver bullet for ranking?"
Both conversations are fascinating, sure. But neither one is sitting in front of a Figma file, which is where the actual battle is being fought.
The most critical "briefing" your AI visitor will ever receive isn't a prompt you typed into a chatbot; it’s the code you pushed to production. When an agent shows up at your checkout, it wasn't briefed by you. It was briefed by the user, and it has zero memory of your brand beyond what’s currently on the page. It gets exactly one shot to figure out what a human would learn through trial, error, and a desperate support chat.
Think of it like this: If your design system is a pile of messy, custom, non-semantic widgets, you’re just handing the AI a map that leads into a wall. If your foundation is built from clean, semantic, native components, you’re handing the AI a GPS.
A site built from unlabeled divs gives an agent nothing to hold onto, no matter how "smart" the AI model supposedly is. You can’t prompt your way out of bad architecture.
The "Agent-Ready" Reality Check
Chrome is shipping agentic browsing by default in the next few releases. That’s not a rumor; that’s the starting gun. When that happens, expect agent traffic to double overnight, basically mirroring what happened when Perplexity’s Comet went free.
If your product still requires a human to "feel" their way through a confusing interface to check out, it’s not fully built anymore. It’s half-built. You’re ignoring a massive share of upcoming traffic that is literally incapable of "figuring it out."
The near future:
- Today: "Agent-ready" is an optional, nerdy checkbox.
- A year from now: "Agent-ready" will be the new "mobile-friendly." It will be assumed, then ignored, then quietly used to grade how professional (or obsolete) your business really is.
Don’t wait for a frustrated customer to email you because their robot assistant got confused and stopped buying your stuff. Test your site this week. Your developers are currently building the "brain" for the future of your sales; make sure they aren't building a lobotomy instead.
What changes before the rest of the web catches up
Chrome shipping agentic browsing by default, likely within the next two stable releases, roughly doubles the agent traffic hitting the average site overnight, the same way Comet going free did earlier this year. A product that only a person can finish using isn't fully built anymore. It's half-built for a share of the traffic that's about to get much larger, and right now the field working on this problem is still mostly empty.
Give it a year, and "agent-ready" will mean about as much as "mobile-friendly" meant in 2011: assumed, then ignored, then quietly graded on.
Run the three-task test on your own site this week, before a customer who couldn't check out tells you about the gap instead.
FAQ
An AI shopping agent is a browser-based AI system, like Perplexity's Comet, Claude for Chrome, or Microsoft's Copilot Mode, that can navigate a website and complete a task on a person's behalf: adding an item to a cart, filling out a form, or comparing two products. It's different from a search crawler, which only reads and indexes pages. A shopping agent acts inside a real, logged-in browser session, the same way a person would.
No. SEO and GEO are about getting a page found and cited by search engines and AI answer engines. Agent-readiness is about whether an AI agent already on your page can complete a task there, like checking out or submitting a form. A page can rank well and be fully citable and still fail every agent completion test if its buttons and forms aren't built with native, labeled components.
Not identical, but closely related. AI agents tend to fail on the exact same components that fail a screen reader: unlabeled inputs, custom controls without accessible roles, and ambiguous button text. Existing accessibility work covers most of what agent-readiness requires. Clean schema markup on top of that is the part accessibility work alone doesn't cover.
Usually not. In most cases the failures cluster on one or two components, typically a custom button or dropdown built without native HTML, rather than the whole site. Fixing native controls first, then labels, then schema, is normally about a week of targeted work, not a rebuild.
Start with whichever one is free and easiest to install, Perplexity's Comet and Claude for Chrome both work well for this. Run the same three tasks in each one: add an item to cart, submit a contact form, and ask the agent to compare your page to a competitor's. Different agents can stall on different components, so testing more than one gives a fuller picture.