# AX Framework > AX Framework is an open framework of principles, patterns, and evaluation methods for designing websites and applications that AI agents can understand, navigate, and act on reliably. AX Framework is a version 0.1 draft proposal, not a ratified standard. Pages label content as AX proposals, established standards, roadmap items, illustrative examples, or mock data. Machine-readable entry points: [capability manifest](https://axframework.com/ax.json), [pillars JSON](https://axframework.com/api/pillars), [principles JSON](https://axframework.com/api/principles), [patterns JSON](https://axframework.com/api/patterns), [docs index JSON](https://axframework.com/api/docs). ## Framework - [Framework overview](https://axframework.com/framework): definition, pillars, lifecycle, maturity model, evaluation method - [Discoverability](https://axframework.com/framework/discoverability): Can an agent discover what a product can do? - [Comprehension](https://axframework.com/framework/comprehension): Can an agent understand content, context, and constraints? - [Actionability](https://axframework.com/framework/actionability): Can an agent execute supported actions? - [Feedback & Observability](https://axframework.com/framework/feedback): Can an agent understand outcomes and state changes? - [Trust & Control](https://axframework.com/framework/trust): Can an agent operate within clear permissions and safety boundaries? - [Recovery & Resilience](https://axframework.com/framework/recovery): Can an agent handle errors, ambiguity, and interruptions? ## Principles - [Explicit Capabilities](https://axframework.com/principles/explicit-capabilities): A product should declare what an agent can do with it, in a machine-readable form, rather than leaving the agent to infer capabilities from the interface. - [Structured Context](https://axframework.com/principles/structured-context): Information an agent needs to make a decision should be available as typed, structured data with explicit units, relationships, and constraints. - [Predictable Actions](https://axframework.com/principles/predictable-actions): The same action with the same input in the same state should produce the same effect, and that effect should be documented before the action is taken. - [Transparent State](https://axframework.com/principles/transparent-state): An agent should be able to read the current state of anything it is working with, directly, rather than reconstructing it from a sequence of past actions. - [Clear Permissions](https://axframework.com/principles/clear-permissions): What an agent is allowed to do should be explicit, scoped to the task, visible to the person who delegated it, and revocable at any time. - [Verifiable Outcomes](https://axframework.com/principles/verifiable-outcomes): Every action should return evidence of what it did, and that evidence should be independently checkable later. - [Graceful Failure](https://axframework.com/principles/graceful-failure): When something goes wrong, the product should explain what happened, whether it is safe to retry, and what the agent can do next. - [Minimal Ambiguity](https://axframework.com/principles/minimal-ambiguity): Each term, action, and value should have one meaning. When a request could mean more than one thing, the product should ask rather than guess. - [Human Oversight](https://axframework.com/principles/human-oversight): People should be able to see what agents are doing on their behalf, approve consequential actions, and intervene at any point. - [Progressive Autonomy](https://axframework.com/principles/progressive-autonomy): The degree of independence granted to an agent should increase with demonstrated reliability and decrease with the stakes of the action. ## Patterns - [Capability Manifest](https://axframework.com/patterns/capability-manifest) (Discovery): Publish a single machine-readable document that lists what agents can do with your product. - [Action Discovery](https://axframework.com/patterns/action-discovery) (Discovery): Expose the actions available on a resource in its current state, alongside the resource itself. - [Resource Description](https://axframework.com/patterns/resource-description) (Discovery): Describe each important resource with typed fields, stable identifiers, and explicit units. - [Structured Actions](https://axframework.com/patterns/structured-actions) (Interaction): Define each action as a contract with a name, typed input, preconditions, effects, and result. - [Multi-step Workflows](https://axframework.com/patterns/multi-step-workflows) (Interaction): Model long tasks as named workflows with explicit steps, persistent state, and resumable progress. - [State Transitions](https://axframework.com/patterns/state-transitions) (Interaction): Publish the state machine for important resources so agents know which changes are legal. - [Permission Requests](https://axframework.com/patterns/permission-requests) (Trust): Let agents request exactly the scopes a task needs, and let people grant, inspect, and revoke them. - [Human Approval](https://axframework.com/patterns/human-approval) (Trust): Pause consequential actions until a person confirms, with a self-contained summary of what will happen. - [Sensitive Actions](https://axframework.com/patterns/sensitive-actions) (Trust): Label actions by risk so agents and policies can treat them differently before anything happens. - [Execution Status](https://axframework.com/patterns/execution-status) (Feedback): Give long-running actions a status resource that agents can poll or subscribe to. - [Action Receipts](https://axframework.com/patterns/action-receipts) (Feedback): Return a durable, verifiable record of every state-changing action. - [Error Reporting](https://axframework.com/patterns/error-reporting) (Feedback): Return errors with stable codes, precise causes, retry guidance, and suggested next actions. - [Retry Strategies](https://axframework.com/patterns/retry-strategies) (Recovery): Make retries safe with idempotency keys, and tell agents when and how to retry. - [Rollback](https://axframework.com/patterns/rollback) (Recovery): Provide compensating actions so completed steps can be undone when a later step fails. - [Context Restoration](https://axframework.com/patterns/context-restoration) (Recovery): Let an agent resume a task after interruption by restoring state from a durable identifier. ## Docs - [Introduction](https://axframework.com/docs): What AX Framework is, who it is for, and how the documentation is organized. - [Quick Start](https://axframework.com/docs/quick-start): Make an existing web product measurably more agent-ready in an afternoon. - [Core Concepts](https://axframework.com/docs/core-concepts): Capabilities, resources, actions, grants, receipts, and the agent interaction lifecycle. - [Agent Experience Layer](https://axframework.com/docs/agent-experience-layer): Where AX sits in your stack and how it relates to your UI, API, and business logic. - [Capability Discovery](https://axframework.com/docs/capability-discovery): Publishing what your product can do so agents can find it. - [Context and State](https://axframework.com/docs/context-and-state): Exposing structured context and readable state for agents. - [Actions and Workflows](https://axframework.com/docs/actions-and-workflows): Modelling single actions and multi-step tasks agents can execute reliably. - [Permissions and Trust](https://axframework.com/docs/permissions-and-trust): Delegated authority, scopes, approvals, and audit trails. - [Structured Metadata](https://axframework.com/docs/structured-metadata): Using schema.org, JSON-LD, and semantic HTML to make content machine-readable. - [Action Contracts](https://axframework.com/docs/action-contracts): Defining typed, documented actions shared by your UI, API, and agents. - [MCP Integration](https://axframework.com/docs/mcp-integration): Exposing AX capabilities through the Model Context Protocol. - [API Integration](https://axframework.com/docs/api-integration): Making existing REST and GraphQL APIs agent-ready. - [Error Handling](https://axframework.com/docs/error-handling): Error formats, retryability, and recovery suggestions. - [AX Readiness](https://axframework.com/docs/ax-readiness): How to assess a product against the six pillars. - [Testing Methodology](https://axframework.com/docs/testing-methodology): Task-based testing with real agents, and what to measure. - [Best Practices](https://axframework.com/docs/best-practices): A condensed checklist drawn from the principles and patterns. - [E-commerce](https://axframework.com/docs/examples/e-commerce): An agent-ready product catalog, cart, and checkout. - [Travel Booking](https://axframework.com/docs/examples/travel-booking): Search, holds, approvals, and rollback for multi-part bookings. - [SaaS Dashboard](https://axframework.com/docs/examples/saas-dashboard): Reports, settings, and long-running jobs in a B2B product. - [Customer Support](https://axframework.com/docs/examples/customer-support): Ticket creation, status, escalation, and handoff to humans. ## Optional - [Evaluation demo](https://axframework.com/evaluate): interactive sample report using mock data; no audits are performed - [About](https://axframework.com/about): purpose, vision, and how to contribute