A practitioner’s view on MuleSoft’s agentic layer: Model Context Protocol and Agent Fabric over a governed Anypoint Exchange, turning AI assistants and autonomous agents from plausible guessers into governed actors.
Ask an enterprise AI assistant a simple question: which API tracks an order, who owns it, and how do I get access? Without grounding, the assistant answers anyway. It reads whatever wiki pages made it into context, blends them with patterns from training, and produces something confident, plausible and frequently wrong. An autonomous agent raises the stakes further: it does not just misinform a developer, it acts, composing calls against endpoints it half understands with credentials it should not have.
The fashionable diagnosis is that the models need to get better. Field experience suggests the real blocker is simpler and closer to home: most enterprises cannot answer basic questions about their own estate in a machine-readable way. What APIs exist, what their contracts say, who owns them, how access is granted. Discovery has always been painful for people, and people compensate with tribal knowledge and hallway questions. Agents cannot. An agent is exactly as good as its map of the estate, and most enterprises do not have one.
This is the problem MuleSoft’s agentic layer solves, and it is why Anypoint Exchange matters more in the agent era than it ever did as a browsing destination. Exchange is a governed, API-first system of record. Put Model Context Protocol in front of it and every assistant, copilot and autonomous agent inherits the same grounded map. Add Agent Fabric and the agents themselves join the registry. And AI does not only consume the result: as the build behind this article shows, AI fast-tracks constructing the layer itself, collapsing a quarter of integration work into days.
Figure 1. Two futures for the same question. An agent without a map answers from stale sources and improvises access. On the agentic layer, the question hits an MCP endpoint over the governed Exchange catalog: the answer is the record, and every action stays inside policy.
The problem, restated for the agent era
The discovery gap predates AI. Engineers have always burned afternoons hunting for APIs, owners and documentation. What changed is the cost profile. A person who cannot find the right API loses time; an ungrounded agent loses the enterprise’s trust:
- An assistant answers integration questions from stale wiki pages, and sounds certain while doing it.
- An agent discovers endpoints by scraping, with no concept of lifecycle, deprecation or contract versions.
- There is no governed way for an agent to request access, so pilots either stall at read-only or route around policy.
- Every agent team builds its own private inventory of the estate, and the inventories disagree.
None of this is a model problem. It is a systems-of-record problem, and it is the one problem the integration platform already solved for itself. Exchange holds governed contracts, versions, owners and access workflows, all exposed through APIs. What the agent era adds is urgency: a reason to put that machine-readable truth in front of every AI surface the enterprise runs.
An agent is only as good as its map of the estate. The agentic layer is that map, governed and kept fresh automatically.
The agentic layer: MCP over governed truth
MuleSoft now ships Model Context Protocol support across the platform. The MuleSoft MCP Server exposes Anypoint capabilities to any MCP-speaking client, and the MCP Connector lets teams turn Mule applications into MCP servers, so existing integrations become tools an agent can call. Put an MCP endpoint over the governed catalog and discovery becomes conversational for every AI surface at once: a developer’s IDE copilot, a business user’s chat assistant, an autonomous agent inside a workflow.
The difference between this and letting an agent browse the wiki is the difference between a witness and a rumor. When the catalog answers through MCP, the response is the governed record: the contract as published, the owner as recorded, the lifecycle as declared, and a deep link into the governed workflow for anything transactional. Requesting access stops being an agent improvising with credentials and becomes the same API Manager contract flow people use, executed inside policy.
Figure 2. The agentic layer at work. Assistants and agents ask plain-language questions through an MCP endpoint over the catalog. Answers carry the governed record, and any action flows through the same contracts and access workflows people use.
Agent Fabric: the agents join the catalog
MuleSoft’s direction of travel compounds the value. Agent Fabric, the platform’s control plane for AI agents, MCP servers and APIs, treats agents as first-class catalog citizens. The Agent Registry discovers and registers agents, MCP servers and LLM assets in Anypoint Exchange, including agents built on external platforms. The Agent Broker routes requests across them. The Agent Visualizer maps who is calling what. And governance policies extend to agent-to-agent, MCP and LLM traffic, the same way API policies govern API traffic today.
Step back and the pattern is one integration architects already trust: a governed registry, policies at the point of interaction, and observability over the traffic. The same Exchange that is the system of record for the API estate becomes the system of record for the agent workforce acting on that estate. One catalog grounds the agents; the same catalog registers them.
What keeps the map true: pull, push, link
A grounded agent layer is only as credible as the catalog beneath it, which is why three unglamorous integration patterns carry the whole story. Pull: a scheduled, read-only entity provider calls the Exchange Experience API and projects every asset into whatever developer portal the enterprise runs, Backstage.io being the common choice, each entry carrying traceable annotations back to its Exchange asset, with zero hand-written YAML. A working implementation syncs on a fifteen-minute cycle against a freshness objective, with drift alarms paging the platform team when a sync fails.
Figure 3. Pattern 1: pull. A scheduled entity provider calls the Exchange Experience API (step 1) and upserts portal entities with traceable annotations (step 2); transactional actions deep-link back into Exchange and API Manager (step 3). The map stays true without anyone maintaining it by hand.
Push: the estate that never ran on Mule flows in through CI. The API Catalog CLI publishes OAS and AsyncAPI specifications into Exchange at build time, so a Java service or a Kafka stream gets a governed contract, a semantic version and a named owner, and the same pull sync carries it everywhere, indistinguishable from a Mule API. This is Universal API Management doing quiet, essential work for the agent era: the agent’s map covers the whole estate, not just the integration platform’s corner of it.
Figure 4. Pattern 2: push. CI runs the API Catalog CLI at build time (steps 1 and 2), publishing non-Mule specifications into Exchange where contracts, versions and policies are governed; the same pull sync carries them to every front door (step 3). The agent’s map covers the whole estate.
Link: every transactional action deep-links into the system that owns it, for people and agents alike. Contracts and access live in MuleSoft; discovery, ownership and documentation live in the portal; the sync is one-way, so there is nothing to drift and no dual master to argue about. One home per fact is precisely what makes the map safe to hand to an autonomous actor.
AI fast-tracks the build itself
There is a second AI story inside this architecture, and it changes the economics of starting. The working build behind this article, the Exchange entity provider, the portal integration, search, rendered contracts, a scorecard page and the MCP endpoint, was assembled in days rather than weeks, with an AI coding agent doing the scaffolding and the team steering architecture and tests. That build renders five specification shapes side by side, OAS, AsyncAPI, GraphQL, gRPC and even EDI, behind one search box, with a test suite over two hundred strong. The integration surface Exchange exposes is what made that speed possible; the AI coding agent is what made it cheap.
AI accelerates the catalog’s content, too. A crawler proposes entries for specifications it finds in repositories, AI suggests capability tags and likely owners, and people confirm with one click; anything unclaimed lands on a blind-spot report that quietly turns unknown unknowns into a to-do list. The loop is worth stating plainly: AI is not just the reason to build the agentic layer. It is how the layer gets built fast enough to matter.
What this delivers
Lead with the agent outcomes. Every AI surface in the enterprise answers estate questions from one governed record instead of its own private guesses. Agents act inside the same contracts, policies and access workflows as people, which is the difference between an agent pilot that security blocks and one it signs off. The map covers Mule and non-Mule alike and stays fresh by construction. And with Agent Fabric, the layer extends from grounding agents to registering and governing them, in the same Exchange that governs the APIs they call.
People are not left behind; they get the portal they always wanted as a side effect. The same governed catalog feeds a Backstage portal for platform engineering, Anypoint API Experience Hub for partner-facing developer experience, and one search across the estate with a named owner and a rendered contract on every entry. What the organization avoids is equally concrete: hand-maintained YAML, a second access workflow, a catalog that rots, and an AI program grounded on wikis.
Where this fits the roadmap
The sequencing is short because AI keeps it short. Stand up the pull provider first; with an AI coding agent on the scaffolding, the first governed, searchable map lands in days. Wire the deep links so every action stays authoritative. Drop the API Catalog CLI into CI templates so the non-Mule estate flows in through the same governed path. Then open the MCP endpoint to the assistants and agents that are arriving anyway, and let Agent Fabric register them in the same Exchange as the APIs they call. Map first; the agents are close behind.
An earlier post in this series, “Omni Gateway Beyond the Front Door,” argued that the gateway belongs in the middle of the application network, not just at the public edge. The agent era makes the same point one layer up, and makes it urgently. Exchange has always been the single place to publish, discover and reuse assets. In the agentic enterprise, that reading sharpens: one governed map in front of everything you run, for every human and every agent. That is what the agentic layer is for.
This post reflects field experience integrating Anypoint Exchange with a Backstage.io-based internal developer portal and an MCP discovery endpoint at enterprise scale. Product names and capabilities referenced, including the Exchange Experience API, the API Catalog CLI, Anypoint API Experience Hub, the MuleSoft MCP Server and Connector, and Agent Fabric (Agent Registry, Agent Broker, Agent Visualizer and agent governance policies), evolve quickly and vary by release and region; validate current specifics with the MuleSoft account team and product documentation.
Reference: Tariq Yaqub, “Omni Gateway Beyond the Front Door,” MuleSoft Blog, August 2026, https://blogs.mulesoft.com/news/omni-gateway-beyond-the-front-door/.
