The Agent Experience Framework
The web was designed for humans. Now design for agents.
AI agents are becoming a new class of digital users. AX Framework introduces the principles, patterns, and tools for building websites and applications that agents can understand, navigate, and interact with reliably.
User interface
Agent Experience layer
Capabilities
The agent learns what the product can do before it does anything.
agent → GET /ax.json
{
"capabilities": [
{ "name": "search_products", "risk": "read" },
{ "name": "add_to_cart", "risk": "low" },
{ "name": "place_order", "risk": "high",
"requiresApproval": true }
]
}A new user has arrived
Same product. A different kind of user.
For thirty years, digital products have been designed around one assumption: a person is on the other side of the screen. Agents break that assumption. They don't see layout, they don't remember your redesign, and they need to be sure before they act.
A strikethrough price means “on sale” to a person. An agent needs the original price, the current price, and the currency as data.
capabilities: search_products, add_to_cart, start_checkout, start_returnproduct: { sku: "TRAIL-RUNNER-42",
price: { amount: 129, was: 149, currency: "EUR" },
delivery: { minDays: 2, maxDays: 4, businessDays: true } }action: add_to_cart({ sku, quantity: 1..10 })
idempotent: true · risk: lowresult: { status: "completed", cart: "cart_8f2", version: 2 }policy: returns { windowDays: 30, excluded: ["final_sale"] }
approval: required above 100 EURWhat is Agent Experience?
A definition
Agent Experience (AX) is the practice of designing digital products and services so AI agents can discover capabilities, understand context, execute actions, recover from errors, and achieve goals reliably, safely, and efficiently.
AX complements what already exists
AX is not a new protocol and does not replace your interface, your API, or your accessibility work. It is a way of designing across them for a user that operates differently.
UX design
Already provides
Interfaces people can understand and use.
AX adds
The same intent, expressed for software acting on a person's behalf.
APIs
Already provides
Programmatic access designed for developers who read the docs first.
AX adds
Runtime discovery, risk labels, approvals, and receipts for agents that read nothing in advance.
Accessibility
Already provides
Semantic structure that assistive technology can interpret.
AX adds
Builds on that structure. Accessible products are already partway to agent-ready.
Web standards
Already provides
HTML, schema.org, OAuth, HTTP semantics, and protocols like MCP.
AX adds
A design discipline for using them together, around tasks and outcomes.
The AX Framework
Six pillars, one loop.
Every agent task follows the same arc: find out what is possible, understand it, act, and confirm the result. Trust bounds the whole loop. Recovery keeps it going when something breaks.
- 01DiscoverabilityCan an agent discover what a product can do?
- 02ComprehensionCan an agent understand content, context, and constraints?
- 03ActionabilityCan an agent execute supported actions?
- 04Feedback & ObservabilityCan an agent understand outcomes and state changes?
- 05Trust & ControlCan an agent operate within clear permissions and safety boundaries?
- 06Recovery & ResilienceCan an agent handle errors, ambiguity, and interruptions?
From UX to AX
Each era added a new way in.
Graphical interfaces made computers usable by people. APIs made products usable by other software. Conversational interfaces let people use language. Agentic experiences let software pursue goals on a person's behalf.
- 01
GUI
Graphical interfaces
People see, point, and click. Meaning lives in layout and convention.
- Primary user
- People
- Unit of design
- Screens, controls
- Contract
- Visual conventions
- 02
API
Programmatic interfaces
Developers read the docs once, then write code that calls the product directly.
- Primary user
- Developers' code
- Unit of design
- Endpoints, schemas
- Contract
- Documented interfaces
- 03
Conversational UI
Natural-language interfaces
People describe what they want. The product interprets intent and responds in kind.
- Primary user
- People, via language
- Unit of design
- Messages, intents
- Contract
- Language understanding
- 04Emerging
Agentic Experience
Agent experience layer
Software decides how to reach a goal on someone's behalf, at runtime, within limits.
- Primary user
- Agents acting for people
- Unit of design
- Capabilities, actions, receipts
- Contract
- Declared, verifiable contracts
Layers accumulate. They don't replace each other.
APIs did not remove the need for good interfaces, and conversational products still rely on APIs. AX is the same: an additional layer, built on the business logic you already have, that serves a new kind of user without degrading the experience for the existing ones.
See AX in action
One task. Two stores.
An agent is asked to buy a pair of running shoes. Step through the same task against a store designed only for people, and against one that provides an Agent Experience layer.
Task given to the agent
Buy trail running shoes, EU size 42, under €150, delivered by Friday.
01 Load homepage
02 Search the catalog
03 Read product details
04 Select size and add to cart
05 Proceed to checkout
06 Retry checkout
07 Report to the person
Simulated agent reasoning
Run the simulation, or step through it, to see how the same task plays out against a store built only for human eyes.
- Waiting to start…
Outcome
Complete the run to see the outcome.
- Requests
- —
- Guesses made
- —
- Errors recovered
- —
- Outcome verified
- —
Who is AX for?
A shared language for the people who build products.
Product Designers
Design interactions beyond the graphical interface.
Map user tasks to capabilities, decide where people stay in the loop, and write the language agents will relay to the people they serve.
Developers
Build agent-ready capabilities and interfaces.
Turn existing business logic into typed action contracts, publish a manifest, and expose it through your API or an MCP server.
Product Teams
Evaluate and improve how agents interact with products.
Assess readiness across six pillars, prioritize the gaps that block real tasks, and track progress with a shared vocabulary.
Open framework
Early, open, and meant to be challenged.
AX Framework is a version 0.1 draft. The pillars, principles, and patterns here are proposals, written to be tested against real products and revised. There is no standards body behind them and no ecosystem yet — that is what contribution is for.
Patterns
Document a recurring problem and a solution you have seen work in production.
Implementation examples
Show how a principle or pattern looks in a real stack, with code.
Research
Share findings from testing products with agents: what failed, what helped, how you measured it.
Proposals
Suggest changes to the pillars, principles, or vocabulary, with the reasoning behind them.