The Agent Clicks Like a Human, and Gets Overwhelmed Fast
ChatGPT Atlas, Perplexity Comet, Claude for Chrome: these agents look at the rendered page and click their way through, the way a human would. That's flexible, but error-prone. One ambiguous button, one unlabeled form field, one layout that shifts, and the task falls apart. You can rank at the top of an AI answer and still lose the sale because the agent got stuck at checkout.
The failure points are known and they repeat. Most fixes are small, targeted interventions, not a relaunch.
How the Agent Actually Does It
"Like a human" is only true in outcome, not in method. The agent doesn't see your page the way a human does — it reads it. It takes a screenshot and, in parallel, pulls the accessibility tree: the browser's own structure of roles, names, and states for every interactive element. From that it determines which element matches the task, then fires a targeted event — a click or an input.
Read the page
Screenshot + accessibility tree, pulled in parallel
Match the element
"The field is called Email — the address goes there"
Fire the event
A targeted click or input on that element
It prefers the accessibility tree because it's the most unambiguous. In practice that means: anything cleanly marked up structurally, it finds reliably. Anything that only "looks like a button" visually but isn't one structurally stays a guessing game based on the screenshot — slower and more error-prone. That's where most stumbling blocks arise.
Screenshot-only guessing
- Elements that "look like" a button but aren't marked up as one
- Layouts that shift, so a remembered position no longer matches
- Text buried in images or heavy client-side JS
Found via the accessibility tree
- Native elements with clear roles and states
- Fields linked to descriptive, programmatic labels
- Content present in the structure, not just the pixels
The Most Common Stumbling Blocks
In April 2026, Google published recommendations for agent-friendly websites. Combined with the patterns agents actually trip over in practice, that adds up to this list:
Unstable layout
Elements that jump while loading, or buttons that sit in different places depending on page type: a screenshot-based agent then clicks into empty space. Fix: consistent layouts and a low CLS score (fixed image dimensions, placeholders).
<div onclick> instead of <button>/<a>
Homemade clickable elements barely show up in the structure. Fix: use native elements; where that's not possible, at least set role and tabindex.
Unlabeled buttons and fields
An icon button without a label, or a form field without a <label>, is nameless to the agent. Fix: descriptive labels, programmatically linked form fields.
Transparent overlays
Invisible layers over interactive elements render them unusable to the agent, since hidden nodes get discarded. Fix: avoid them, or make them cleanly dismissible.
Heavy client-side rendering
A page that's empty until JavaScript runs is empty to many agents too. Fix: server-render core content or place it high in the HTML.
Mouse- and hover-only interaction
Menus that only open on hover, or drag-and-drop with no alternative, are unreachable for the agent. Fix: make them operable via focus and click.
Infinite scroll without pagination
The agent doesn't know when it's done. Fix: offer pagination or a clear endpoint.
CAPTCHAs on every interaction, hard bot-blocking
This catches legitimate agents acting on a user's behalf just as much as it catches abuse. Fix: apply it selectively at sensitive points rather than across the board.
One Step Further: WebMCP
Removing the stumbling blocks means staying out of the agent's way. WebMCP goes further: instead of making the agent interpret the interface, you declare your key actions directly, so it no longer has to guess what a given button does. That makes interaction more consistent, especially for complex flows.
WebMCP is early rather than widely available, but it's the active counterpart to the same work — declaring actions instead of letting the agent infer them. How it works technically, and how you measure agent access along the way, is covered in a separate article.
How Much of a Difference It Makes
This isn't a marginal effect. A study by UC Berkeley and the University of Michigan (A11y-CUA, CHI 2026) had a current-generation agent complete 60 everyday tasks, comparing two interaction paths.
~78% success
The agent clicked by sight, the way it does by default on most sites today.
~42% success
The non-visual path — the same one screen readers and the accessibility tree take.
The success rate was nearly cut in half, simply because the agent had to rely on structural navigation instead of clicking by sight. Structure isn't a nice-to-have — it's a large share of whether the task completes at all.
Testing Without Guessing
You don't have to do this blind:
Run through it with real agents
Perplexity Comet's agent mode is free. Have it work through your critical paths: search, cart, booking, inquiry. In a professional context, it's worth testing across the common agents rather than sticking to one browser — their behavior differs.
Set up a fixed test case
Rather than trying it once, build your key tasks into a repeatable, automated test that runs regularly. That way you immediately notice when a relaunch or new feature breaks a path for agents — essentially a regression test for usability.
Keep an eye on the Agentic Browsing Audit
Google is bringing its own audit to Lighthouse that checks a page for agent-readiness, from semantic structure to typical blockers. It arrives with Chrome 150 — not yet in the current version 149 — and for now can only be tried early via Chrome Canary.
Look at the accessibility tree
In Chrome DevTools (Elements → Accessibility), you see exactly the structure the agent encounters — where names or roles are missing.
A Side Note: The Same Effort Pays Off Multiple Times
The practical bonus: almost all of these fixes — semantic HTML, clear labels, server-rendered content, a low CLS score — are the same ones that make your site better for screen readers and for search engines. CLS, for instance, you're already tracking via Core Web Vitals, in PageSpeed Insights and Search Console. Google is essentially saying that agent-friendly and human-friendly converge here. So you're not building for some exotic new audience — you're hardening fundamentals that already pay off across multiple channels.
English 
German