Agentic browser SEO: getting found by Atlas and Comet

Perplexity's CEO put it plainly on The Verge's Decoder podcast: "The browser is the most agentic software that we use every day. It has your login state. It has all the pages you're on. It's the most powerful surface area where AI can actually take actions for you," Aravind Srinivas said. That is the whole shift in one sentence. For two years, getting cited by ChatGPT, Perplexity, and Claude meant earning a quoted sentence in a chat answer. Agentic browser SEO is a different, stricter bar: can an autonomous agent open your pricing page, read the number, fill your form, and finish the task without a human stepping in.

Traffic from AI agents and agentic browsers grew 7,851% year over year, according to HUMAN Security's 2026 State of AI Traffic & Cyberthreat Benchmark Report, and more than 95% of that traffic concentrated in three verticals: retail and e-commerce, streaming and media, and travel and hospitality. Those are exactly the categories built on pricing pages and comparison pages, the two page types this post is about. And the single biggest wrinkle in this space right now is that ChatGPT Atlas, one of the two browsers in this post's title, is being discontinued as a standalone app. That is a real fact you cannot skip, and it is also not the story. The story is that the capability is moving, not disappearing.

What agentic browsers actually do differently from chat answer engines

A chat answer engine reads your page once and writes a sentence about it. An agentic browser opens your page, decides what to click, and keeps going until the task is done or it gives up. That is the difference between being summarized and being used.

A citation in an answer vs. an action on your site

When ChatGPT or Perplexity answers a question in chat, the model retrieves a handful of sources, synthesizes an answer, and drops in a citation. Your job is to be extractable enough to be one of those sources. Perplexity Comet's Agent Mode is a different animal: it can fill forms, compare products across multiple sites, and complete basic transactions, and its enterprise tier adds autonomous multi-step tasks like booking flights and managing email, according to a landscape review of agentic browsers. ChatGPT Atlas's Agent Mode does the comparison-shopping version of the same thing: it opens tabs, navigates multiple airline or vendor sites, extracts pricing, and presents its own comparison table back to the user, per the same review. Neither of those is a citation. Both are your page being operated, not read.

Why classic AI crawlers and agentic browsers see two different websites

This is the part that trips teams up, because it looks like the same problem as classic AEO and it is not. GPTBot, ClaudeBot, and PerplexityBot are HTML-only crawlers; none of them execute JavaScript, so a client-rendered pricing table can be invisible to all three, a gap we've covered in depth separately. Agentic browsers are the opposite case. Comet and Atlas drive a real, full browser session, Chromium under the hood, so they do execute your JavaScript. Their failure mode isn't a blank DOM, it's stalling on an unclear form label, a login wall, or a multi-step flow that assumes a human who already knows what to click next.

That real-browser architecture has a second consequence worth knowing before the rest of this post: because Comet and Atlas ride the underlying browser's own session, their traffic carries that browser's normal user agent string instead of announcing itself as a bot, making the agent effectively invisible at the HTTP layer. Perplexity's crawler documentation draws the same line from a different angle: PerplexityBot, the discovery crawler, respects robots.txt, but Perplexity-User, the live fetcher that powers Comet, generally ignores it, because a human explicitly asked for that page right now. If your mental model of AI traffic control is "block the user agents I don't want," agentic browsers are the case where that model breaks, and robots.txt for AI bots covers the allow-list mechanics you'll still need for the crawlers that do respect it.

The current-events wrinkle: Atlas is being folded into ChatGPT, not staying a standalone browser

Here's the fact you can't skip if you're writing about this topic in mid-2026: OpenAI is sunsetting Atlas as a standalone app, TechCrunch reported, folding its agentic capabilities into the ChatGPT desktop app and a new ChatGPT Chrome extension instead of continuing to compete as a separate browser. Atlas access ends on August 9, 2026, according to reporting on OpenAI's shutdown notice. It's a short life for a product this loud at launch: Atlas arrived in October 2025 as a macOS-only release, Ghacks reported at the time, and eight months later it was still limited to Apple Silicon Macs; Windows, iOS, and Android versions were promised at launch and never shipped before OpenAI pulled the plug on the standalone app, less than a year after it debuted.

Here's why that shouldn't change what you do to your site. OpenAI isn't retreating from agentic browsing, it's conceding that a standalone browser was the wrong shell for it and moving the same capability into surfaces people already have open: the ChatGPT desktop app and a Chrome extension. If you were tracking Atlas referrals in your analytics, that gap already exists for a mundane reason, Atlas strips its referrer header before the visit reaches GA4, and the shutdown doesn't fix that; it just moves the same blind spot into whichever surface ships next. The mistake would be treating any of this as one app's UI problem. Optimize for the durable thing: an autonomous agent, wherever it's hosted, trying to read your price and complete your form. That target survives the rename.

Three concrete changes agentic browsers force on your site

None of this requires a rebuild. It requires treating three page types, pricing, forms, and comparisons, as the ones an agent is now actually operating rather than just reading.

1. Extractable pricing: one number per plan, consistent everywhere it appears

An agent comparison-shopping across vendor sites needs one clean number per plan, not a number buried in a JS-rendered widget or split across a toggle state. This is the same fix our pricing page SEO guide already prescribes for AI Overviews and ChatGPT citations, and it applies with even less margin for error here, because an agent building a live comparison table acts on whatever number it can parse, wrong or not. Offer and Product schema, price, currency, and availability as machine-readable fields, is the groundwork underneath that: agents use it to confirm a product is purchasable at a known price before recommending or buying it, and a mismatch between the schema and the visible page price gets flagged as an unreliable signal rather than resolved in your favor. Schema doesn't earn you a citation on its own, as we've written before, but for agentic commerce specifically, it's the difference between an agent trusting your price and quietly skipping you for a competitor whose numbers actually match.

We checked our own pricing page the way an agent's fetcher would: a plain curl with a generic user agent, no browser, no JavaScript. All three plan prices, $39, $149, and $399, came back as plain text in the raw HTML on the first response, because our pricing plans render server-side from a single source of truth instead of a client-side widget that only fills in after a script runs. That's the whole bar. If your prices only exist after a render, an agent doing the same fetch gets nothing to compare.

2. Frictionless flows: forms, labels, and checkout an agent won't stall on

Agents still fail on ambiguous forms, and the failure looks nothing like a crawler returning a 404. During an early hands-on test of Comet, TechCrunch documented the assistant hallucinating and entering the wrong dates while trying to complete a parking reservation, then confidently telling the reviewer the dates it invented were unavailable. That's not a fluke worth dismissing, it's the standing failure mode: unclear field labels, date pickers with no accessible text alternative, and multi-step checkouts that assume human context an agent doesn't have. Two emerging standards are aimed directly at this gap. Google shipped an early preview of WebMCP in Chrome Canary in February 2026, co-developed with Microsoft through the W3C, letting ordinary HTML forms and page elements become structured, agent-callable capabilities instead of guesswork over a rendered DOM. Google is pushing a second standard at the same problem from a different surface: the Universal Commerce Protocol, an open standard for the full commerce journey, discovery, consideration, purchase, order management, and identity linking, that Google built for AI Mode in Search and the Gemini app with partners including Shopify, Etsy, Wayfair, Target, and Walmart. It's not a Chrome feature, but it's aimed at the same multi-step checkout flow that trips agents up today, just from the search and assistant side instead of the browser. Neither is close to universal yet, but they're the direction the fix is heading: less inference, more structure.

3. Agent-readable comparisons: structured, not JS-gated, tables

When someone tells an agent to compare vendor X against vendor Y, that agent is doing on-page what comparison pages already do well for human buyers, if the table is real HTML and not a JS-gated widget the agent has to reason its way through. Real markdown-style tables, static rows, one feature per line, extract cleanly; a comparison rendered as an interactive filter with no server-side fallback does not. It's worth remembering the agent isn't limited to your own comparison page either. When someone asks an agent to "find the best tool for X," review-site data on G2 and Capterra frequently outranks a vendor's own page in what the agent surfaces, a dynamic we've covered separately, so a clean on-site comparison table is necessary but not sufficient on its own.

How to test your own site the way an agentic browser sees it

Don't guess whether your pricing and comparison pages are agent-readable. Run the audit built for exactly this, then watch a real agent try the page.

Run Lighthouse's Agentic Browsing audit

Chrome's Lighthouse 13.3, shipped May 7, 2026, added an Agentic Browsing category to the default audit config, available in Chrome 150 and later. Unlike Performance or SEO, it doesn't return a 0-100 score, it checks for an llms.txt file, WebMCP support, the accessibility tree, and cumulative layout shift, then reports a pass ratio. Run it against your pricing and comparison URLs first; those are the pages carrying the highest agent traffic, per the industry-concentration numbers above.

Watch it fail live: run Atlas/Comet against your own pricing and comparison pages

The audit tells you what's structurally missing. Watching an actual agent work tells you where it stalls, and those are often different findings. Open Comet or the ChatGPT desktop app's Agent Mode and give it a genuinely ambiguous task on your own site: "compare our Growth and Scale plans and tell me which is cheaper per seat," or "sign up for the free trial." Note the exact step it hesitates on, a toggle it can't parse, a label with no accessible name, a modal it can't dismiss. That's your fix list, and it costs nothing but ten minutes to generate. Given that roughly 12% of enterprise sites had begun WebMCP implementation by early 2026, with e-commerce leading adoption at close to 41%, per one industry adoption tracker, most of your competitors haven't run this test yet either.

The catch: doing this without turning your site into a bot playground

Here's what should give you pause before you optimize purely for agent completion rates. Comet and Atlas traffic is largely invisible at the HTTP layer, since it rides the underlying browser's own user agent, and Perplexity-User, the live fetcher behind Comet, generally ignores robots.txt entirely because a human asked for the fetch. That means you can't cleanly separate "agent shopping on my customer's behalf" from "scraper pretending to be a customer" using the tools that used to work for that job. Making your forms and pricing more mechanically parseable helps a legitimate agent complete a checkout for a real buyer, and it helps a bad actor's scraper do the same thing at scale. There's no clean fix here yet, WebMCP and UCP both bake in some form of user-mediated approval before an agent can act on sensitive steps, which is the right instinct, but it's early and neither standard is finished. The honest answer is to build for the agent that's actually trying to buy from you, keep an eye on the traffic you can't fully see, and not treat "agent-readable" as a synonym for "wide open."

Every fix in this post traces back to the same root discipline as classic AEO: facts that are true, structure that is clean, and nothing load-bearing hidden behind a script an agent can't parse. That is the same standard Lyra holds every post to before it ships. If you want a second pair of eyes on how your own pricing or comparison pages would hold up, talk to the founder.

Getting an agentic browser to complete a task on your site starts with the same discipline as getting cited in an answer: extractable facts, clean structure, nothing hidden behind a script it can't parse. Lyra fact-checks every claim and ships posts as a pull request you review before anything goes live.

Try Lyra → · Talk to the founder