The insight: an agent-accessible web application supports the maximum number of these channels. A site that only works via screenshots is agent-hostile. A site with semantic HTML, structured data, and a documented API is agent-native. Most sites are somewhere in between — and don't know it.

Three Levels: A Framework for Agent Accessibility

Inspired by WCAG's A/AA/AAA tier structure, AAG defines three levels of agent accessibility. Each level builds on the previous. Each maps to a concrete set of requirements a development team can audit and implement.

Level A: Agent Parseable

The minimum bar. An agent can understand what's on the page.

• Semantic HTML for all interactive elements — , , , not
• Form inputs have associated elements
• Single

  with logical heading hierarchy

• Descriptive link text (not "click here")
• Error messages persist in the DOM (not toast-only)
• Loading states are detectable via aria-busy or data-loading

<!-- Agent-hostile: invisible to the accessibility tree -->
<div class="css-1a2b3c" onclick="handleSubmit()">
  <span class="css-4d5e6f">Submit</span>
</div>

<!-- Level A: parseable, semantic, labeled -->
<form aria-label="Create issue">
  <label for="title">Issue title</label>
  <input id="title" type="text" name="title" required />
  <label for="priority">Priority</label>
  <select id="priority" name="priority">
    <option value="high">High</option>
    <option value="medium">Medium</option>
  </select>
  <button type="submit">Create Issue</button>
</form>

Level AAA: Agent Native

The site treats agents as first-class users, not accommodated afterthoughts.

• Full API parity — everything visible in the UI is available programmatically
• llms.txt at the site root describing capabilities for agent discovery
• Event-driven state via data- attributes or webhooks/SSE
• Token-efficient pages with minimal DOM nesting
• Documented interaction patterns (agent-flows.json)
• Agent-specific rate limits (per-API-key, not per-IP)
• No anti-automation on legitimate use paths

Here's what Level AAA structured data looks like — the kind of response an agent-native service returns:

{
  "object": "payment_intent",
  "id": "pi_3abc123",
  "amount": 2000,
  "currency": "usd",
  "status": "succeeded",
  "created": "2026-03-10T12:00:00Z",
  "metadata": {
    "order_id": "order_456",
    "created_by": "agent:rhumb-deploy"
  },
  "idempotency_key": "order_456_payment_v1",
  "livemode": true
}

How AAG Maps to the AN Score

AAG isn't a separate standard from Rhumb's AN Score — it's the framework embedded within it. The AN Score evaluates services across three dimensions, and AAG levels map directly to each:

The key insight: a service can score 9/10 on WCAG and 4/10 on AAG. Conversely, a tool with no web UI at all — say, a pure CLI or API — can score 9/10 on AAG because agents are the intended users. WCAG compliance is necessary but not sufficient. If your customers are increasingly agents, you need to measure what agents actually need.

Implementation: From Agent-Hostile to Agent-Native

Here's the practical playbook. Three tiers of effort, each with concrete steps and approximate engineering cost.

Quick Wins: Level A → Level AA (1–2 Weeks)

These require no architectural changes. Just better HTML and headers.

1. Audit your interactive elements. Replace every
   with a . Replace every

   acting as a link with an . Run document.querySelectorAll('[onclick]') in your console — if it returns results, you have work to do.

1. Build an MCP server. If you have a REST API, wrapping it in an MCP server takes days, not weeks. Publish it to the MCP registry. Your service becomes directly invocable by Claude, GPT, and every MCP-compatible agent framework.

1. Create a CLI tool. Even a thin wrapper over your API dramatically improves agent ergonomics. Agents execute CLI commands more reliably than they navigate web UIs.

1. Implement per-key rate limiting. Stop rate-limiting by IP. Agent infrastructure often shares IPs. Per-API-key limits give paying agent customers the throughput they need without penalizing co-located services.

1. Add webhook support. Agents shouldn't poll your /status endpoint every 10 seconds. Push state changes to them. Stripe supports 200+ webhook event types. Start with 5: resource created, updated, deleted, failed, completed.

1. Publish an OpenAPI spec or GraphQL schema. Machine-readable API definitions let agents introspect your service at runtime. Linear's introspectable GraphQL schema is a major reason it scores 8.4.

Long-Term: Locking in Level AAA (4–8 Weeks)

These are strategic investments that compound over time.

1. Achieve full API parity. If a user can do it in the UI, an agent should be able to do it via API. Audit every web-only action and build API coverage.

1. Create llms.txt and agent-flows.json. Describe your service's capabilities and key workflows in machine-readable formats at your site root. These are the robots.txt of the agent era.

1. Design for composability. Agents chain 3–5 operations in sequence. If your API forces a separate authentication step between each call, or returns data in formats that require transformation before the next operation, you're creating friction that compounds across every workflow.

1. Build agent-specific audit trails. When an agent creates, modifies, or deletes resources, that provenance should be tracked. Stripe's metadata field (50 key-value pairs per object) is the gold standard — agents tag everything they create with created_by, workflow, and idempotency_ref.

The Future: AAG as Industry Standard

In two years, Agent Accessibility will be as expected as WCAG compliance.

This isn't a prediction based on hype. It's extrapolation from what we're already seeing. Enterprise procurement teams are starting to ask: can our agents use this tool? Development teams are evaluating SaaS not just on features and price, but on API completeness, rate limit transparency, and automation friendliness. The question isn't whether agent accessibility standards will emerge — it's who defines them.

Companies will display AAG compliance badges on their marketing sites. RFPs will include agent accessibility scores alongside uptime SLAs and SOC 2 certifications. "Agent-native" will become a product differentiator the way "mobile-first" was a decade ago. Platform reviews will include AN Scores alongside G2 ratings.

We built Rhumb because this future is obvious and nobody was measuring it. The AN Score embedded AAG reasoning from day one — evaluating services across execution autonomy, access readiness, and agent autonomy. By publishing this framework openly and scoring 55 services against it, we're not just ranking tools. We're defining what "good" looks like for the agent era.

The standard is here. The methodology is documented. The scores are public. The source is open.

What remains is adoption. And adoption follows the same pattern it did with WCAG: first the leaders build for it because it's right, then the market demands it because it's required, then everyone wonders why they didn't start sooner.

Start now. Your agents are already waiting.