From DX to AX: Why the Future of AI Depends on Agent Experience and Open Standards Like MCP

As we step deeper into the AI-powered era, two emerging concepts are rapidly reshaping how we think about software, systems, and user interaction: Agent Experience (AX) and the Model Context Protocol (MCP).

Just as UX (User Experience) and DX (Developer Experience) shaped the design and adoption of software over the last two decades, AX is poised to define the next wave of innovation—where humans are not the primary interface to digital systems.

Let’s unpack what AX and MCP mean, why they matter, and how open standards are unlocking a future where AI agents can truly act on our behalf with clarity, confidence, and control.

Introducing Agent Experience (AX): The New Frontier

In the past, we obsessed over how users interact with interfaces. Then came the developer era—where APIs, SDKs, and frameworks redefined how humans build systems. Now, as AI agents become increasingly autonomous, capable, and embedded into workflows, we must design for a new “user:” the AI agent.

Agent Experience (AX) refers to the holistic experience of an AI agent acting on behalf of a human user. It’s how companies can measure how easily that agent can:

• Understand and access relevant data
• Invoke the right tools or APIs
• Navigate permissions and trust boundaries
• Take actions reliably, securely, and transparently

Think of it this way: if UX is how a user experiences a product, and DX is how a developer builds within it, AX is how an AI functions inside the system as a user.

Just like you wouldn’t give a developer a broken IDE or a user a clunky UI, you can’t give an AI agent a fragmented, insecure, or inconsistent environment and expect great results. Yet that’s where many systems still are today.

Why AX Matters Now

Modern AI agents like Microsoft Copilot for enterprise need context, tools, and trust. For AX to be successful, AI systems must:

• Get the right context: Structured, up-to-date information like financial data, or customer records
• Access tools seamlessly: Invoke services, APIs, or functions without brittle or one-off integrations
• Act safely: Operate within secure boundaries and respect enterprise policies

This requires rethinking not just UX or DX, but how systems expose themselves to AI. That’s where MCP comes in.

Model Context Protocol (MCP): Like USB-C for AI Agents

The Model Context Protocol (MCP), introduced by Anthropic in late 2024, is rapidly becoming the USB-C of AI agent integration. It’s a simple but powerful open standard—built on top of JSON-RPC—that enables AI models to interact with tools, APIs, and data in a consistent, secure way.

MCP makes it possible for AI agents (like Claude, GPT, or others) to:

• Discover available functions (tools) dynamically
• Make structured calls with validation and predictable responses
• Handle authorization and trust in a transparent, auditable manner

Rather than building bespoke wrappers or plugins for every single integration, teams can now speak a common language between AI models and external systems.

This is a game-changer. By adopting MCP:

• Developers gain interoperability across LLMs and services
• Enterprises maintain control and consistency
• AI agents become more capable, reliable, and trustworthy

Just like OpenAPI brought clarity to RESTful services, MCP is bringing that same clarity to AI integrations—and it’s moving fast. It borrows many concepts from old protocols like CORBA or SOAP around discoverability and invocation, adapting them to be usable by Agents. Leading frameworks and LLMs are already supporting it, pointing toward a de facto standard for the next generation of intelligent systems.

MCP example courtesy of modelcontextprotocol.io

Open APIs + MCP = Empowered Agents

OpenAPI and MCP together create the foundation for rich Agent Experiences.

Here’s a practical analogy: GitHub Copilot is an AI agent trained with context from a codebase. It thrives because its context is rich, and its tool (the IDE) is tightly integrated.

Now imagine a business AI agent embedded within an enterprise platform. It needs:

• Financial or supply chain data
• Access to payment rails or inventory systems
• The ability to trigger workflows or ask for approvals

With OpenAPI providing standardized API definitions, and MCP acting as the secure bridge between models and those APIs, this agent can truly understand, act, and deliver value autonomously—without engineers wiring every connection manually.

For financial software providers, the focus should now shift to exposing meaningful tools—with clear definitions and well-defined semantics—so that agents can operate within the correct context. Behind the scenes, these tools might orchestrate multiple API calls to achieve a specific outcome, but from the agent’s perspective, they should appear as cohesive, high-level actions.

What truly matters is offering a rich, highly-granular set of tools that enables agents to execute complex tasks—such as initiating approvals, sending emails, posting to Slack, or interacting with any other business system—intelligently and securely.

Trust, Safety, and Governance: Built In

AX also isn’t just about functionality—it’s about safety. In enterprise settings, AI agents must be auditable, authorized, and compliant.

That’s why MCP is designed with security in mind. It supports:

• Permissioned access to functions
• Clear boundaries of agent capabilities
• Structured input/output for risk mitigation

In short: AI agents get just enough power, with just enough visibility, to be useful—without becoming unpredictable.

Looking Ahead

As AI becomes more autonomous and deeply embedded in software systems, we’re entering a new design paradigm. Agent Experience (AX) and Model Context Protocol (MCP) are the keystones of this shift.

Forward-looking teams are already exploring how to:

• Build AI-native platforms that optimize AX
• Embrace open standards like MCP for scale and simplicity
• Balance capability and control with secure, composable architectures

For MCP to gain broader corporate adoption beyond early tech adopters—like vibe coders using Claude or platforms like Cursor—it must evolve, particularly in areas like remote calls and security. We can do great demos today. However, in most cases, the MCP Server is running locally. This is not practical for corporate usage, where SaaS is the norm.

Another challenge is trust. Corporations will have to approve the usage of specific MCP Servers before agents use them to make sure they are not from malicious actors.

With growing momentum from industry leaders such as OpenAI, Microsoft, Google, Stripe, and Shopify, MCP is maturing rapidly, and we should see more and more companies offering MCP Servers.

The future of software isn’t just about users interacting with machines. It’s about machines interacting on behalf of users. And that future starts with great Agent Experience.