AEO & GEO skill 12 of 13

Agent Readiness for AI Browsers and Assistants SKILL.md

The Agent Readiness skill makes Claude, Codex or another AI agent check whether AI browsers and assistants can understand and complete the key tasks on a site: comparing plans, checking availability, booking, buying or contacting. It tests real tasks with real agents, fixes the accessibility tree, labels and flows agents rely on, keeps facts machine-clear, tunes bot protection and assesses agent commerce protocols.

agent-readiness/SKILL.md, version 1.0.0, 1,337 words.

AI agents don't just read pages; they act on them. Browser agents from OpenAI, Google, Anthropic, Perplexity and others can open a site, compare plans, fill in a form, book a demo or start a checkout for a person. Google describes how such agents work: they may analyse screenshots, inspect the DOM and interpret the accessibility tree. [Confirmed, Google Search Central] A site that confuses a screen reader usually confuses an agent too.

This skill audits whether agents can understand and complete the key tasks on a site, and prepares for the protocols that let agents transact directly.

How agents meet your site

LayerWhat the agent usesWhat helps
VisualScreenshots of the rendered pageClear layout, visible labels, no overlapping pop-ups
StructureDOM and accessibility treeSemantic HTML, labelled controls, logical headings, ARIA used correctly
DataText, tables, structured data, feedsFacts in text, consistent prices, product and organisation data
ActionsLinks, buttons, forms, checkoutPredictable flows, clear errors, no traps
ProtocolsAPIs and standards such as UCP, ACP and MCPMachine interfaces for search, cart and checkout

Operating principles

  1. Accessibility is agent readiness. Labelled inputs, real buttons and logical focus order serve people and agents.
  2. Tasks, not pages. Audit the jobs that matter: compare plans, check availability, book, buy, contact, cancel.
  3. Facts in text. Prices, specs, policies and availability belong in HTML text, not only in images or scripts.
  4. Friction where it protects, not everywhere. Keep fraud controls, but avoid blanket challenges that stop legitimate, user-directed agents from browsing public pages.
  5. Watch the standards. Agent protocols are young; adopt through your platform where possible rather than custom builds.

When to use, and when not to

Use it for e-commerce, SaaS sign-up and pricing flows, booking and lead-generation sites, and any business where an assistant could complete the task for a buyer.

Don't use it for crawler policy (ai-crawler-access) or product feeds and AI shopping surfaces (ai-commerce-product-visibility), though they overlap.

Inputs to ask for, in one message

  1. The five to ten most valuable tasks on the site.
  2. Key templates: pricing, product, booking, forms, checkout, account.
  3. The platform (Shopify, WooCommerce, custom) and any bot protection.
  4. Accessibility audits or known issues.
  5. Whether you sell through feeds, marketplaces or agent checkout already.

Raw SKILL.md file

.md

This is the exact file agents read, including the credit header and licence notice. Save it as agent-readiness/SKILL.md.

---
name: agent-readiness
description: "Prepare a site for AI agents that browse and act for people: audit key tasks with real browser agents, fix the accessibility tree, labels, semantic HTML and flows agents rely on, keep prices and policies machine-clear, tune bot protection for user-directed agents, and assess agent commerce protocols such as Google's Universal Commerce Protocol, OpenAI and Stripe's Agentic Commerce Protocol and MCP. Use whenever someone mentions AI agents, agentic browsing, ChatGPT agent, browser agents, agent-friendly websites, agentic commerce, UCP, ACP, MCP for websites, or whether assistants can complete tasks on their site."
license: CC-BY-4.0
metadata:
  author: Afeez Adebayo
  author_url: https://afeezadebayo.com
  author_linkedin: https://www.linkedin.com/in/afeez-adebayo/
  author_x: https://x.com/za_icon
  source: https://afeezadebayo.com/skills-md/marketing/aeo-geo/agent-readiness/
  category: marketing
  subcategory: aeo-geo
  version: "1.0.0"
  created: "2026-10-10"
  updated: "2026-10-10"
---

# Agent Readiness for AI Browsers and Assistants

AI agents don't just read pages; they act on them. Browser agents from OpenAI, Google, Anthropic, Perplexity and others can open a site, compare plans, fill in a form, book a demo or start a checkout for a person. Google describes how such agents work: they may analyse screenshots, inspect the DOM and interpret the accessibility tree. [Confirmed, Google Search Central] A site that confuses a screen reader usually confuses an agent too.

This skill audits whether agents can understand and complete the key tasks on a site, and prepares for the protocols that let agents transact directly.

## How agents meet your site
| Layer | What the agent uses | What helps |
|---|---|---|
| Visual | Screenshots of the rendered page | Clear layout, visible labels, no overlapping pop-ups |
| Structure | DOM and accessibility tree | Semantic HTML, labelled controls, logical headings, ARIA used correctly |
| Data | Text, tables, structured data, feeds | Facts in text, consistent prices, product and organisation data |
| Actions | Links, buttons, forms, checkout | Predictable flows, clear errors, no traps |
| Protocols | APIs and standards such as UCP, ACP and MCP | Machine interfaces for search, cart and checkout |

## Operating principles
1. **Accessibility is agent readiness.** Labelled inputs, real buttons and logical focus order serve people and agents.
2. **Tasks, not pages.** Audit the jobs that matter: compare plans, check availability, book, buy, contact, cancel.
3. **Facts in text.** Prices, specs, policies and availability belong in HTML text, not only in images or scripts.
4. **Friction where it protects, not everywhere.** Keep fraud controls, but avoid blanket challenges that stop legitimate, user-directed agents from browsing public pages.
5. **Watch the standards.** Agent protocols are young; adopt through your platform where possible rather than custom builds.

## When to use, and when not to
Use it for e-commerce, SaaS sign-up and pricing flows, booking and lead-generation sites, and any business where an assistant could complete the task for a buyer.

Don't use it for crawler policy (`ai-crawler-access`) or product feeds and AI shopping surfaces (`ai-commerce-product-visibility`), though they overlap.

## Inputs to ask for, in one message
1. The five to ten most valuable tasks on the site.
2. Key templates: pricing, product, booking, forms, checkout, account.
3. The platform (Shopify, WooCommerce, custom) and any bot protection.
4. Accessibility audits or known issues.
5. Whether you sell through feeds, marketplaces or agent checkout already.

## Workflow

### Step 1. List the tasks
For each, define start page, steps, success state and what an agent needs to know (price, availability, terms).

### Step 2. Run an accessibility pass
Check headings, landmarks, labels, button semantics, focus order, contrast and error messages with automated tools and a screen reader. Fix issues on task paths first.

### Step 3. Test with agents
Give one or two browser agents each task in plain words ("find the cheapest plan with SSO and start a trial"). Record where they fail: hidden prices, unlabeled fields, modal traps, ambiguous buttons, CAPTCHAs.

### Step 4. Make facts machine-clear
Put plan names, prices, limits and policies in consistent HTML text and tables; mirror them in structured data where it applies; keep them identical across pages and feeds.

### Step 5. Simplify flows
Fewer steps, clear labels ("Start free trial", not "Go"), inline errors, no forced account creation before showing prices, cookie banners that don't cover controls.

### Step 6. Review bot protection
Tune rules so public browsing by user-directed agents works while abusive automation is still blocked; protect sensitive actions with confirmation rather than blanket blocks.

### Step 7. Assess protocols
| Protocol | What it is | Status |
|---|---|---|
| Universal Commerce Protocol (UCP) | Open standard for agent commerce from discovery to checkout and post-purchase, announced by Google with Shopify, Etsy, Wayfair, Target, Walmart and others on 11 January 2026; REST, A2A and MCP bindings; merchants stay merchant of record | Live in Google's AI Mode and Gemini for eligible US merchants; expanding [Confirmed, Google] |
| Agentic Commerce Protocol (ACP) | OpenAI and Stripe standard powering checkout in ChatGPT, launched September 2025 | Live for participating merchants [Confirmed, OpenAI/Stripe] |
| Model Context Protocol (MCP) | Open protocol for connecting AI applications to tools and data | Widely adopted for tools; useful for exposing product, booking or support functions |

For most merchants, the practical route is through their commerce platform's integrations.

## Agent readiness checklist
- [ ] Key facts (price, plans, availability, policies) in HTML text
- [ ] Forms have visible labels and clear errors
- [ ] Buttons and links are real elements with descriptive text
- [ ] No pop-ups that block content without a clear close control
- [ ] Task flows work without forced sign-in before key information
- [ ] Bot rules allow public browsing by legitimate agents
- [ ] Structured data and feeds match the page
- [ ] Platform agent-commerce options reviewed (UCP, ACP)

## Worked example
A software company asked two browser agents to "find a plan with SSO for 50 users and book a demo". Both failed: plan limits were in images, the SSO add-on price appeared only in a tooltip, and the demo form's company-size field was an unlabeled custom dropdown. The team moved plan details into an HTML table, added the add-on price to the table, rebuilt the dropdown as a native select with a label and removed a newsletter pop-up on the pricing page. Both agents then completed the task; human conversion on the pricing page rose slightly as well.

## Output format
```
# Agent readiness review: <site>, <date>
## Tasks tested (agent, result, failure point)
## Accessibility findings on task paths
## Fact clarity issues (where facts are hidden or inconsistent)
## Flow and bot-protection changes
## Protocol assessment (UCP, ACP, MCP: relevant or not, route)
## Prioritised fixes with owners
```

## Task test script
Give each agent the same plain request and record the result:
```
Task: [plain request, e.g. find the cheapest plan with SSO for 50 users and start a trial]
Start URL: [homepage]
Agent: [name, version, date]
Result: completed / failed / partial
Steps taken: [list]
Failure point: [page, element, reason]
Time taken: [minutes]
```

## Edge cases and judgement calls
| Situation | What to do |
|---|---|
| Checkout requires human verification (3-D Secure, ID checks) | Keep it; agents should hand control back to the person |
| Prices depend on location or login | Show a clear default price and explain how it changes |
| Marketplace or reseller channels | Make sure product facts match across channels agents may use |
| Accessibility fixes conflict with design | Accessible patterns win on task paths; designers can style them |
| Agents abuse forms (spam) | Use rate limits and server-side validation rather than blocking all automation |

## Handoffs to related skills
- Product data and checkout protocols: `ai-commerce-product-visibility`
- Bot rules: `ai-crawler-access`
- Server-rendered facts: the Technical SEO `javascript-seo` skill
- Speed: the Technical SEO `core-web-vitals` skill
- Clear fact pages: `answer-ready-content`

## Quality bar: what an excellent review includes
- Real tasks tested with real agents, with failure points recorded.
- Accessibility fixes prioritised on task paths.
- Protocol claims labelled with status and source.
- Fixes that help people as much as agents.

## Common mistakes
- Treating agents as a future problem while customers already use them.
- Prices in images or behind interactions.
- Custom controls without labels or keyboard support.
- Blanket bot blocking that also stops user-directed agents.
- Building custom agent integrations the platform already provides.

## Questions to ask before you recommend changes
- Which tasks would a buyer delegate to an assistant?
- What does the platform already support for agent commerce?
- Where must friction stay for fraud or compliance?

## Self-check before you answer
- Did I test real tasks with real agents?
- Are accessibility fixes prioritised on task paths?
- Are protocol claims labelled with status and source?
- Do fixes help humans as much as agents?

## Official documentation
- Google: generative AI features in Search, site owner guide (agentic experiences): https://developers.google.com/search/docs/fundamentals/ai-optimization-guide
- Agent-friendly website best practices (web.dev): https://web.dev/articles/ai-agent-site-ux
- Universal Commerce Protocol: https://ucp.dev/
- Model Context Protocol: https://modelcontextprotocol.io/
- WCAG 2.2: https://www.w3.org/TR/WCAG22/

---
Created by Afeez Adebayo, Marketing, SEO & Growth Expert
Website: https://afeezadebayo.com
LinkedIn: https://www.linkedin.com/in/afeez-adebayo/
X: https://x.com/za_icon
Source: https://afeezadebayo.com/skills-md/marketing/aeo-geo/agent-readiness/

Licence: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). You may copy, share and adapt this skill, including for commercial use, as long as you credit Afeez Adebayo and link to the source URL above. Keep this notice in any copy or adapted version.

Workflow

Step 1. List the tasks

For each, define start page, steps, success state and what an agent needs to know (price, availability, terms).

Step 2. Run an accessibility pass

Check headings, landmarks, labels, button semantics, focus order, contrast and error messages with automated tools and a screen reader. Fix issues on task paths first.

Step 3. Test with agents

Give one or two browser agents each task in plain words ("find the cheapest plan with SSO and start a trial"). Record where they fail: hidden prices, unlabeled fields, modal traps, ambiguous buttons, CAPTCHAs.

Step 4. Make facts machine-clear

Put plan names, prices, limits and policies in consistent HTML text and tables; mirror them in structured data where it applies; keep them identical across pages and feeds.

Step 5. Simplify flows

Fewer steps, clear labels ("Start free trial", not "Go"), inline errors, no forced account creation before showing prices, cookie banners that don't cover controls.

Step 6. Review bot protection

Tune rules so public browsing by user-directed agents works while abusive automation is still blocked; protect sensitive actions with confirmation rather than blanket blocks.

Step 7. Assess protocols

ProtocolWhat it isStatus
Universal Commerce Protocol (UCP)Open standard for agent commerce from discovery to checkout and post-purchase, announced by Google with Shopify, Etsy, Wayfair, Target, Walmart and others on 11 January 2026; REST, A2A and MCP bindings; merchants stay merchant of recordLive in Google's AI Mode and Gemini for eligible US merchants; expanding [Confirmed, Google]
Agentic Commerce Protocol (ACP)OpenAI and Stripe standard powering checkout in ChatGPT, launched September 2025Live for participating merchants [Confirmed, OpenAI/Stripe]
Model Context Protocol (MCP)Open protocol for connecting AI applications to tools and dataWidely adopted for tools; useful for exposing product, booking or support functions

For most merchants, the practical route is through their commerce platform's integrations.

Agent readiness checklist

  • [ ] Key facts (price, plans, availability, policies) in HTML text
  • [ ] Forms have visible labels and clear errors
  • [ ] Buttons and links are real elements with descriptive text
  • [ ] No pop-ups that block content without a clear close control
  • [ ] Task flows work without forced sign-in before key information
  • [ ] Bot rules allow public browsing by legitimate agents
  • [ ] Structured data and feeds match the page
  • [ ] Platform agent-commerce options reviewed (UCP, ACP)

Worked example

A software company asked two browser agents to "find a plan with SSO for 50 users and book a demo". Both failed: plan limits were in images, the SSO add-on price appeared only in a tooltip, and the demo form's company-size field was an unlabeled custom dropdown. The team moved plan details into an HTML table, added the add-on price to the table, rebuilt the dropdown as a native select with a label and removed a newsletter pop-up on the pricing page. Both agents then completed the task; human conversion on the pricing page rose slightly as well.

Output format

# Agent readiness review: <site>, <date>
## Tasks tested (agent, result, failure point)
## Accessibility findings on task paths
## Fact clarity issues (where facts are hidden or inconsistent)
## Flow and bot-protection changes
## Protocol assessment (UCP, ACP, MCP: relevant or not, route)
## Prioritised fixes with owners

Task test script

Give each agent the same plain request and record the result:

Task: [plain request, e.g. find the cheapest plan with SSO for 50 users and start a trial]
Start URL: [homepage]
Agent: [name, version, date]
Result: completed / failed / partial
Steps taken: [list]
Failure point: [page, element, reason]
Time taken: [minutes]

Edge cases and judgement calls

SituationWhat to do
Checkout requires human verification (3-D Secure, ID checks)Keep it; agents should hand control back to the person
Prices depend on location or loginShow a clear default price and explain how it changes
Marketplace or reseller channelsMake sure product facts match across channels agents may use
Accessibility fixes conflict with designAccessible patterns win on task paths; designers can style them
Agents abuse forms (spam)Use rate limits and server-side validation rather than blocking all automation
  • Product data and checkout protocols: ai-commerce-product-visibility
  • Bot rules: ai-crawler-access
  • Server-rendered facts: the Technical SEO javascript-seo skill
  • Speed: the Technical SEO core-web-vitals skill
  • Clear fact pages: answer-ready-content

Quality bar: what an excellent review includes

  • Real tasks tested with real agents, with failure points recorded.
  • Accessibility fixes prioritised on task paths.
  • Protocol claims labelled with status and source.
  • Fixes that help people as much as agents.

Common mistakes

  • Treating agents as a future problem while customers already use them.
  • Prices in images or behind interactions.
  • Custom controls without labels or keyboard support.
  • Blanket bot blocking that also stops user-directed agents.
  • Building custom agent integrations the platform already provides.

Questions to ask before you recommend changes

  • Which tasks would a buyer delegate to an assistant?
  • What does the platform already support for agent commerce?
  • Where must friction stay for fraud or compliance?

Self-check before you answer

  • Did I test real tasks with real agents?
  • Are accessibility fixes prioritised on task paths?
  • Are protocol claims labelled with status and source?
  • Do fixes help humans as much as agents?

Official documentation

When to use this skill, and when not to

Use it for e-commerce, SaaS pricing and sign-up flows, booking and lead-generation sites, and any business where an assistant could finish the task for a buyer.

Google describes how browser agents work: they may analyse screenshots, inspect the DOM and interpret the accessibility tree. A site that confuses a screen reader usually confuses an agent too, which is why accessibility fixes come first. Protocols such as Google’s Universal Commerce Protocol and OpenAI and Stripe’s Agentic Commerce Protocol go further, letting agents check out without using the page at all.

Don’t use it for crawler policy (use AI Crawler Access) or product feeds (use AI Commerce).

Example prompts

  • “Can a browser agent find our SSO plan for 50 users and book a demo? Test it.”
  • “Audit our checkout for agent readiness and accessibility.”
  • “Which facts on our pricing page are hidden from agents?”
  • “Should we adopt UCP or ACP, or wait for our platform?”
  • “Our bot protection blocks everything. Tune it so legitimate agents can browse.”

Example output

The skill returns a fixed structure. A shortened example for an imaginary site:

# Agent readiness review: example.com, 10 October 2026

## Tasks tested
| Task | Agent | Result | Failure point |
| Find SSO plan for 50 users | Browser agent A | Failed | Plan limits shown as images |
| Book a demo | Browser agent B | Failed | Unlabelled company-size dropdown |
| Start free trial | Both | Passed | none |

## Fixes
1. Plan details into an HTML table, add-on prices included
2. Native select with label for company size
3. Remove newsletter pop-up on /pricing/

Every fix also helps people using screen readers, keyboards and slow connections, so agent readiness never costs human conversion.

What the agent needs from you

The skill asks for the five to ten most valuable tasks on the site, key templates (pricing, product, booking, forms, checkout, account), the platform and any bot protection, existing accessibility audits and whether you already sell through feeds, marketplaces or agent checkout.

Research behind this skill

FindingSourceLabel
Browser agents may analyse screenshots, the DOM and the accessibility treeGoogle Search Central, 2026Confirmed
UCP announced 11 January 2026 with Shopify, Etsy, Wayfair, Target and Walmart; REST, A2A and MCP bindingsGoogleConfirmed
ACP launched September 2025 by OpenAI and Stripe for ChatGPT checkoutOpenAI and StripeConfirmed
Accessible sites are easier for agents to useweb.dev agent-friendly site guidanceConsensus

How this skill hands off to related skills

Agent readiness connects to technical and commerce work. Product data and checkout protocols continue in AI Commerce, bot rules in AI Crawler Access, server-rendered facts in JavaScript SEO and Rendering, page speed in Core Web Vitals and markup consistency in Structured Data. Clear fact pages follow Answer-Ready Content.

How to run the Agent Readiness skill step by step

  1. Install the skill as agent-readiness/SKILL.md.
  2. List the five to ten most valuable tasks on the site, with start page and success state.
  3. Share key templates and the platform, plus any bot protection and accessibility audits.
  4. Run each task with one or two browser agents using the test script, and record failure points.
  5. Fix task paths first: labels, buttons, hidden facts, pop-ups and flows.
  6. Assess protocols such as UCP and ACP through your platform, then re-test.

Situations this skill handles

Agents fail on sites for practical reasons. The skill handles these situations:

SituationWhat the skill does
Plan details shown as imagesMoves them into HTML tables agents and people can read
Unlabelled custom dropdownsReplaces them with labelled, native controls
Pop-ups covering controlsRemoves or delays them on task paths
Prices behind sign-inShows a default price and explains how it changes
Blanket bot blockingAllows public browsing by user-directed agents and protects sensitive actions
Should we adopt UCP or ACP?Checks platform support before any custom build

What makes this skill different

Most agent readiness talk is about future protocols. This skill starts with today’s reality: browser agents already open sites, read the accessibility tree and try to complete tasks for people. It tests real tasks with real agents, fixes the failure points (usually accessibility and hidden facts), and only then looks at protocols.

Every fix also helps human visitors, particularly people using screen readers, keyboards or slow connections, so agent readiness never trades off against conversion.

Practical tips from real projects

  • Accessibility is agent readiness.
  • Keep facts in text, not images or tooltips.
  • Keep friction where it protects: payment checks and confirmations stay.
  • Use platform integrations for agent commerce before custom builds.

A worked example: a software company asked two browser agents to find a plan with SSO for 50 users and book a demo. Both failed: plan limits were in images, the SSO add-on price was in a tooltip and the company-size field was an unlabelled custom dropdown. Moving plan details into an HTML table, adding the add-on price, using a native labelled select and removing a pricing-page pop-up let both agents finish the task, and human conversion improved slightly too.

Google’s Universal Commerce Protocol and OpenAI and Stripe’s Agentic Commerce Protocol let assistants check out with merchants; for most businesses the practical route is the commerce platform’s own integration.

The test script keeps results comparable over time: the same plain request, start URL, agent name and version, date, result, steps taken, failure point and time taken. Re-running it after each release shows whether a change helped or broke a task path.

Frequently asked questions

How well AI agents can understand your site and complete tasks on it for people, such as comparing plans, booking or buying. It depends on clear facts, accessible markup, simple flows and sensible bot rules.

Browser agents look at screenshots, read the page structure and accessibility tree, and click, type and submit like a person. Some use APIs and protocols instead of the page.

Not the same, but closely linked. Labelled controls, real buttons and logical structure help screen readers and agents alike.

Open protocols for agent commerce. Google’s Universal Commerce Protocol covers discovery to post-purchase; OpenAI and Stripe’s Agentic Commerce Protocol powers checkout in ChatGPT. Most merchants adopt them through their commerce platform.

Block abuse, not people. User-directed agents browsing public pages represent customers. Protect sensitive actions with confirmation rather than blanket blocks.

Give one or two browser agents real tasks in plain words and record where they fail. Fix those points, then test again.

Changelog

  • 1.0.0, 10 October 2026: first release.

Use, adapt and share this skill under CC BY 4.0: credit Afeez Adebayo and link to this page.