AI is continuing to redefine the “rules of engagement” across our personal lives, society, and the economy. AI agents use in recent times has risen dramatically, acting as a bridge between humans and the digital world. They speak natural language like you are reading now on one side, and the language of systems and applications on the other. They’re getting stronger with their reasoning and planning abilities as well. AI agents represent a new super persona never witnessed before.
This innovation is redefining the way companies and industries operate and is accelerating the digitization of the global economy. The value creation and value exchange for each industry is becoming more digital, leading radical shifts in the way businesses operate – ultimately developing new markets and driving entirely new revenue streams.
We’re entering the world of agentic enterprises driven by agentic architecture optimized for the global digital economy. In short, we’re moving from digital to agentic transformation.
Against this backdrop arises a common question: What is the function of APIs within this agentic enterprise? To answer this question, we’ll examine the evolution and operation of APIs in an agent-driven architecture, tracing their progression from conventional web services to innovative protocols such as MCP and A2A, which empower agents to execute high-level goals across diverse domains.
API evolution: From SDKs to the reusable building blocks of the composable enterprise
- Early days (1970s–1990s): APIs were more like software development kits (SDKs). They were bundled with software libraries and were primarily used for invoking system-level operations with a focus on procedural programming
- Internet revolution (early 2000s): Emergence of web APIs. As the web matured, RPC and SOAP emerged
- RESTful revolution (mid 2000s-2010s): Powered by HTTP/JSON
- Modern era (2010s to present): While RESTful APIs are still relevant, API management, governance, security, and the developer experience are table stakes for all organizations. APIs are the standard for exposing and consuming digital capability
APIs and microservices: API-led connectivity fueling the composable architecture
Organizations needed to accelerate innovation and move away from rigid, monolithic systems to more flexible, distributed services. This drive led to the adoption of microservices architecture, and APIs were the key enabler, evolving alongside it. This era marked the rise and establishment of the tri-layered API-led connectivity (ALC) system (System, Process, and Experience APIs) as the fundamental future proof architecture of the composable enterprise.
Reusable digital building blocks formed the core of this idea, which could be rewired instead of recreated in response to a business need. It linked integration with universal API management.
ALC, pioneered by MuleSoft, became the de facto architectural paradigm for the composable enterprise driving true business agility. APIs enabled microservices and microservices amplified the importance and ubiquity of APIs, fundamentally reshaping modern software development and the creation of the composable enterprise.
Role of APIs in the agentic enterprise
The future of APIs is closely tied to the overall architecture of the AI enterprise and must be viewed within the context of related concepts: agent interactions, Model Context Protocol (MCP), Agent-to-Agent (A2A) protocol, and semantic routing.
The future of APIs in the agentic enterprise
We’ve entered the world of the agentic enterprise, where autonomous software agents handle tasks, make decisions, and collaborate with minimal human intervention. In this new era, APIs become the lifeblood connecting these agents to enterprise systems and to each other. Enterprise APIs are becoming more important, but they must be designed with machine consumption in mind.
How does work get done differently in the agentic enterprise?
- Agents understand intent in natural language from a human or another agent
- They reason and plan a solution
- As the complexity of the goal increases, they discover and orchestrate capabilities from multiple agents, within an enterprise domain, across domains and eventually into the external ecosystem
- These agents are typically powered by MCP servers that give them the ‘actionability’ by ultimately invoking APIs exposed as MCP tooling
Semantic routing is a core tenant of an agentic enterprise. It means that the agents are able to discover and navigate the skills (often exposed via agent cards) required to execute an entire business workflow just in natural language. LLMs allow them to reason and resources like APIs, workflows and events exposed through MCP tooling provides the deterministic execution of the solution.
Just as we use our vocabulary to create sentences, agents use the “digital vocabulary” of the enterprise to act on a plan. The scope of natural language extends beyond human communication to include machine communication. APIs enable agents to discover capabilities and enable the execution of orchestrated solutions
MCP: Abstracting APIs for AI agents
Model Context Protocol (MCP) is an emerging standard that serves as a translation layer between AI agents and external tools or data sources. Instead of custom-coding each agent to call each API, developers can expose APIs via an MCP server. MCP wraps traditional APIs and other interfaces in a uniform, natural language friendly layer.
When an API is exposed via an MCP server, the consumer (either an agent or a human prompt) can ask questions in natural language.The MCP layer parses the request and maps it to the underlying API call. In this way, an MCP server acts as a natural language adapter for the API.
How does this work in practice? Typically, the API’s OpenAPI spec or a predefined schema is registered with the MCP server. The agent, when needing to use that API, doesn’t directly construct an HTTP request from scratch. Instead, the agent queries the MCP interface and the MCP service translates it to the actual API call and returns the result. This reduces the complexity on the agent’s side. Any MCP-compliant agent can plug into any MCP-wrapped API without bespoke integration code.
Importantly, MCP is model-agnostic and vendor-agnostic. MCP does for tool integration what APIs did for system integration: it creates a standardized contract. Under the hood, it’s often implemented with JSON schemas, function definitions, or adapters that the LLM can interpret. With MCP, agents can consume APIs as easily as humans consume web services. They focus on what needs to be done and MCP handles how to call the API.
A2A: Enabling agent interaction
Agent-2-Agent (A2A) protocol provides a common language for agents to talk to each other, regardless of who built them or what underlying model they use. Whereas MCP focuses on connecting agents to tools/data, A2A focuses on connecting agents to other agents
With A2A, an agent can request help from another agent as easily as calling an API. In fact, from one agent’s perspective, another agent is an API – an intelligent service it can query. The protocol defines how agents advertise their capabilities and exchange messages. For discovery, agents publish an “agent card” (typically a JSON document over HTTP) describing their endpoint and skills.
For example, a finance agent’s card might list that it can perform budget approvals, generate invoices, and so on, along with how to invoke those actions. Other agents can fetch this card to understand how to interact. Once discovered, agents communicate using a task-oriented message exchange, often over HTTPS or a messaging substrate.
From intent to action: Agent actionability via APIs
In the agentic enterprise, APIs power agent actionability. A core strength of agentic AI is turning high-level goals or intents into concrete actions. APIs are the executors of those actions. APIs give the agent the ability to actually do things in the world – not just chat.
When a user gives an AI agent an objective, the agent must break that down and invoke the right APIs to fulfill the request. The sequence might involve: querying a database, composing a report, uploading it to a drive, and sending an email – each of which is an API call.
To support this, enterprise APIs must be designed with action granularity in mind. Instead of one giant API that does a multi-step process, it might be better to expose smaller, composable operations that an agent can mix and match. An order management agent might need separate APIs to search orders, update an order, notify a customer, etc. – allowing it to dynamically string them together as needed. In an agentic enterprise, APIs effectively represent the action space that agents can navigate.
Traditional vs. agentic enterprise API usage variance
In the traditional enterprise APIs are the primary integration contract between systems. But in the agentic enterprise they become the execution and actionability layer and are increasingly wrapped, exposed, and governed through MCP so agents can safely discover and invoke them.
To summarize the transformation, the following table contrasts the role of APIs in a traditional enterprise vs. an agentic enterprise:
| Aspect | Traditional enterprise APIs | Agentic enterprise APIs (with MCP) |
| Primary consumers | Human-fronted applications, backend services, scheduled integration jobs | Autonomous agents (LLM-driven) consuming APIs via MCP servers, often acting on behalf of users, roles, or business processes |
| Trigger for calls | Direct user actions (UI clicks, form submissions) or predefined schedules | High-level intents or goals, passed to agents. Agents iteratively invoke MCP-exposed APIs until the objective is met |
| Integration style | Static, pre-modeled integrations with fixed workflows and endpoints | Dynamic, goal-driven integration. Agents compose API calls at runtime using MCP-provided tool catalogs. Integrations are often ephemeral and task-scoped |
| Discovery and tooling | Developers manually discover APIs via portals and documentation | Agents discover capabilities programmatically through MCP tool manifests. Discovery is real-time, contextual, and machine-readable |
| Documentation and design | Human-oriented API documentation; ambiguity tolerated | APIs must be agent-readable. OpenAPI schemas, strong typing, and clear semantics are surfaced through MCP so agents can reason deterministically |
| Context handling | Context managed by applications and session state | MCP provides structured context to agents (who, what, constraints, history), allowing APIs to be called with richer situational awareness |
| Latency and execution pattern | Latency acceptable at human interaction speeds | APIs must support fast agent loops. MCP coordinates bursty, high-frequency calls and shields backend systems from agent over-iteration |
| Security and authorization | User-centric OAuth tokens tied to sessions or apps | Task-scoped, delegated credentials issued via MCP. Agents receive least-privilege, time-bound access to specific APIs and actions |
| Governance and guardrails | Governance is largely enforced through development practices and reviews | Governance becomes automated. MCP enforces policy, rate limits, data access rules, and auditability for autonomous agent behavior |
| Change management | Versioning impacts developers and release cycles | MCP abstracts API evolution from agents. Updated schemas and capabilities can be surfaced without retraining agents, reducing coupling |
| Inter-service interaction | Services orchestrate each other through programmed API calls | Agents orchestrate services and other agents. MCP enables agent-to-API and agent-to-agent coordination using standardized protocols (MCP/A2A) |
| Error handling and recovery | Errors handled by developers or surfaced to users | Agents interpret errors semantically via MCP metadata and can retry, adapt strategies, or escalate intelligently |
| Outcome Orientation | APIs deliver discrete operations. Outcomes require human guidance | Agents own outcomes end-to-end. APIs are invoked as needed, while MCP ensures the agent stays within enterprise boundaries |
| Enterprise operating model | APIs are products for developers | APIs become capabilities for agents, curated and governed through MCP as part of the enterprise’s digital labor platform |
In the agentic model, APIs shift from being just integration points to being autonomous agents’ “action vocabulary”. All the principles of good API design: consistency, clarity, performance, and security become even more critical when AI is in the driver’s seat.
Agentic enterprise architectural blueprint
The agentic enterprise relies on a layered architecture that leverages different types of agents and protocols:
API layer and backend systems
This foundational API layer is where the complexities of backend data silos and heterogeneous IT landscapes are resolved, i.e. multiple vendors, technologies, transport protocols, data formats, security schemas, and more.
Domain agent layer and system interaction (MCP)
One hallmark of an agentic enterprise is the presence of headless domain agents, AI-driven agents that autonomously operate specific business domains via APIs without needing a user interface.
The inherited complexity and data silos of an enterprise is resolved by relying on the basics of domain-driven design (DDD) through the lens of the domain agents. These agents act as the digital team members and know how work gets done in a specific domain and the digital assets that are critical to enable the domain. MCP servers powered by APIs provide the actionability for the agents. API and MCP governance ensures that agents remain within safe operational bounds.
Customer agent layer and agent interaction (A2A)
The traditional system of engagement and the channels is now augmented by customer agents as the new persona in the digital workforce. Think of them as the top-level agents responsible for understanding and servicing the needs of its stakeholder. As agents are asked to do more complex tasks no single agent will have all the expertise or permissions needed to accomplish it alone and will require multi-agent systems.
Agent Fabric
Agent Fabric is a framework that allows multiple agents to collaborate, coordinate and compete with one another. It provides the following key capabilities:
- Discover: Catalog, surface, and reuse agents and tools through a registry
- Orchestrate: Coordinate agent interactions that span across multiple domains
- Govern: Apply security and compliance policies to every agent interaction
- Observe: Gain real-time visibility across the complex interactions for operational rigor
In the example above, the fulfillment customer agent is responsible for end to end fulfillment. It might have to go to the product domain agent to find the product specs, then go to an inventory domain to check for inventory and then place an order and then initiate shipment and then accommodate for the loyalty, driving the business goal of increasing the lifetime value of the customer.
Leveraging APIs for future-proof evolution
An agentic enterprise is well-suited for driving digital agility and APIs provide the deterministic actionability to the multi-agent system. An agentic API strategy helps organizations harness the full power of their years of investment, giving them a significant headstart in the agentic enterprise of the future.
This isn’t just about connecting systems; it’s about building a composable enterprise where every capability – exposed via a clear, reliable API – becomes a reusable building block for your intelligent agents.
MuleSoft is the integration layer that makes this agentic future possible. Our API-led approach ensures that your data and services are discovered, governed, and easily consumed by your autonomous agents, turning complex workflows into seamless, automated value chains. Stop reacting to change and start building the future.
