Why AX is the New UX

We need to rethink how we approach AI enablement. So much focus is on the AI side, kind of reminds me of how we reacted to mobile or web as transformational technologies. For decades, we’ve focused on User Experience (UX) as the north star of application design---creating interfaces and interactions optimized for human cognition, preferences, and behaviors. However, we’re now entering a paradigm shift where AI agents are poised to becoming significant consumers of our digital services. AI needs a reasonably predictable and structured interface to truly be able to operate as an end user of our existing applications. Are most enterprises ready to enable AI on top of their existing application and data infrastructure? We still are working on digital transformation in many enterprise organizations. Data quality is still an issue, api management, api reuse, consistent domain models, legacy systems, tech debt and now we are going to add AI and hope for the best? Maybe that will work out, but I think if we are going to progress beyond the simple chat, document synthesis and analysis to employing agents like people we have a long way to go. We need to step back and think about treating this new potential kind of employee/user of our digital capabilities and this new delivery channel of agentic AI of business execution and create some discipline around designing and architecting for AI. We need to enable the AI agent “user experience”, we need AX.

The reason AX should be considered as its own discipline is because the way agents interact with our applications and data and processes is different than the traditional user. The consume data, interpret it, develop action plans call other agents, potentially route to humans. We barely handle workflow now in most applications and cots packages with business process automation and configuration being one of the most expensive and challenging exercises and we want to throw AI at the problem and wave a magic wand and make it easier? AI in 2024 was struggling to determine how many r’s there are in strawberry because of the way AI was prompted. Think about that for a second, the prompt structure matters. If the prompt structure matters and we want AI to successfully operate our existing applications, than the “prompt” (the data and the interface we feed AI agents) to take action needs to be well formed. The implications for our existing APIs and how we have enabled user experiences is huge. How do we consistently name, structure, label data and errors so that AI correctly understands, the “prompt” received back from our applications.

As we shift to AI-mediated interactions represents a fundamental change in how digital services will be consumed, comparable to the transformations brought by mobile-first design or the original transition from command-line to graphical user interfaces.

The Evolution from UX to DX to AX

We’ve witnessed this pattern of expanding design disciplines before. User Experience (UX) emerged in the early 1990s and transformed how we think about human interfaces---covering everything from visual design to workflows to how products “feel” for real users. Then, Developer Experience (DX) gained prominence in the 2010s, recognizing developers as equally important consumers of platforms and APIs.

Now, we’re entering the age of Agent Experience (AX), acknowledging AI agents as a distinct user group with their own needs and interaction patterns. This evolution reflects a broadening understanding of who (or what) consumes our digital services and how we need to design for these different consumers.

Business Impact and Market Context

The business case for why AX is compelling and urgent. Recent market research projects the market for agentic AI to reach $5.1 billion in 2025, with 99% of enterprise developers reportedly exploring or actively developing AI agents for their organizations. Companies that fail to optimize their systems for AI consumption risk becoming invisible in an ecosystem increasingly mediated by AI agents.

This isn’t merely a technical consideration---it’s a fundamental business strategy for maintaining relevance and competitive advantage in the emerging AI-mediated economy. Early adopters of AX principles will gain preferential positioning in this new ecosystem, just as early adopters of mobile-first design gained advantage during the smartphone revolution.

AX design recognizes that AI agents have fundamentally different needs than human users:

Processing Patterns: While humans excel at intuitive understanding and contextual interpretation, AI agents require explicit, structured data with clear semantic meaning.
Discovery Mechanisms: Humans discover functionality through visual cues and exploration; AI agents need machine-readable specifications and well-defined interconnections between resources.
Error Tolerance: Humans can adapt to inconsistent interfaces and recover from ambiguous errors; AI agents require consistent patterns and explicit error remediation paths.
Information Density: Humans often prefer simplified interfaces that reduce cognitive load; AI agents can process rich, detailed information efficiently when properly structured.

The stakes are high: as AI agents increasingly mediate between users and services---finding information, making reservations, comparing options, and executing transactions---systems designed with strong AX principles will gain preferential access to this new channel of engagement. Those that ignore AX may find themselves invisible to the AI layer that increasingly orchestrates our digital interactions.

To enable AI Agents we will need to ensure our applications are capable of supporting a new class of users which means we need to take a hard look at the changes we have to make in how we provide tools and context.

In thinking about the future of agents, I think we need to start with how we start designing for agents.

Design for Agents

When we started focusing on the concept of the Developer Experience we actually were building capabilities that in the future could be harnessed by Agents. The same structured programmatic interfaces used by developers to integrate applications, present data consistently to users provides some of the refined infrastructure needed for AI. I want to focus on the next steps to building a first class agent experience which in turn creates a better developer experience as well. These two focuses go together well. I will discuss various concepts of application architecture and design and highlight why they are critical to creating the best possible AX.

Backend for Frontend Microservice Pattern

The Backend for Frontend (BFF) pattern was originally designed to provide tailored backend services for specific frontend clients (web, mobile, etc.). When viewed through the lens of AX design, this pattern takes on new significance as an ideal architectural approach for AI agent consumption:

Granular, Purpose-Specific Endpoints

Unlike human users who navigate through complex interfaces with intuitive understanding, AI agents perform optimally when accessing clearly defined, purpose-specific endpoints. While UX design might consolidate multiple functions into a single interface for user convenience, AX design favors granular separation of concerns. BFF microservices allow us to create these purpose-built interfaces that align with how AI agents process and consume services.

Context Isolation and Focused Functionality

Each BFF microservice encapsulates a specific domain of functionality with clear context boundaries. This maps perfectly to how AI agents process information---by breaking complex systems into distinct components with well-defined responsibilities. While humans excel at maintaining context across blurry boundaries, AI agents benefit from explicit domain separation that BFF architectures provide.

Independent Scaling and Evolution

As certain AI agents gain popularity and increase their consumption of specific services, the microservice architecture allows for independent scaling of only the required components. This means resources can be allocated precisely where needed, rather than scaling an entire monolithic system.

Standardized Communication Patterns

Microservices typically communicate through standardized protocols (REST, GraphQL, gRPC), making it easier for AI agents to understand and predict how to interact with these services. The consistency in communication patterns reduces the complexity AI agents face when learning to navigate our systems.

Improved Error Handling and Resilience for AX

Error handling represents one of the most significant divergences between UX and AX design. Humans can interpret vague error messages and recover through intuition; AI agents cannot.

A cornerstone of effective AX design is implementing standardized error response formats across all services. These should include:

Human-readable messages for debugging purposes
Machine-readable error types that categorize the issue
Contextual details about what caused the error
Suggested remediation steps specifically for AI
Links to other APIs that may help with the remediation

When designing error responses for AI agents, consider that these agents learn from every interaction. A well-structured error response doesn’t just solve the immediate problem---it trains the AI to avoid similar issues in the future. Consider adding these elements to your error structures:

Error Classification Taxonomy: Implement a consistent hierarchical classification of errors that AI agents can use to build a “mental model” of your system’s failure modes.
Frequency Indicators: Where appropriate, indicate whether an error is transient (likely to resolve on retry) or persistent (requiring different handling).
Learning Resources: Links to machine-readable documentation specifically designed to help AI agents understand the domain concepts related to the error.
Example Corrections: For validation errors, provide example valid values when possible.

For example, a standard JSON error response might follow this pattern:

{

“error”: {

“code”: “RESOURCE_NOT_FOUND”,

“status”: 404,

“message”: “The requested resource could not be found”,

“details”: “User with ID ‘12345’ does not exist”,

“remediation”: {

“parameter”: {

“name”: “path”,

“location”: “path”,

“pathSegment”: “{id}”,

“providedValue”: 1,

“remediationSuggestion”: “please provide a valid user id”

“instructionsForAI”: “The requested User with id = 1 was not found in the system. Please verify that the id is correct or use the ‘list’ link to browse available users.”

“links”: {

“self”: {

“href”: “/user/1”,

“rel”: “self”,

“method”: “GET”

“list”: {

“href”: “/users”,

“rel”: “list”,

“method”: “GET”

}

This structured approach gives AI agents the concrete information they need to make intelligent decisions about how to proceed after encountering an error---something that profoundly differs from human error recovery, which often relies on general context and trial-and-error.

Event Driven Architecture

In UX design, users typically request information when they need it. In AX design, we need more proactive information delivery. Event-driven architectures allow AI agents to subscribe to specific events rather than continuously polling for changes, enabling more efficient and timely updates.

Event Sourcing for State Changes to Enable Context

Event sourcing takes this further by storing every state change as a discrete event object, creating a complete historical record of all actions and transformations.

For AI agents, this pattern offers several critical benefits:

Complete Contextual History: AI agents can understand not just the current state of a resource, but how it evolved over time. This historical context allows for more sophisticated reasoning about the system’s behavior and potential future states.
Temporal Querying: AI agents can “time travel” through the state of a system, examining it at different points in its history to identify patterns, anomalies, or causal relationships.
Intent Preservation: Events typically capture the intent behind a change, not just the change itself. This allows AI agents to understand why changes occurred, not just what changed.
Audit Capability: AI agents can review the complete sequence of events to ensure compliance with expected patterns or to identify potential issues in their own interaction with the system.
Replay and Simulation: AI agents can use the event stream to replay scenarios or simulate potential outcomes by applying hypothetical events to historical states.

When implementing event sourcing for AI consumption, consider these practical approaches:

Standardized Event Schemas: Define consistent event structures across your domain with common metadata fields and typed payloads.
Temporal API Access: Provide API endpoints that allow AI agents to query your event store by time ranges, event types, or entity identifiers.
Causality Chains: Include correlation and causation IDs in your events to allow AI agents to trace cause-and-effect relationships through your system.
Snapshot Access: While event sourcing stores the complete history, provide snapshot endpoints that give AI agents efficient access to the current state without processing all historical events.
Schema Evolution Strategy: As your events evolve over time, implement a versioning strategy that allows AI agents to understand both historical and current event formats.

Consider an e-commerce order process implemented with event sourcing:

OrderCreated(id: 12345, customer: 5678, items: […], timestamp: 2025-04-28T14:30:00Z)

PaymentAttempted(orderId: 12345, amount: 99.95, timestamp: 2025-04-28T14:32:15Z)

PaymentDeclined(orderId: 12345, reason: “INSUFFICIENT_FUNDS”, timestamp: 2025-04-28T14:32:18Z)

PaymentAttempted(orderId: 12345, amount: 99.95, timestamp: 2025-04-28T14:45:22Z)

PaymentSucceeded(orderId: 12345, transactionId: “tx_789012”, timestamp: 2025-04-28T14:45:25Z)

OrderFulfillmentInitiated(orderId: 12345, timestamp: 2025-04-28T15:00:00Z)

While a human user might only care about the current order status, an AI agent analyzing this event stream gains rich contextual understanding about the complete journey---including challenges encountered and how they were resolved. This level of contextual understanding creates a significantly richer AI experience that enables more sophisticated assistance capabilities.

API Gateway Pattern with AI-Specific Considerations

Enhanced API gateways that include AI-specific features such as rate limiting based on agent type, specialized authentication mechanisms for different AI capabilities, and transformation layers that can adapt response formats to be more consumable by different types of AI agents.

Domain Models As API

I’ll explain why exposing domain models rather than Data Transfer Objects (DTOs) is important for optimizing Agent Experience (AX).

Semantic Richness and Context

Domain models are significantly richer in semantic meaning compared to DTOs. They make it easier for consumers to trace from API elements to the corresponding domain model elements, enabling better understanding of the business domain. For AI agents, this semantic richness provides crucial context that helps them properly interpret and interact with your system.

When an AI agent encounters a domain model, it gains access to:

The full business meaning behind entities
The relationships between different domain concepts
The constraints and rules that govern these entities

Natural Language Understanding Alignment

Domain models are typically designed around business terminology that aligns closely with natural language understanding. This alignment is particularly important for AI agents that process and generate natural language.

For example, if your domain model has a “Patient” entity with relationships to “Appointments,” “Prescriptions,” and “MedicalHistory,” an AI agent can more intuitively understand these connections because they mirror how we discuss healthcare concepts in natural language.

Reduced Cognitive Load for AI Agents

DTOs often represent simplified or flattened versions of domain models optimized for specific data transfer scenarios. They’re designed to “carry data between processes in order to reduce the number of method calls”, but this simplification often comes at the cost of lost context.

When AI agents consume domain models directly, they don’t need to:

Reconstruct relationships between flattened data
Infer business rules that were stripped from the DTO
Translate between technical DTO naming conventions and domain terminology

Evolutionary Understanding

Domain models naturally evolve with the business domain they represent. They maintain important concepts like identity, which allows AI agents to understand that an entity can change properties while remaining “the same entity”. This evolutionary understanding is critical for AI agents to properly model how your system behaves over time.

Consistent Mental Model Formation

For AI agents to build accurate mental models of your system, consistency is key. Domain models provide a consistent representation of your business domain, unlike DTOs which might vary depending on the specific API endpoint or use case. This consistency helps AI agents form more accurate and reliable mental models of your system.

Discovery and Exploration

AI agents excel at discovering relationships and connections. Domain models with their rich interconnections provide a natural exploration environment that allows AI agents to discover capabilities and relationships that might not be explicitly documented.

Self-Documentation

Well-designed domain models are inherently self-documenting because they represent real-world concepts and relationships. This self-documentation reduces the need for extensive additional metadata and makes your API more intuitively understandable to AI agents.

By exposing domain models directly, you’re essentially providing AI agents with the same rich context and understanding that your internal systems use, allowing them to form more sophisticated and accurate models of your business domain.

OData: Enabling Semantic Understanding for AI Agents

OData (Open Data Protocol) combines the power of RESTful APIs with rich semantic metadata, creating an ideal foundation for AI consumption. By implementing OData, your services provide:

Standardized Query Language: AI agents can formulate complex queries using a consistent syntax across all your services, reducing the need for endpoint-specific knowledge.
Rich Type System: The OData type system allows AI agents to understand the precise structure and constraints of your data models.
Relationship Navigation: OData’s entity relationships enable AI agents to efficiently traverse complex data structures through navigation properties rather than making multiple disjointed API calls.
Metadata Discovery: The $metadata endpoint provides a machine-readable description of your entire data model, enabling AI agents to dynamically discover and adapt to your service capabilities.

For example, an AI agent can use OData capabilities to efficiently filter, sort, and select only the needed properties in a single request:

GET /users?$filter=department eq ‘Engineering’&$orderby=lastName&$select=firstName,lastName,email

This precision reduces unnecessary data transfer and processing compared to retrieving full records and post-processing them. For AI agents that may be operating with rate limits or optimizing for efficiency, these capabilities are particularly valuable.

Training AI Agents with Versioning Awareness

When designing systems for AI consumption, consider how version information contributes to agent training:

Version as Context: AI agents should be trained to consider API version as an essential part of the context for every interaction. This creates a more robust mental model that can handle version-specific behaviors.
Breaking Change Simulation: Design training scenarios that specifically exercise an AI agent’s ability to detect and adapt to breaking changes between versions. This builds resilience in the agent’s interaction patterns.
Multi-Version Compatibility: Train agents to maintain compatibility with multiple versions simultaneously, allowing them to serve users on different versions of your system.
Version-Specific Error Recovery: Ensure AI agents understand that error patterns and recovery strategies may differ between major versions, requiring version-specific error handling logic.

By implementing these enhanced versioning practices, your AX design creates an environment where AI agents can confidently consume your services, adapt to changes over time, and provide a seamless experience to end users even as underlying systems evolve.

Hypermedia Controls (HATEOAS)

Even more powerful is HATEOAS (Hypermedia as the Engine of Application State), which becomes exceptionally valuable in the context of AI agent consumption. Here’s why:

HATEOAS transforms static APIs into self-describing, discoverable systems by including hypermedia links in responses that tell consumers what actions they can take next. For AI agents, this brings several key benefits:

Dynamic Discovery: Instead of hardcoding endpoint URLs and relationships, AI agents can discover available actions at runtime, allowing them to navigate complex systems without prior knowledge of the entire API structure.
Resilience to Change: When API endpoints change location or structure, the hypermedia links update accordingly, allowing AI agents to continue functioning without needing to be reconfigured.
Context-Aware Interactions: Links provided in responses are contextually relevant to the current state, helping AI agents understand what actions make sense in the current context.
Reduced Dependency on Documentation: AI agents can learn API capabilities through exploration rather than requiring extensive pre-programming based on documentation.
State Machine Clarity: HATEOAS effectively exposes the underlying state machine of your application, making it easier for AI agents to model the system’s behavior.

A HATEOAS-enabled response might look like this:

{

“orderId”: “12345”,

“status”: “pending”,

“total”: 99.95,

“_links”: {

“self”: { “href”: “/orders/12345” },

“pay”: { “href”: “/orders/12345/payment”, “method”: “POST” },

“cancel”: { “href”: “/orders/12345/cancel”, “method”: “DELETE” },

“customer”: { “href”: “/customers/5678” }

}

This explicit presentation of available actions enables AI agents to navigate your system intelligently, adapting to changes without breaking and discovering new capabilities as they’re added.

Circuit Breakers and Bulkheads with AI Awareness

Enhanced resilience patterns that are specifically designed to handle the unique traffic patterns of AI agents. These include circuit breakers that can differentiate between human and AI traffic, and bulkheads that isolate critical system components from potential AI-driven traffic surges.

The Symbiotic Relationship: How AX Design Elevates Human UX

Building systems optimized for AI agents doesn’t just prepare your organization for the future of AI-mediated interactions---it can immediately enhance the user experience for your human customers. This seemingly counterintuitive relationship emerges from several key dynamics:

AI-Assisted User Interactions

When AI agents can effectively interact with your systems, they become powerful intermediaries that simplify complex tasks for humans. Consider these scenarios:

An AI assistant that fully understands your e-commerce API can help users find products with natural language queries like “Find me comfortable running shoes similar to what I bought last year, but in blue.”
A voice-based AI interacting with your event management system could handle complex booking flows: “Book me a table for four next Friday at around 7 PM at that Italian restaurant I liked downtown, and send everyone in my dinner group an invitation.”

These natural, conversational interactions are only possible when your underlying systems are designed with strong AX principles that allow AI agents to effectively understand and navigate your services.

Reduced Cognitive Load Through AI Mediation

Systems designed with robust AX reduce the cognitive burden on human users by allowing AI agents to:

Handle complex data collection and validation before submission, reducing human error rates
Pre-fill forms and applications based on context and history
Translate domain-specific terminology into plain language
Manage complex decision trees and workflows
Present only the most relevant options from large datasets

These capabilities shift cognitive processing from the human to the AI agent, creating a dramatically simplified UX layer that focuses on human goals rather than system requirements.

Consistency Through AI Translation

One of the greatest challenges in UX design is maintaining consistency across large organizations with multiple teams and products. AX-optimized systems enable AI layers that can:

Normalize inconsistent terminology across different services
Abstract away implementation differences between similar capabilities
Present unified interfaces that span multiple underlying systems
Apply user preferences consistently across disparate services

This creates a more cohesive experience for users even when the underlying systems evolve independently.

Proactive & Anticipatory Experiences

The event-driven architectures and rich context preservation that benefit AI agents also enable more proactive human experiences:

AIs that monitor event streams can notify users of relevant changes without polling
Agents with access to event history can identify patterns and make intelligent predictions
Systems that maintain rich contextual history enable personalized experiences without explicit configuration

The result is a UX that feels anticipatory rather than reactive---a system that seems to know what users need before they ask.

Accelerated Solution Development

When your systems support rich AX capabilities, your development teams can rapidly create new user-facing solutions by:

Assembling AI-driven experiences that leverage existing APIs rather than building custom UIs
Testing new capabilities with AI interfaces before investing in full UI development
Repurposing common patterns across different user touchpoints
Focusing development resources on unique value rather than standard interaction patterns

This creates an innovation multiplier effect---each investment in core capabilities becomes available to all AI-mediated experiences.

Error Recovery Enhancement

The robust error handling required for effective AX directly improves human user experiences through:

AI-mediated error recovery that handles common issues without user intervention
Translation of technical errors into actionable guidance for users
Contextual help that leverages the same resources provided to AI agents
Reduction in error rates through AI pre-validation

The detailed error information that helps AI agents navigate failures becomes a powerful resource for improving human user experiences as well.

AX will improve UX

Perhaps the most powerful aspect of the AX-UX relationship is the continuous feedback loop it creates. As systems are optimized for AI agents, those agents become more effective at serving humans. This improved human experience drives greater adoption, generating more interaction data that can be used to further optimize both the AI agents and the underlying systems.

This virtuous cycle means that investments in AX don’t just prepare for a future state---they create immediate UX benefits that compound over time. The data from AI agent interactions provides unprecedented visibility into user needs and system limitations, enabling a data-driven approach to experience improvement.

Optimizing user experience increasingly means optimizing for AX since users are employing agents to work on their behalf. Rather than competing priorities, AX and UX become aligned goals working together to create better overall experiences.

An Example: Healthcare System Transformation

Consider a healthcare appointment scheduling and patient management system that implements strong AX design principles:

Before AX optimization, a patient might navigate multiple complex interfaces to find available specialists, compare appointment times, review insurance coverage details, access medical records, and manage prescriptions---a process requiring dozens of decisions, form inputs, and considerable health literacy.

After AX optimization, this same system can be accessed by an AI agent that understands the patient’s medical history, coverage details, and preferences. The AI can handle complex queries about provider specialties, cross-reference availability with insurance networks, prioritize urgent care needs, coordinate with pharmacy systems, and manage appointment scheduling with minimal patient input---perhaps just a final confirmation.

The patient experience transforms from a complex, often frustrating series of technical interactions to a simple goal-oriented conversation: “I need to see a specialist for my back pain who accepts my insurance and has availability next week. Also, please check if my prescription needs renewal before then.”

This represents a fundamental elevation of the healthcare experience---not because the UX was directly redesigned, but because the system was optimized for effective AI consumption through strong AX design principles. The healthcare provider benefits as well, with reduced administrative burden, more complete patient information at the point of care, and better coordination across the care continuum.

By investing in AX design now, organizations create the foundation for these transformative user experiences while simultaneously positioning themselves for the AI-mediated future that’s rapidly emerging.

Implementation Considerations for AX-Optimized Architecture

When implementing architectural patterns to support AI experiences, several key considerations should guide your approach:

Documentation as a first-class asset: While UX might rely on intuitive design to reduce documentation needs, AX demands comprehensive, machine-readable documentation. Consider Domain Models, ODATA and OpenAPI specifications as primary artifacts rather than afterthoughts.
Predictable patterns over clever optimizations: UX often benefits from clever shortcuts and optimizations; AX benefits from consistency and predictability across your entire system. Predictable patterns make your services more learnable for AI agents.
Explicit over implicit: UX can leverage human intuition to fill in gaps; AX requires explicit specification of every detail. Make nothing implicit in your API designs for AI consumption.
Statelessness where possible: While UX often involves complex session state, AX benefits from stateless interactions that require less contextual overhead for AI agents to track.
Transparent rate limiting and usage policies: For human users, rate limits are often hidden until breached. For AI agents, make these constraints explicitly discoverable through headers and documentation.

Balance Between Control and Autonomy

When designing for AI agents, a key decision is determining how much autonomy to grant versus how much control to maintain:

Guided Pathways: For critical operations with significant business impact, implement more restrictive HATEOAS controls that guide AI agents through approved workflows.
Exploration Spaces: For discovery and information retrieval, create more open-ended interfaces that allow AI agents to creatively solve user problems.
Progressive Trust: Consider implementing trust levels that grant AI agents increasing autonomy as they demonstrate consistent compliance with your system’s rules and constraints.

The optimal balance will depend on your specific domain, regulatory requirements, and risk tolerance.

Specialized AI Agent Types

Different AI agents may have different capabilities and requirements. Your AX design should consider:

Capability Advertisement: Mechanisms for AI agents to declare their capabilities and preferences.
Adaptive Responses: Systems that can provide more or less guidance based on the agent’s declared capabilities.
Specialized Interfaces: Purpose-built endpoints optimized for specific agent types or use cases.

This approach acknowledges that the AI ecosystem will be diverse, with agents specializing in different domains and exhibiting varying levels of sophistication.

Testing and Validation for AX Design

An important aspect of AX design that deserves special attention is how to test and validate systems designed for AI consumption. Unlike testing for human users, where qualitative feedback and usability studies play a central role, testing for AI agents requires different approaches and metrics.

Automated AX Testing Framework

A comprehensive testing framework for AX should include these key components:

Capability Discovery Testing: Verify that AI agents can successfully discover and understand all available capabilities through metadata and documentation.
Intent Resolution Testing: Ensure that AI agents can correctly map natural language intents to specific API operations and resources.
Error Recovery Testing: Validate that AI agents can successfully interpret error messages and take appropriate remediation steps.
Context Preservation Testing: Test whether context is properly maintained across complex multi-step workflows.
Version Compatibility Testing: Verify that AI agents can adapt appropriately to different API versions and handle version transitions smoothly.
Performance Under Constraint Testing: Evaluate how AI agents perform when faced with rate limits, response size limitations, or other constraints.
Security Boundary Testing: Ensure that AI agents cannot exceed their authorized access or perform unauthorized operations.

Agent Personas for Testing

One effective approach is to develop a library of “agent personas” representing different types of AI agents with varying capabilities:

Basic Agents: Limited to simple queries and operations with minimal context awareness.
Intermediate Agents: Capable of maintaining context across operations and performing modestly complex workflows.
Advanced Agents: Highly capable agents that utilize the full range of system capabilities, maintain rich context, and handle complex error conditions.

By testing your systems against this spectrum of agent personas, you can ensure that your AX design works well for the full range of AI agents likely to interact with your system.

Synthetic Agent Testing

Creating synthetic AI agents specifically for testing purposes allows for systematic evaluation of your AX quality:

Capability Coverage: Generate test cases that exercise every capability and endpoint.
Error Injection: Deliberately introduce errors to validate error handling mechanisms.
Load Simulation: Simulate multiple agents operating simultaneously to evaluate performance and concurrency handling.
Mutation Testing: Systematically modify API inputs and parameters to discover edge cases and unexpected behaviors.

Progressive Rollouts and Observability for AI Agent Interactions

The probabilistic nature of AI agents introduces unique challenges that can’t be adequately addressed through testing alone. Unlike deterministic software systems where inputs reliably produce the same outputs, AI agents operate on probability distributions that can produce different outcomes from the same inputs. This fundamental characteristic requires a more sophisticated approach to deployment.

Measuring and Monitoring AI Agent Interactions

An effective AX strategy requires robust measurement and monitoring capabilities.

When designing monitoring systems for AI agent interactions, consider tracking these key metrics:

Consumption Patterns: Monitor which endpoints are most frequently accessed by agents versus human users, and how these patterns evolve over time.
Error Rates by Agent Type: Track error rates categorized by agent type or capability level to identify potential compatibility issues.
Latency and Performance: Measure response times specifically for agent-initiated requests, which may have different performance characteristics than human-initiated requests.
Capability Discovery: Track which capabilities are being discovered and utilized by agents compared to the full range of available functionality.
Version Adoption: Monitor how quickly AI agents adopt new API versions compared to human developers.
Business Impact: Correlate agent activity with business outcomes such as conversion rates, user satisfaction, or operational efficiency.

The data gathered from monitoring AI agent interactions creates powerful opportunities for improving both your AX and UX:

API Optimization: Identify which endpoints or functions could be optimized specifically for agent consumption based on usage patterns.
Documentation Gaps: Discover areas where agents consistently encounter difficulties, suggesting potential gaps in machine-readable documentation.
New Capability Opportunities: Uncover patterns in agent requests that might indicate opportunities for new capabilities or functions.
Deprecation Candidates: Identify rarely-used endpoints or features that could be candidates for deprecation.

By systematically collecting and analyzing this data, organizations can create a continuous improvement cycle that enhances the experience for both AI agents and, by extension, the humans they serve.

Feature Flags for Controlled AI Agent Adoption

Feature flags provide an essential mechanism for gradually introducing AI agent interactions with your systems. Progressive rollouts allow you to gradually release AI features to users, helping mitigate risk and gather valuable feedback before a full launch. This controlled approach is particularly crucial for AI-mediated interactions where behavior may be less predictable than traditional software components.

Key benefits of using feature flags for AI agent interactions include:

Controlled Exposure: Limit the percentage of traffic handled by AI agents, starting with as little as 1-5% and gradually increasing as confidence builds.
Segmented Rollouts: Direct specific types of interactions or specific user segments to AI agents first, such as internal users, opt-in beta testers, or low-risk transaction types.
A/B Comparisons: Run human-handled and AI-handled processes in parallel to directly compare outcomes and satisfaction metrics.
Rapid Remediation: Quickly disable AI agent access to problematic endpoints or functionality without disrupting the entire system.
Feedback Loops: Create tight feedback loops where AI agent performance directly informs further development and refinement.

Real-Time Monitoring and Observability

The successful deployment of AI agents requires robust monitoring frameworks that go beyond traditional application metrics:

Agent-Specific Metrics: Track AI-specific metrics such as:
- Confidence scores for AI decisions
- Fallback/escalation rates to human operators
- Completion rates for multi-step workflows
- Semantic drift between inputs and outputs
- Latency compared to traditional processing
Automatic Rollback Triggers: Define business KPIs that trigger automatic rollbacks if thresholds are exceeded, minimizing the blast radius of any negative impact due to problematic AI behaviors.
Conversation Analytics: For conversational AI agents, implement specialized analytics to track:
- Topic coherence across turns
- Sentiment progression
- Resolution rates for different query types
- Follow-up question frequency (potentially indicating confusion)
Differential Privacy Aggregation: Implement privacy-preserving aggregation methods to analyze sensitive user-agent interactions without compromising individual privacy.

The Competitive Advantage of AX Design

As AI agents increasingly mediate between users and digital services, the quality of your AI Experience design will become a critical competitive differentiator. Companies that create architectures optimized for AI consumption will gain preferential positioning in this new ecosystem, while those focused exclusively on human interfaces may find themselves invisible to the AI layer that orchestrates more and more of our digital interactions.

The transition to AX design represents both a technical evolution and a strategic necessity. As AI agents become the primary gateway through which users discover and interact with digital services, AX quality will directly impact:

Visibility: Services with poor AX will become increasingly invisible as AI mediators deprioritize them.
Integration Ease: Services with strong AX will be seamlessly incorporated into AI-driven workflows and recommendations.
Customer Acquisition: As users increasingly rely on AI assistants for discovery, AX will become a critical channel for customer acquisition.
Operational Efficiency: Organizations that effectively serve AI consumers will reduce their cost-to-serve through automation and self-service.
Competitive Positioning: Companies that design their platforms with agents in mind will enable better automation, improve efficiency, and enhance customer experiences, while those that don’t risk falling behind as AI-powered ecosystems reshape how information is discovered and processed.

The transition from UX to AX doesn’t require abandoning our existing design principles---rather, it means expanding our architectural thinking to accommodate a new class of consumers with different needs and capabilities. The organizations that recognize and embrace this shift early will be best positioned to thrive in the emerging AI-mediated digital economy.

Just as organizations that invested early in mobile-optimized experiences gained advantage during the smartphone revolution, those who invest now in AI-optimized experiences will lead in the agent revolution that’s already underway.

The winners in this transition will be those who recognize that AX isn’t just a technical consideration---it’s a fundamental business strategy for the AI-mediated economy.