How AI Agents Actually Use Websites (and How to Make Yours Agent-Ready)
How browser agents read and operate websites, where they fail, what WebMCP changes, and a practical checklist to make your site agent-ready.
Quick answer
AI agents use websites by reading a machine view of the page (a screenshot, the HTML or the browser's accessibility tree), deciding what to do next and then clicking, typing and submitting like a person would. They fail on the same things that trip up screen readers: unlabelled buttons built from `div`s, forms without labels, layouts that shift, invisible overlays and flows that hide prices or rules until late. To make a site agent-ready, fix semantic HTML and accessibility first, make key facts and policies visible, keep sensitive actions behind explicit confirmation, and consider exposing structured tools (WebMCP, an API or commerce protocols) for your most important tasks.
Agents are a new kind of visitor
For two decades websites have had two audiences: people and search crawlers. A third has arrived. Browser agents (ChatGPT agent, Gemini's agentic browsing in Chrome, agent modes in AI browsers, and custom agents built on computer-use models) visit sites to finish a task: compare three insurance quotes, book a table, reorder office supplies, fill in a supplier form.
Google's web.dev team put it directly in its April 2026 guide *Build agent-friendly websites*: websites have a new type of visitor, and interfaces built around complex hover states, shifting layouts and fluid motion can be functionally broken for agents. Google's guide to generative AI features in Search makes the same point from the search side, noting that browser agents may access websites to complete tasks such as reservations.
How an agent reads your page
The web.dev guide describes three views agents use, often in combination:
| View | What the agent gets | Where it breaks |
|---|---|---|
| Screenshots | An image analysed by a vision model to find buttons, fields and text | Low contrast, tiny targets, overlays covering elements, content that moves between screenshots |
| HTML (DOM) | Structure, nesting, attributes and text | Click handlers on generic divs, meaning hidden in CSS, huge DOMs full of tracking markup |
| Accessibility tree | A browser-built list of interactive elements with role, name and state | Missing labels, wrong roles, custom widgets without ARIA, disabled states not exposed |
Why the accessibility tree matters most
The accessibility tree is the closest thing a browser has to a map of what can be done on a page. It strips away visual noise and lists each control with its role (button, link, textbox, checkbox), its accessible name ("Add to cart", "Email address") and its state (checked, expanded, disabled). An agent that can read that map does not have to guess what a styled box does.
That is why so much agent-readiness advice overlaps with accessibility work. A site that already meets WCAG basics for screen-reader users is most of the way to being usable by agents. Our website accessibility guide and accessible UI design guide cover the details.
Key takeaway
Agent-readiness is mostly accessibility with a new business case. If a screen-reader user can complete the task, an agent usually can too.
Where agents fail on real websites
The same problems appear again and again when agents try to complete tasks on business sites:
Businesses also use the same screen-reading technology to automate their own systems that lack APIs; see computer-use agents for business.
- Fake buttons: clickable `div`s and `span`s with no role or keyboard support
- Unlabelled inputs: placeholders instead of `<label>` elements, so fields have no accessible name
- Ghost overlays: transparent layers, cookie banners or chat widgets covering controls
- Layout shift: elements moving after the agent has decided where to click
- Hover-only menus: options that appear only on mouse hover
- Hidden facts: delivery cost, fees, availability or eligibility revealed only at the last step
- Unclear errors: a red border with no text explaining what went wrong
- Aggressive bot challenges: CAPTCHAs or blocks on every automated client, including legitimate agents
- Multi-step state in the client only: flows that break if a page reloads or opens in a new tab
The agent-readiness checklist
Most of these fixes are small, improve the experience for people too, and can be shipped incrementally. Google's web.dev guidance includes several of them: semantic elements, labels linked to inputs, stable layouts, no ghost elements, `cursor: pointer` on clickable items and interactive targets large enough to detect.
| Area | Do this | Why agents care |
|---|---|---|
| Controls | Use `<button>` and `<a href>`; add role and tabindex to any custom control | Recognized as actionable in the DOM and accessibility tree |
| Forms | Link every `<label>` to its input; use correct input types and autocomplete attributes | Agents know what to type where |
| Layout | Reserve space for images and banners; avoid content jumping after load | Screenshot-based agents click where elements were |
| Overlays | Make banners and widgets dismissible and never cover primary actions | Covered elements may be ignored |
| Facts | Show price, fees, stock, delivery, returns and eligibility early and in text | Agents compare options and must report accurate totals |
| URLs | Stable, shareable URLs for products, searches and filtered views | Agents can return to and cite a state |
| Errors | Specific, text-based error messages next to the field | Agents can correct and retry |
| Confirmation | Clear review step before payment, booking or data submission | Lets the agent pause for the user's approval |
Want to know where agents get stuck on your site?
ZSpace Labs runs agent and accessibility walkthroughs of key journeys (search, quote, booking, checkout) and fixes what blocks them. See our website development and UI/UX design services.
From clicking to calling: WebMCP and structured tools
Clicking through an interface is a fallback. It is slow, it breaks when the design changes, and it makes agents guess. The direction of travel is to let sites declare the actions they support so agents can call them directly.
WebMCP is a proposed web standard for exactly that. A page registers tools (a name, a description, an input schema and a function) through a browser API, and an agent in the browser calls them instead of operating the UI. Chrome shipped a developer trial in May 2026 and runs a public origin trial from Chrome 149 through Chrome 156; Chrome's documentation suggests uses such as filling complex structured forms correctly. The API surface is still changing (Chromium moved the entry point from `navigator.modelContext` to `document.modelContext`), so treat it as an experiment rather than a requirement. web.dev's guide notes that sensitive actions should still require user confirmation.
Outside the browser, the same idea already works through APIs and protocols: the Model Context Protocol for connecting AI applications to your services, and commerce protocols such as UCP and ACP for product discovery and checkout, covered in our agentic commerce guide.
Whether your business should offer such an interface, and what to expose first, is covered in should your business build APIs for AI agents.
| Approach | Best for | Maturity (Oct 2026) |
|---|---|---|
| Accessible, semantic UI | Every site; agents that browse | Established; do this first |
| Public API or MCP server | SaaS and services with programmatic tasks | Established and growing |
| Commerce protocols (UCP, ACP) and feeds | Product discovery and checkout in AI assistants | Live on some surfaces, early access on others |
| WebMCP tools in the page | Complex in-browser tasks: forms, configurators, bookings | Origin trial in Chrome; experimental |
Keep people in control of consequential actions
An agent acting for a customer is still acting for a customer. Payment, account changes, bookings with cancellation fees and anything involving personal data should have a clear review step that an agent can surface to its user before proceeding. Current agents generally pause for confirmation before purchases and other sensitive steps; your interface should make that pause natural, with an unambiguous summary of what will happen.
On your side, treat agent traffic like any other client: authenticate accounts properly, rate-limit, and decide which agents you trust. Signed agent requests now make that possible without blocking everyone; see how to verify AI agent traffic.
What the website of the next few years needs to be
Put together, the shift is less dramatic than headlines suggest but real. A website now has to be three things at once: a persuasive experience for people, a crawlable source of facts for search and AI answers, and an operable interface for software acting on someone's behalf. The businesses that adapt early will not be the ones with the most novel AI features; they will be the ones whose facts are clear, whose flows are accessible and whose key tasks can be completed by whatever the customer uses to reach them.
| Audience | Needs | Where to read more |
|---|---|---|
| People | Clear value, trust, fast pages, easy decisions | Page speed and conversion |
| Search and AI answers | Crawlable pages with specific, consistent facts | AI search visibility |
| Agents | Accessible controls, visible facts, confirmations, optional tools | This article |
How to start
- Pick three journeys that matter most (for example enquiry form, product search to cart, booking)
- Run them with an agent and with a screen reader; note every place either gets stuck
- Fix semantics and labels on those journeys first; they are usually quick changes
- Surface facts early: prices, fees, availability, policies
- Add a clear review step before any payment or submission
- Review bot protection so verified agents are not blocked by default
- Evaluate structured access (API, MCP, commerce protocols, WebMCP trial) for your highest-value task
AI search discoverability vs agent interaction
Being visible to an AI answer engine and being usable by an autonomous agent are different problems. Discoverability is about reading: crawler access, indexable pages and specific facts worth citing (see AI search visibility). Interaction is about doing: semantic controls, stable flows, visible prices and policies, authentication, confirmations and, increasingly, action interfaces such as APIs or WebMCP tools. A site can be cited constantly in AI answers and still be impossible for an agent to book or buy on, and the reverse.
| AI search discoverability | Agent interaction | |
|---|---|---|
| Goal | Be found and cited | Let software complete tasks |
| Depends on | Crawling, indexing, content quality, consistent facts | Semantic HTML, accessibility, stable flows, APIs, auth |
| Key data | Text, structured data, feeds | Prices, availability, policies, form fields, action endpoints |
| Measured by | AI impressions and referrals | Agent task completion, agent-placed orders |
Conclusion
AI agents read websites through screenshots, HTML and the accessibility tree, and they struggle wherever the page is ambiguous. The fix is mostly good engineering you should be doing anyway: semantic, accessible, stable interfaces with honest information up front and clear confirmation steps. Structured tools such as WebMCP are worth watching and piloting, but the accessible interface is the part every agent can use today.
For the strategic picture of how websites now serve people, search engines, AI systems and agents at once, read will AI agents replace websites?.
Planning a site that works for people, search and agents?
Talk to ZSpace Labs about building or upgrading your website with accessible, agent-ready journeys. Discuss your project.
Common questions.
An AI system that operates a web browser on a person's behalf: it reads pages, clicks, types and submits forms to complete a goal such as booking, buying or filling an application. Examples include ChatGPT agent, Gemini's agentic browsing in Chrome and agentic modes in AI browsers.