<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by vijay kumar on Medium]]></title>
        <description><![CDATA[Stories by vijay kumar on Medium]]></description>
        <link>https://medium.com/@vijaykumarstar111?source=rss-2af5420a9964------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Stories by vijay kumar on Medium</title>
            <link>https://medium.com/@vijaykumarstar111?source=rss-2af5420a9964------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 05:36:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vijaykumarstar111/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[MuleSoft Agent Fabric, Step by Step: How to Turn Scattered AI Agents into One Governed Agent…]]></title>
            <link>https://medium.com/another-integration-blog/mulesoft-agent-fabric-step-by-step-how-to-turn-scattered-ai-agents-into-one-governed-agent-d6638adacce9?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/d6638adacce9</guid>
            <category><![CDATA[anypoint-platform]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agent-fabric-mulesoft]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mulesoft]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 10:16:20 GMT</pubDate>
            <atom:updated>2026-11-06T16:54:03.904Z</atom:updated>
            <content:encoded><![CDATA[<h3>MuleSoft Agent Fabric, Step by Step: How to Turn Scattered AI Agents into One Governed Agent Network</h3><h3>Introduction: Vijay’s first week</h3><p>Let’s start with a story.</p><p>Vijay Kumar has just accepted an offer as a <strong>Senior Data Engineer</strong> and starts on Monday. The company is modern and has invested heavily in AI agents:</p><ul><li>HR uses a Workday-connected assistant to create employee records.</li><li>IT uses a ServiceNow agent to raise laptop and access tickets.</li><li>Security manages accounts and groups in Okta.</li><li>Procurement orders equipment through SAP.</li><li>The Employee Experience team built an Agentforce agent that sends welcome packs and books orientation.</li><li>A third-party background-check vendor brought its own agent, running on Amazon Bedrock.</li></ul><p>Every one of these agents works well on its own. And yet, here is what Vijay’s first week looked like:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*RCcXQ2L1b-sdLFW9fVA8cQ.png" /></figure><p>Vijay’s first week without vs. with Agent Fabric <em>Same company, same agents. The only difference is whether something connects and governs them.</em></p><ul><li>Monday 09:00: Vijay arrives. No laptop, no accounts, so Vijay waits at reception.</li><li>Monday 14:00: the manager sends five separate requests to five different agents and teams.</li><li>Tuesday: a well-meaning automation grants admin access to production data, without checking the role.</li><li>Wednesday: the laptop finally arrives, two days late.</li><li>Thursday: Security asks <em>“Who granted that access, and why?”</em> Nobody can answer.</li></ul><p>The problem was never the agents. It was that nothing connected, governed or observed them as a whole.</p><p>That is exactly the gap MuleSoft Agent Fabric fills. In this blog we’ll go step by step: what the problem is, what Agent Fabric is, how each part works, how they fit together, and how to adopt it. Vijay’s onboarding is the main example, and we’ll finish with real scenarios from retail, IT operations, manufacturing and insurance.</p><p>What you’ll learn:</p><ol><li>Why “agent sprawl” happens and why it’s dangerous</li><li>The vocabulary you need: agents, tools, MCP, A2A</li><li>What MuleSoft Agent Fabric is, and how it differs from Agentforce</li><li>The four pillars: Discover, Orchestrate, Govern, Observe</li><li>How a single request flows through the whole network</li><li>How to design for scale, and a practical roadmap to adopt it</li></ol><h3>Step 1: Understand the problem, agent sprawl</h3><p>What happened to Vijay has a name: agent sprawl.</p><p>It doesn’t come from bad decisions. It comes from many good ones made separately. Each team picks the AI platform closest to them (Salesforce, AWS, Google, Microsoft, ServiceNow or a SaaS vendor) and solves its own problem. A year later the company has dozens of agents and MCP servers, and nobody has the full picture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*UvnLM8qBZeBjM64eXxzjkA.png" /></figure><p>From agent sprawl to a governed agent network <em>Left: what most companies have today. Right: the same agents, connected through one control plane.</em></p><h3>The six symptoms</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pfVtaXcPOe_dFXOQViUuUw.png" /></figure><h3>Why it gets worse over time</h3><p>Every new agent adds new connections, credentials and data paths. With 5 agents you might keep track manually. With 50 you can’t. The risk doesn’t grow in a straight line, because every agent that can talk to every system multiplies the number of things that can go wrong.</p><blockquote><em>Key takeaway: You can’t fix agent sprawl by building a better agent. You fix it with one place that can see, connect and govern all of them.</em></blockquote><h3>Step 2: Learn the vocabulary, tools vs. teammates</h3><p>Before we look at Agent Fabric, here are the terms a beginner needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y9j-pK88XnRn8WYMrqwDsg.png" /></figure><h3>MCP vs. A2A, the most important distinction</h3><p>These two protocols are the “roads” of every agent network, and beginners often mix them up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*1XZjTvh7A7zAtuEXb2-ktg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W3kmsR8Jp6BuYpLgIsaWmA.png" /></figure><blockquote><em>Key takeaway: MCP is how agents use tools. A2A is how agents talk to each other. Agent Fabric governs both.</em></blockquote><h3>Step 3: Meet MuleSoft Agent Fabric</h3><p>MuleSoft Agent Fabric is the control plane for enterprise AI agents. It lets you discover, orchestrate, govern and observe agents, MCP servers and LLMs, whichever vendor built them and wherever they run.</p><p>It is part of the Anypoint Platform, so it builds on tools many integration teams already use: Exchange, Runtime Manager, API Manager and Anypoint Monitoring.</p><h3>An analogy: an airport control tower</h3><p>Picture a busy international airport:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7SQEbkzfdnQyW2ijk2DabA.png" /></figure><p>The airport doesn’t build aircraft. It lets many different aircraft operate safely together. That is precisely Agent Fabric’s job.</p><h3>Agentforce vs. Agent Fabric</h3><p>These two are often confused, so let’s settle it:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PjECKWdskVieiYeN2ujK2w.png" /></figure><p>Most enterprises need both. Agentforce builds excellent agents, and Agent Fabric makes sure they work safely alongside everyone else’s.</p><blockquote><em>Key takeaway: Agent Fabric doesn’t replace your agents. It’s the air traffic control that lets all of them work together safely.</em></blockquote><h3>Step 4: Learn the four pillars</h3><p>Agent Fabric rests on four pillars. Each one answers one question that agent sprawl leaves open.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*JXde96D3Gpv0MqcXG2C1RA.png" /></figure><p>The four pillars of Agent Fabric <em>Each pillar maps to concrete components on the Anypoint Platform.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BL0Y6-ZTQ8uK2yOFqvuXBA.png" /></figure><p>The next five steps go through each pillar in the order you would actually adopt them: first see what you have, then connect it, then coordinate it, then lock it down and watch it.</p><blockquote><em>Key takeaway: Remember the four verbs: Discover → Orchestrate → Govern → Observe.</em></blockquote><h3>Step 5: Discover, know what you already have</h3><p>Goal: get a complete, trustworthy inventory of every agent, MCP server and LLM in the company.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*SM-3mr59kY3_Bq6-tBctgQ.png" /></figure><p>How Agent Scanners fill the Agent Registry <em>Agents you build are published. Agents you didn’t know about are found. Both end up in one catalog.</em></p><h3>5.1 The Agent Registry</h3><p>The Agent Registry is a central catalog in Anypoint Exchange, the same place MuleSoft teams already publish APIs. Each agent, MCP server and LLM gets an entry recording:</p><ul><li>Type: A2A agent, MCP server or LLM</li><li>Purpose: what it does and which capabilities or tools it offers</li><li>Owner: the team accountable for it</li><li>Version: which version is live, managed with semantic versioning</li><li>Environment: where it runs (sandbox, production)</li><li>Data boundaries: what kind of data it touches, e.g. employee PII</li></ul><h3>5.2 Two ways in: publishing and scanning</h3><ol><li>Publishing. Agents and MCP servers you build yourself are published from Anypoint Code Builder, the same way you publish APIs today.</li><li>Scanning. Agent Scanners connect to your AI and cloud platforms and automatically discover the agents running there, on a schedule or on demand. Everything they find is synced into the registry.</li></ol><p>Scanner support started with Amazon Bedrock, Google Vertex AI and Microsoft Azure / Copilot, and through 2026 MuleSoft has added more platforms, such as Agentforce and Databricks. The Amazon AgentCore scanner can also discover MCP servers.</p><h3>5.3 What this means for Vijay</h3><p>When the Bedrock scanner runs, the background-check vendor’s agent appears in the registry, marked NEW. Its entry shows that it touches employee PII, runs in production and has no owner. Security assigns it to People Ops, reviews its data access and adds gateway policies before it ever touches Vijay’s data.</p><h3>5.4 Why discovery comes first</h3><ul><li>Reuse instead of rebuild: before building a new “get employee” tool, search the registry. Someone may have built one already.</li><li>Find risk early: shadow AI is found, not stumbled upon during an incident.</li><li>Clear ownership: every asset has an accountable team.</li></ul><blockquote><em>Key takeaway: Discovery gives value on day one. Just knowing what exists removes duplicated effort and hidden risk.</em></blockquote><h3>Step 6: Connect, make your systems agent-ready without rewriting them</h3><p>Goal: let agents use the systems you already have.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*2QeMFlnBTaimQ3w7aO8l6g.png" /></figure><p>Your most important capabilities already exist as APIs, Mule apps or agents. Agent Fabric gives you four building blocks to plug them into the network, without rebuilding them.</p><p>Which building block do I need? <em>Two building blocks for tools (MCP) and two for agents (A2A).</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tXYj54j9ooZMUHqLc43YMg.png" /></figure><h3>How to choose</h3><ul><li>Is it an existing API that already does the job? → MCP Bridge. Your API never knows an agent is calling it.</li><li>Do you need new logic, data transformation or orchestration? → MCP Connector in a Mule app.</li><li>Is it an agent from another platform that can’t join the network? → A2A Bridge.</li><li>Should a Mule integration take part as an agent? → A2A Connector.</li></ul><blockquote><em>Key takeaway: Bridge what already works. Build with a Connector only when you need new logic.</em></blockquote><h3>Step 7: Orchestrate, make agents work as a team</h3><p>Goal: turn one business request into a coordinated set of agent and tool calls.</p><h3>7.1 The Agent Broker</h3><p>The Agent Broker is an intelligent router. It receives a task, works out which agents and tools are needed, and coordinates them:</p><ul><li>it delegates to agents over A2A,</li><li>it calls tools over MCP,</li><li>it uses an LLM of your choice for the reasoning parts.</li></ul><p>For Vijay, the HR manager types one sentence into Microsoft Teams:</p><blockquote>“Onboard Vijay Kumar, Senior Data Engineer, starting Monday in Bengaluru.”</blockquote><p>The broker handles everything else.</p><h3>7.2 Guided determinism, the most important idea in this blog</h3><p>LLMs are probabilistic. Ask the same question twice and you may get two slightly different answers. That’s perfect for understanding a free-text sentence. It’s dangerous for anything that must happen exactly the same way every time, like granting access to production data.</p><p>Guided determinism means designing every workflow with two kinds of steps:</p><ul><li>Probabilistic steps. The LLM reasons: understanding a request, coordinating agents, writing a summary.</li><li>Deterministic steps. Fixed rules and fixed tool calls: creating records, checking a role, assigning access.</li></ul><p>A useful analogy is a GPS. The navigation suggests the best route (judgment), but once you’re on the road you follow fixed lanes, signals and traffic laws (rules).</p><h3>7.3 Agent Script and its node types</h3><p>Broker workflows are written in Agent Script, a graph-based language introduced in 2026 with Agent Network 2.0.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVSbz_fCRrP12qwbAhQs_g.png" /></figure><p>Here is Vijay’s onboarding as an Agent Script graph:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*j5pJHIn8BXUCJpK9Ui-jtg.png" /></figure><p>Guided determinism onboarding flow <em>Purple steps use the LLM. Blue steps are fixed rules. The orange step asks a human.</em></p><p>Look at what the LLM is allowed to do: read the manager’s sentence and coordinate the IT and welcome agents. Now look at what it is not allowed to do: decide whether a role is privileged, grant production access without approval, or improvise how accounts are created.</p><blockquote><em>The LLM decides how to do the work. Rules decide what is allowed.</em></blockquote><p>That one design choice would have prevented Vijay’s accidental admin access.</p><h3>7.4 What Agent Script looks like (simplified)</h3><p>Below is a simplified, illustrative sketch of the onboarding graph. It shows the shape of the language, not a copy-paste-ready file. Start from the template that Anypoint Code Builder generates, and check the Agent Script reference for exact syntax.</p><pre># Illustrative only. Real files are generated and validated by Anypoint Code Builder.<br>subagent understand-request:<br>  reasoning:<br>    instructions: -&gt; @request.payload.message.parts[0].text<br>  outputs:<br>    properties:<br>      employeeName: { type: &quot;string&quot; }<br>      role:         { type: &quot;string&quot; }<br>      startDate:    { type: &quot;string&quot; }<br> <br>executor create-worker:<br>  # deterministic: fixed tool, fixed inputs, no LLM<br>  action: @actions.workday-create-worker with name = @subagent.understand-request.output.employeeName<br> <br>router access-path:<br>  # the definition of &quot;privileged&quot; is a rule, not an opinion<br>  when @variables.privilegedRoles contains @subagent.understand-request.output.role -&gt; manager-approval<br>  otherwise -&gt; standard-access<br> <br>orchestrator welcome-and-equipment:<br>  reasoning:<br>    instructions: &quot;Raise the laptop ticket and send the welcome pack&quot;<br>    actions:<br>      laptop:  @actions.servicenow-it-agent<br>      welcome: @actions.employee-experience-agent</pre><p>Notice the patterns:</p><ul><li>... style slot filling (not shown here) lets the LLM fill a value. Fixed bindings like name = @subagent…output.employeeName mean the value comes from earlier steps, not from the LLM&#39;s imagination.</li><li>@variables, @request and @&lt;node&gt;.output let every step read workflow state.</li><li>Routers and executors never call the LLM, so they behave the same way every time.</li></ul><h3>7.5 Human-in-the-loop</h3><p>Some decisions should always involve a person. The broker can pause a workflow, ask a human (here, Vijay’s manager), and resume once they respond. While it waits, the conversation and approval state are kept in Object Store, so nothing is lost even if the wait is long. In Vijay’s case, nobody gets production access unless a named manager has explicitly approved it.</p><blockquote><em>Key takeaway: Let the LLM reason, let rules decide, and let humans approve what really matters.</em></blockquote><h3>Step 8: Govern, make every call safe, compliant and affordable</h3><p>Goal: make sure no agent, tool or LLM call bypasses your rules.</p><h3>8.1 Omni Gateway</h3><p>Omni Gateway is the new name for Flex Gateway. It is the single enforcement point in front of your agents, MCP servers, APIs and LLM traffic. Because it understands MCP and A2A as well as REST, every policy you know from API management now applies to agent traffic too.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*FEIXrHvEKYYfwgvuhCNUSQ.png" /></figure><p>Inside Omni Gateway <em>Six checks on every call, and what they mean for two calls to the same tool.</em></p><p>Every call goes through a pipeline of checks:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fFf9BF7B9Yr_RtXEUhlDAw.png" /></figure><h3>8.2 Ingress and egress, two gateways per network</h3><p>An agent network typically uses two gateways:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AewQDTC7-ECwNd-3RZhMHw.png" /></figure><p>For Vijay: the egress gateway lets only the Onboarding Broker call assign-okta-groups. When a marketing chatbot elsewhere in the company tries the same tool, it gets 403 Forbidden, and the attempt is logged and visible.</p><h3>8.3 Governance at scale</h3><ul><li>Governance strategies: define rules once and apply them across many services.</li><li>Policy bundles: consistent packages, e.g. PII detection + rate limiting + audit logging for every HR-related tool.</li><li>External vaults: keep secrets in AWS, Azure or HashiCorp vaults instead of in code.</li></ul><h3>8.4 LLM cost control</h3><p>Governance covers money as well as security:</p><ul><li>Model Proxy: one endpoint for multiple LLM providers, with routing (send simple tasks to cheaper models) and caching (don’t pay twice for the same prompt).</li><li>Budget management: caps token spend per day, week or month.</li><li>Model wallets: spend limits per caller, e.g. per team or per agent.</li></ul><p>No more LLM keys hard-coded in apps, and no more surprise invoices.</p><blockquote><em>Key takeaway: If a call doesn’t go through the gateway, it shouldn’t happen at all.</em></blockquote><h3>Step 9: Observe, see and explain everything</h3><p>Goal: be able to answer “what happened, and why?” for any request, in seconds.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*Ah8jHYSGI4A0ZgQbwS42Mg.png" /></figure><p>Observe: answering who gave Vijay production access <em>A conceptual view of the network map and step-by-step trace. This is an illustrative mock-up, not the exact product screen.</em></p><p>Agent Visualizer gives you:</p><ul><li>A live network map: every agent, MCP server and tool, and how they connect.</li><li>MCP server and tool insights: which tools are actually being used.</li><li>Search and filtering: by business group, environment and time period.</li><li>Request flows and metrics: together with Anypoint Monitoring, you can follow one request across every gateway, broker, agent and tool.</li></ul><h3>What this means for Vijay</h3><p>When Security asks <em>“Who gave Vijay production access, and why?”</em>, the answer comes from the trace, not from a week of emails:</p><ul><li>the request came from the manager in Teams,</li><li>the router flagged “Senior Data Engineer” as privileged,</li><li>manager R. Mehta approved at 10:42,</li><li>the Onboarding Broker called the Okta MCP tool, which assigned Data-Eng and Prod-Read.</li></ul><p>Notice something else: the human approval was the longest step, and it’s visible rather than hidden. Observability helps you improve processes, not just investigate incidents.</p><blockquote><em>Key takeaway: If you can’t trace it, you can’t trust it. Observability turns AI from a black box into an accountable system.</em></blockquote><h3>Step 10: See the whole picture, the runtime architecture</h3><p>Now let’s put all four pillars together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*BntBtQsTwS2pfvHeu6ubkA.png" /></figure><p>Employee onboarding agent network runtime architecture <em>Every call into and out of the broker passes through Omni Gateway, so policies and telemetry are always applied.</em></p><h3>The layers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mu774SALNx6zHq140aIaWw.png" /></figure><h3>The request, step by step</h3><p>The onboarding request sequence <em>Every red dot is a gateway check: authenticated, authorized, policy-checked and logged.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*V4z9S5A8Pe3AEsjI1VGkJw.png" /></figure><ol><li>The request arrives. The HR manager writes in Teams: <em>“Onboard Vijay Kumar, Senior Data Engineer, starting Monday in Bengaluru.”</em> The ingress gateway validates the token, applies rate limits and scans for sensitive data.</li><li>Understand. A subagent in the Onboarding Broker uses the LLM (through the Model Proxy) to extract name, role, start date and city.</li><li>Create the worker. An executor calls create-worker on Workday through MCP Bridge. Workday returns worker ID W-1024.</li><li>Check the role. A router checks the privileged-roles list. “Senior Data Engineer” is on it, so approval is needed.</li><li>Ask a human. The broker asks the manager: <em>“Approve production data access for Vijay Kumar?”</em></li><li>Approval. Manager R. Mehta clicks APPROVE. The broker kept the state in Object Store while it waited.</li><li>Accounts and access. An executor calls Okta to create the account and assign exactly the approved groups.</li><li>Laptop and VPN. The orchestrator asks the ServiceNow IT agent over A2A: <em>“Laptop and VPN by Monday.”</em> ServiceNow raises RITM0042, and the laptop is ordered through the SAP procurement tool.</li><li>Welcome. The orchestrator asks the Agentforce Employee Experience agent over A2A to send the welcome pack and book orientation.</li><li>Reply. An echo node sends the manager one message in Teams with the onboarding plan and all ticket numbers.</li><li>Observe. Every step is sent to Agent Visualizer and Anypoint Monitoring.</li></ol><p>The result: one sentence from the manager, a laptop on the desk on Monday, exactly the right access, and a complete audit trail. This time, Vijay’s first day goes well.</p><h3>The deployment model in one line</h3><blockquote><em>Build in Anypoint Code Builder → publish to Exchange (Agent Registry) → deploy the broker to CloudHub 2.0 (Runtime Fabric is supported from August 2026) → protect with Omni Gateway → observe with Agent Visualizer.</em></blockquote><p>If you’ve worked with MuleSoft before, this will feel familiar. Exchange already catalogs your APIs, and now it catalogs agents too. API Manager already governs your API traffic, and Omni Gateway extends that to agent traffic. You’re applying existing MuleSoft skills to a new kind of asset.</p><blockquote><em>Key takeaway: Every request follows the same shape: in through a gateway, reason and route in the broker, out through a gateway, and everything observed.</em></blockquote><h3>Step 11: Look inside an agent network project</h3><p>When you create an agent network in Anypoint Code Builder, a few files do most of the work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*GpLCct-1wo_V6nMnfM69gQ.png" /></figure><p>Inside an agent network project <em>You describe the network in a few files. The platform generates and deploys the plumbing.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*twoKSAap8O2e63lJzOWzBA.png" /></figure><h3>What happens when you publish</h3><ol><li>Publish: assets are published to Exchange and a Maven build starts.</li><li>Generate: using agent-network.yaml as a blueprint, the build generates the broker as a Mule application (an A2A server).</li><li>Deploy: the broker is deployed to CloudHub 2.0 or Runtime Fabric through Runtime Manager.</li><li>Protect: ingress and egress Omni Gateways apply your policies.</li><li>Observe: the network appears in Agent Visualizer.</li></ol><p>You describe what the network should do, and the platform generates the plumbing. Because it’s declarative, it’s also easier to review, version and audit than hand-written glue code.</p><blockquote><em>Key takeaway: An agent network is mostly configuration and a playbook, not a pile of custom code.</em></blockquote><h3>Step 12: Design for scale, a hierarchy of brokers</h3><p>Onboarding works. Next, HR wants hiring and offboarding too. The tempting option is to add everything to one broker. Don’t.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*DgSy8nkF9kHRgXp1dsLaZg.png" /></figure><p>Hierarchy of brokers <em>Each broker sees a small, focused set of agents and tools.</em></p><p>A broker that has to choose from 80 tools will choose badly. Too many options confuse the LLM (“option paralysis”) and fill its context window. Salesforce’s architecture guidance recommends:</p><ul><li>multi-level hierarchies of brokers instead of one flat broker,</li><li>roughly 20–25 tools per broker context at most,</li><li>splitting brokers by your org structure (Conway’s Law) or your business domains (Domain-Driven Design).</li></ul><p>In our example, a top-level Employee Lifecycle Broker routes to Hiring, Onboarding and Offboarding brokers, and each of those manages only its own small set of agents and tools. Offboarding then reuses the same Okta and ServiceNow assets, this time to revoke access and recover the laptop.</p><blockquote><em>Key takeaway: Many small, focused brokers beat one giant broker, for accuracy, cost and maintainability.</em></blockquote><h3>Step 13: Apply it to other industries</h3><p>Onboarding is just one example. The same pattern shows up wherever several vendors’ agents, existing systems and rules that must never bend come together.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*dfndJAdIm91egrkowZybQg.png" /></figure><p>Agent Fabric in four real-world scenarios <em>Different industries, same pattern.</em></p><h3>Retail: “Where is my order?”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*79uhPjq2pLZE-oOwxkxWbg.png" /></figure><h3>IT operations: “P1 incident at 2 a.m.”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TAnCXWNQ9Jf0hUD69vAkog.png" /></figure><h3>Manufacturing: “Supplier shipment delayed”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ysbalyF5uAuBXqd7cDvhEA.png" /></figure><h3>Insurance: “I had a car accident”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XvKjeC2DSWavkysqJm_Mdg.png" /></figure><blockquote><em>Key takeaway: If your process crosses more than one vendor’s agents and touches sensitive data or money, Agent Fabric is built for it.</em></blockquote><h3>Step 14: Follow a step-by-step adoption roadmap</h3><p>You don’t adopt Agent Fabric in one big bang. Start with visibility, add safety, then add coordination.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*roon0vP48jKyISGKylYv9g.png" /></figure><p>Agent Fabric adoption roadmap <em>Steps 1–4 give value even before you orchestrate anything.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PlF0UXBZRSh_3FDLQ73NGw.png" /></figure><p>A good first project has three properties: it’s painful today, it crosses two or three systems, and it has one clear rule that must never be broken. Employee onboarding fits all three.</p><blockquote><em>Key takeaway: See it, secure it, then scale it.</em></blockquote><h3>Step 15: Avoid the common mistakes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WG2G7nOHanF4GLishc1HyA.png" /></figure><h3>When you might NOT need Agent Fabric (yet)</h3><p>Honesty helps here. If you have one agent on one platform calling two or three tools, the platform’s own features may be enough for now. Agent Fabric pays off when you have multiple agents, multiple vendors, sensitive data or regulatory requirements, which describes most enterprises sooner than they expect.</p><h3>Step 16: Quick myth-buster</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nvlaPX0cboYI7A3NhBjOmQ.png" /></figure><h3>Glossary</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LViPeVLIWWNdHUsHhOaz2A.png" /></figure><h3>Conclusion</h3><p>AI agents are multiplying faster than most organizations can track. The answer isn’t fewer agents. It’s a control plane that makes many agents safe to run together.</p><p>MuleSoft Agent Fabric delivers that through four pillars:</p><ul><li>Discover: Agent Registry and Agent Scanners, so you know what you have</li><li>Orchestrate: Agent Broker and Agent Script, so agents work as one team</li><li>Govern: Omni Gateway, Model Proxy and budgets, so every call is secure and affordable</li><li>Observe: Agent Visualizer, so every decision can be explained</li></ul><p>At the center is guided determinism: let the LLM reason where judgment helps, keep fixed rules for everything that matters, and bring in a human when a real decision is needed.</p><p>Remember Vijay’s first week? With Agent Fabric, the manager wrote one sentence. The laptop arrived on time, Vijay got exactly the access the role needed, approved by a named manager, and Security could see the whole story in seconds.</p><blockquote><em>Don’t just build more agents. Build an agent network you can trust.</em></blockquote><p><em>If this guide helped you, share it with your team, and let me know in the comments how your organization is handling agent sprawl today.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*73EUftOF0v2BWHNiWZEDuQ.png" /></figure><h3>References</h3><ul><li><a href="https://docs.mulesoft.com/general/agent-fabric-overview">MuleSoft Agent Fabric Overview</a> (MuleSoft Documentation)</li><li><a href="https://docs.mulesoft.com/agent-network/latest/af-agent-networks">Agent Networks</a> (MuleSoft Documentation)</li><li><a href="https://docs.mulesoft.com/agent-network/latest/af-agent-script-reference">Agent Script Reference</a> (MuleSoft Documentation)</li><li><a href="https://docs.mulesoft.com/general/agent-fabric-release-notes">Agent Fabric Release Notes</a> (MuleSoft Documentation)</li><li><a href="https://architect.salesforce.com/fundamentals/mulesoft-agent-fabric-deep-dive">MuleSoft Agent Fabric Deep Dive</a> (Salesforce Architects)</li><li><a href="https://www.mulesoft.com/ai/agent-fabric">MuleSoft Agent Fabric product page</a></li><li><a href="https://www.salesforceben.com/salesforce-launches-mulesoft-agent-fabric-a-complete-breakdown/">Salesforce launches MuleSoft Agent Fabric: a complete breakdown</a> (Salesforce Ben)</li><li><a href="https://www.enterpriseaiworld.com/Articles/News/News/Salesforce-Enhances-MuleSoft-Agent-Fabric-with-Seamless-Automated-Discovery-173237.aspx">Salesforce enhances MuleSoft Agent Fabric with automated discovery</a> (Enterprise AI World)</li></ul><p><em>The company, people and ticket numbers in this blog are fictional examples.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d6638adacce9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/mulesoft-agent-fabric-step-by-step-how-to-turn-scattered-ai-agents-into-one-governed-agent-d6638adacce9">MuleSoft Agent Fabric, Step by Step: How to Turn Scattered AI Agents into One Governed Agent…</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI Needs a Brain, Hands, and a Front Door: Building a Salesforce Agent with MuleSoft Agent…]]></title>
            <link>https://medium.com/another-integration-blog/your-ai-needs-a-brain-hands-and-a-front-door-building-a-salesforce-agent-with-mulesoft-agent-490dc0b4f6b3?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/490dc0b4f6b3</guid>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 10:07:00 GMT</pubDate>
            <atom:updated>2026-11-06T16:54:31.934Z</atom:updated>
            <content:encoded><![CDATA[<h3>Your AI Needs a Brain, Hands, and a Front Door: Building a Salesforce Agent with MuleSoft Agent Fabric and Claude</h3><p><em>How I connected Salesforce, MuleSoft and Claude into a governed AI agent, explained without jargon (and with just enough technical detail to build it yourself).</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*21HLjw0JA9F1Y7wP5kYAHg.png" /></figure><h3>Why this post?</h3><p>Every company wants AI agents. Sales wants one that updates Salesforce. HR wants one that answers leave questions. IT wants one that resets passwords. Within months, a company can end up with dozens of agents built on different platforms, and nobody knows:</p><ul><li>which agents exist,</li><li>who is allowed to call them,</li><li>what they cost,</li><li>or whether they are safe with company data.</li></ul><p>This problem has a name: <strong>agent sprawl</strong>. MuleSoft’s answer to it is <strong>Agent Fabric</strong>.</p><p>In this post I walk through a real project end to end:</p><blockquote>A user asks in plain English, “Show me the Edge Communications account and its open deals”, and an AI agent answers using live Salesforce data, built with MuleSoft and Claude and governed by Agent Fabric.</blockquote><p>You don’t need to be an AI expert. I’ll explain every idea with an everyday comparison first, then show the technical part.</p><h3>Part 1: The big idea in one picture</h3><p>The easiest way to understand Agent Fabric is to think of a <strong>company’s front office</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3wsTrNBrxnk6X_0SzKCJ-A.png" /></figure><p><em>Every role in a front office maps to a real Agent Fabric component.</em></p><ul><li><strong>Visitor</strong>: Agent Fabric component: Users and apps (Teams, a website); What it does: Asks a question</li><li><strong>Security guard</strong>: Agent Fabric component: <strong>Gateway</strong>; What it does: Checks who is calling, blocks strangers, limits abuse</li><li><strong>Receptionist</strong>: Agent Fabric component: <strong>Broker</strong>; What it does: Sends each request to the right expert</li><li><strong>Expert</strong>: Agent Fabric component: <strong>AI agent</strong>; What it does: Understands the request and plans the work</li><li><strong>Hands and tools</strong>: Agent Fabric component: <strong>MCP server</strong>; What it does: Does exact jobs, like “find this account”</li><li><strong>Filing cabinet</strong>: Agent Fabric component: <strong>Salesforce</strong>; What it does: Where the real data lives</li><li><strong>Staff directory</strong>: Agent Fabric component: <strong>Registry</strong>; What it does: Lists every agent and what it can do</li><li><strong>Rulebook</strong>: Agent Fabric component: <strong>Policies and governance</strong>; What it does: Security, limits, privacy rules</li><li><strong>CCTV and dashboard</strong>: Agent Fabric component: <strong>Observability</strong>; What it does: Who called whom, how long it took, what it cost</li><li><strong>Recruiter</strong>: Agent Fabric component: <strong>Scanners (Providers)</strong>; What it does: Finds agents built on other platforms</li></ul><p>Keep this picture in mind. Everything else in this post is just filling in the details.</p><h3>Part 2: Five words you need to know</h3><p>Before building anything, let’s decode the vocabulary.</p><p><strong>1. LLM (Large Language Model).</strong> The “brain” that understands and writes language. In this project the brain is <strong>Claude</strong>, by Anthropic.</p><p><strong>2. AI agent.</strong> An LLM that can <em>take actions</em>, not just chat. It reads your request, decides what to do, uses tools, and gives you an answer.</p><p><strong>3. MCP (Model Context Protocol).</strong> A standard way for an agent to use <strong>tools</strong>. Think of it as a universal plug: any agent that speaks MCP can use any tool server that speaks MCP. An MCP call is precise: <em>“run </em><em>search_accounts with name = Edge&quot;</em>.</p><p><strong>4. A2A (Agent-to-Agent protocol).</strong> A standard way for <strong>agents to talk to other agents</strong>. Instead of exact tool calls, you send a goal in plain language: <em>“Fetch Edge Communications with its open deals.”</em> Every A2A agent publishes an <strong>Agent Card</strong>, a small JSON “business card” listing its name, skills and address.</p><p><strong>5. Agent Fabric.</strong> MuleSoft’s control layer that discovers, catalogs, connects, protects, governs and observes all your agents and tools.</p><h3>MCP vs A2A: the question everyone asks</h3><p><em>“If I already have MCP tools, why do I need A2A?”</em> The answer is <strong>who does the thinking</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U2w4fr3rfFZ8Q8kOJxEYxA.png" /></figure><p><em>With MCP alone, the caller must plan every step. With A2A, the agent plans for you.</em></p><ul><li><strong>MCP is the hands.</strong> It only does exactly what it’s told.</li><li><strong>An A2A agent is the expert who uses the hands.</strong> You give it a goal; it figures out the steps.</li></ul><p>If your caller is already an AI (like Claude Desktop, or the Agent Fabric broker), it can use MCP tools directly. If your caller is a simple app (a Teams bot, a website, another system), it needs an agent to do the thinking, and that’s where A2A comes in.</p><blockquote><strong>Rule of thumb:</strong> a smart A2A agent has an LLM inside it. A broker only needs its own LLM when it has to choose between several agents.</blockquote><h3>Part 3: What we’re building</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rt7RAmHPPLhUwUxRpMoZyw.png" /></figure><p><em>Users talk to Agent Fabric; Agent Fabric routes to the Salesforce agent; the agent uses MCP tools to reach Salesforce.</em></p><p>Four building blocks, from the bottom up:</p><ol><li><strong>Salesforce</strong>: the data (accounts, contacts, opportunities, cases, tasks).</li><li><strong>MCP server</strong> (a MuleSoft app on CloudHub): 13 Salesforce “tools” the agent can use.</li><li><strong>Claude agent</strong> (a Claude Managed Agent): the brain that decides which tools to call.</li><li><strong>A2A front door</strong> (another MuleSoft app on CloudHub): lets any A2A caller, including Agent Fabric, talk to the Claude agent.</li></ol><p>Then <strong>Agent Fabric</strong> sits on top to discover, register, protect and monitor everything.</p><p>Let’s build it step by step.</p><h3>Part 4: Step 1, the hands (an MCP server in MuleSoft)</h3><h3>What it is</h3><p>A MuleSoft application that exposes Salesforce operations as MCP tools. Each tool is one Mule flow.</p><h3>The 13 tools</h3><ul><li><strong>Accounts</strong>: search, get details (with contacts, open deals, open cases), create, update</li><li><strong>Contacts</strong>: search, get full details by name, create</li><li><strong>Opportunities</strong>: create, list (with total amount), update stage/amount/date</li><li><strong>Cases and tasks</strong>: create a case, create a follow-up task</li><li><strong>Reporting</strong>: run a read-only SOQL query (including counts)</li></ul><h3>How one tool looks</h3><p>Every tool follows the same simple pattern:</p><pre>MCP Tool Listener → log START → build query → Salesforce operation → shape JSON → log END</pre><p>The <strong>tool listener</strong> is where you describe the tool to the AI. The description and the input schema matter a lot, because that’s how Claude decides when and how to use the tool:</p><pre>&lt;mcp:tool-listener config-ref=&quot;MCP_Server_Config&quot; name=&quot;search_accounts&quot;&gt;<br>  &lt;mcp:description&gt;Find Salesforce Accounts whose name contains the given text.&lt;/mcp:description&gt;<br>  &lt;mcp:parameters-schema&gt;&lt;![CDATA[{<br>    &quot;type&quot;: &quot;object&quot;,<br>    &quot;properties&quot;: {<br>      &quot;name&quot;:  { &quot;type&quot;: &quot;string&quot;,  &quot;description&quot;: &quot;Part of the account name, e.g. &#39;Acme&#39;&quot; },<br>      &quot;limit&quot;: { &quot;type&quot;: &quot;integer&quot;, &quot;description&quot;: &quot;Max results (default 10)&quot; }<br>    },<br>    &quot;required&quot;: [&quot;name&quot;]<br>  }]]&gt;&lt;/mcp:parameters-schema&gt;<br>  ...<br>&lt;/mcp:tool-listener&gt;</pre><h3>Connecting to Salesforce safely</h3><p>The app uses the <strong>Salesforce Connector</strong> with <strong>OAuth 2.0 Client Credentials</strong> (an External Client App in Salesforce). Two important habits:</p><ul><li>The <strong>client secret is never stored in code</strong>. Locally it’s passed as a runtime argument; on CloudHub it’s a <strong>protected property</strong>.</li><li>The External Client App runs as a <strong>dedicated user with only the permissions the agent needs</strong>. The agent can only do what that user can do.</li></ul><h3>Logging you can actually use</h3><p>Every log line is one JSON object with the same shape, so you can follow a single request from start to end using its correlationId:</p><pre>{&quot;correlationId&quot;:&quot;8dc03c70-...&quot;,&quot;eventTimestamp&quot;:&quot;2026-10-09T13:51:08.215&quot;,<br> &quot;applicationName&quot;:&quot;salesforce-mcp-server&quot;,&quot;flowName&quot;:&quot;tool-search-accounts-flow&quot;,<br> &quot;stage&quot;:&quot;END&quot;,&quot;message&quot;:&quot;search_accounts completed&quot;,<br> &quot;details&quot;:{&quot;recordCount&quot;:1,&quot;durationMs&quot;:313}}</pre><p>A small DataWeave module builds it, so every flow logs the same way.</p><h3>Testing it</h3><p>Run the app, then open the free <strong>MCP Inspector</strong>:</p><pre>npx @modelcontextprotocol/inspector</pre><p>Connect to http://localhost:8081/mcp (Streamable HTTP), click <strong>List Tools</strong>, and call search_accounts with {&quot;name&quot;: &quot;Edge&quot;}. You should see real Salesforce data.</p><h3>Part 5: Step 2, the brain (a Claude Managed Agent)</h3><p>Now we give the hands a brain. A <strong>Claude Managed Agent</strong> is an agent that lives in your Claude (Anthropic) account. You configure it once, and Anthropic runs it for you.</p><p>In the Claude Console:</p><ol><li><strong>Environment:</strong> create one with <strong>“Allow MCP servers”</strong> turned on, so the agent can reach your MuleSoft app.</li><li><strong>Agent:</strong> give it</li><li>a <strong>model</strong> (e.g. a fast, low-cost model for simple CRM work),</li><li>a <strong>system prompt</strong>, which is its job description,</li><li>your <strong>MCP server URL</strong> (https://&lt;your-app&gt;.cloudhub.io/mcp),</li><li>and the tool permission policy <strong>“Always allow”</strong>.</li></ol><p>A good system prompt is short and practical:</p><pre>You are a Salesforce CRM assistant. Use the Salesforce tools to find, create and<br>update records.<br>- Never invent data. Only report what the tools return.<br>- If you only have a name, search first to get the record Id.<br>- If several records match, list them and ask which one before changing anything.<br>- Use full country names (United States, not USA). Dates must be YYYY-MM-DD.<br>- After creating or updating, confirm what you did and include the record Id.</pre><blockquote><strong>Gotcha:</strong> the default tool permission is “Always ask”, which pauses every tool call until a human approves it. For an automated agent, set it to “Always allow” (or “Auto”), otherwise every request appears to hang.</blockquote><h3>Part 6: Step 3, the front door (an A2A app in MuleSoft)</h3><p>The Claude agent speaks <strong>Anthropic’s API</strong>. Agent Fabric and other agents speak <strong>A2A</strong>. So we need a translator: a small MuleSoft app that</p><ol><li>publishes an <strong>Agent Card</strong> at /.well-known/agent-card.json,</li><li>accepts A2A <strong>message/send</strong> requests (JSON-RPC),</li><li>forwards them to the Claude agent,</li><li>waits for the answer, and returns it as an A2A <strong>Task</strong>.</li></ol><p>Here’s what happens during one request:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eDTHqVpilywU4MYn-EsMvg.png" /></figure><p><em>Ten steps, usually in 10–30 seconds. The purple steps are the agent using its MuleSoft tools.</em></p><p>In plain words:</p><ol><li>The caller sends a sentence.</li><li>The A2A app opens (or reuses) a <strong>conversation session</strong> with Claude. One A2A conversation (contextId) maps to one Claude session, so follow-up questions like <em>&quot;move </em><strong><em>that</em></strong><em> deal to Qualification&quot;</em> just work.</li><li>It sends the user’s message. 4–7. Claude calls the MCP tools as many times as it needs. Each tool queries Salesforce. 8–9. The A2A app checks the session until Claude has finished, then takes Claude’s final answer.</li><li>It returns an A2A Task with &quot;state&quot;: &quot;completed&quot; and the answer as an artifact.</li></ol><h3>What a request looks like</h3><pre>{<br>  &quot;jsonrpc&quot;: &quot;2.0&quot;,<br>  &quot;id&quot;: &quot;1&quot;,<br>  &quot;method&quot;: &quot;message/send&quot;,<br>  &quot;params&quot;: {<br>    &quot;message&quot;: {<br>      &quot;kind&quot;: &quot;message&quot;,<br>      &quot;role&quot;: &quot;user&quot;,<br>      &quot;messageId&quot;: &quot;msg-001&quot;,<br>      &quot;contextId&quot;: &quot;demo-conversation-1&quot;,<br>      &quot;parts&quot;: [{ &quot;kind&quot;: &quot;text&quot;, &quot;text&quot;: &quot;Fetch the Edge Communications account with its contacts and open deals&quot; }]<br>    }<br>  }<br>}</pre><h3>Built for real life, not just the happy path</h3><ul><li><strong>Missing or wrong bearer token</strong>: HTTP 401</li><li><strong>Not JSON / wrong method / empty text</strong>: The correct A2A JSON-RPC error code</li><li><strong>Agent paused for a tool approval</strong>: A failed task explaining how to fix it</li><li><strong>Agent took too long</strong>: A failed task: &quot;did not finish within the time limit&quot;</li><li><strong>Stored session no longer valid</strong>: Starts a new session automatically</li></ul><h3>Part 7: Step 4, deploy and test</h3><p>Both apps are deployed to <strong>CloudHub 2.0</strong> from Runtime Manager:</p><ul><li>env = dev (so the app listens on port 8081, which CloudHub expects),</li><li>secrets (Salesforce secret, Anthropic API key, inbound A2A key) as <strong>protected properties</strong>.</li></ul><p>Quick checks in a browser:</p><ul><li>https://&lt;a2a-app&gt;/health → UP</li><li>https://&lt;a2a-app&gt;/.well-known/agent-card.json → the agent&#39;s name, URL and six skills</li></ul><p>Then the real test with curl (or import it into Postman):</p><pre>curl --location &#39;https://&lt;a2a-app&gt;/&#39; \<br>--header &#39;Content-Type: application/json&#39; \<br>--header &#39;Authorization: Bearer &lt;your-inbound-key&gt;&#39; \<br>--data &#39;{ &quot;jsonrpc&quot;: &quot;2.0&quot;, &quot;id&quot;: &quot;1&quot;, &quot;method&quot;: &quot;message/send&quot;,<br>  &quot;params&quot;: { &quot;message&quot;: { &quot;kind&quot;: &quot;message&quot;, &quot;role&quot;: &quot;user&quot;, &quot;messageId&quot;: &quot;msg-001&quot;,<br>  &quot;contextId&quot;: &quot;demo-1&quot;, &quot;parts&quot;: [ { &quot;kind&quot;: &quot;text&quot;,<br>  &quot;text&quot;: &quot;Fetch the Edge Communications account with its contacts and open deals&quot; } ] } } }&#39;</pre><p>The answer that came back, in about 8 seconds:</p><pre>Edge Communications (Electronics, Austin, United States)<br>Contacts:  Rose Gonzalez (SVP, Procurement), Sean Forbes (CFO)<br>Open deal: Edge Emergency Generator, stage &quot;Id. Decision Makers&quot;, $35,000</pre><p>Then, in the <strong>same conversation</strong>:</p><blockquote>“Create a task to call Rose Gonzalez on 2026–10–20 about that deal.”</blockquote><p>The agent remembered which deal “that deal” was, created the task in Salesforce, and returned the new Task Id.</p><h3>Part 8: Step 5, bring it into Agent Fabric</h3><p>Now the fun part: making the agent visible and governable in MuleSoft.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jYRO8guBFD8VmhNvG0_FrQ.png" /></figure><p><em>Every Agent Fabric feature answers one practical question.</em></p><h3>1. Discover with a scanner</h3><p>In <strong>Providers</strong>, add an <strong>Anthropic</strong> scanner with an API key from the same Claude workspace, then click <strong>Run Discovery Scan</strong>. The Claude agent appears under <strong>Agents</strong> automatically: name, description, model and tools.</p><blockquote><strong>Gotcha:</strong> a scanned agent shows <strong>Protocol: OTHER</strong>. It’s a catalog entry pointing at the agent’s home platform, not something a broker can call over A2A.</blockquote><h3>2. Register the A2A version</h3><p>Go to <strong>Agents → Add Agent → Register Manually</strong>, choose <strong>Protocol: A2A</strong> and upload the <strong>Agent Card</strong> (agent-card.json). Now the registry has an entry the broker <em>can</em> call, with all six skills.</p><h3>3. Instances: managed vs unmanaged</h3><p>An <strong>agent</strong> is the definition (like a product in a catalog). An <strong>instance</strong> is a running copy at a URL (like a store that sells it).</p><ul><li><strong>Unmanaged target:</strong> just a record of the URL. Quick to add, no protection.</li><li><strong>Managed instance:</strong> the agent sits <strong>behind a gateway</strong>, which unlocks authentication, rate limits, PII masking, client tracking and dashboards.</li></ul><h3>4. The broker (when you have more than one agent)</h3><p>The broker is written in <strong>Agent Script</strong> (a .agent file) inside an <strong>Agent Network project</strong> in <strong>Anypoint Code Builder</strong>. With one agent, it can simply forward every request. Once you add an HR or Finance agent, you give the broker its own LLM (through a <strong>Model Proxy</strong>) so it can decide where each request goes:</p><pre>User: &quot;Fetch Edge Communications AND how many leave days do I have?&quot;<br>Broker → Salesforce agent (CRM part) + HR agent (leave part)</pre><p>The callers never change. You just add agents behind the broker.</p><h3>Part 9: Governance and security, end to end</h3><p>So far, each piece has its own protection. In a real company, that isn’t enough. A single question passes through <strong>seven hops</strong>: user → gateway → A2A front door → Claude agent → gateway → MCP server → Salesforce. If any one hop is weak, the whole chain is weak.</p><p>A simple way to check governance is to ask three questions at <strong>every</strong> hop:</p><ol><li><strong>Who are you?</strong> (authentication)</li><li><strong>What may you do?</strong> (policy and least privilege)</li><li><strong>What happened?</strong> (audit)</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ja9LutCOs90L1ih9tfSFKg.png" /></figure><h3>9.1 Policy enforcement at every hop</h3><ul><li><strong>User</strong>: Who are you?: Signs in with SSO (Entra ID / Okta) · What may you do?: Only apps IT has approved · What happened?: Who asked, from which app</li><li><strong>Omni Gateway (A2A)</strong>: Who are you?: Validates OAuth JWT or client ID + secret · What may you do?: Rate limit, PII masking, schema validation, client tracking · What happened?: Every call logged, visible in Agent Visualizer</li><li><strong>A2A front door</strong>: Who are you?: Checks the bearer token, reads the user claim · What may you do?: Input checks, timeout, one contextId = one Claude session · What happened?: JSON log with correlationId</li><li><strong>Claude agent</strong>: Who are you?: Anthropic API key in a protected property · What may you do?: System-prompt rules, tool permissions · What happened?: Session events for every tool call</li><li><strong>Omni Gateway (MCP)</strong>: Who are you?: MCP token kept in the Claude credential vault · What may you do?: Tool allow-list, rate limit per agent · What happened?: Tool-call log per calling agent</li><li><strong>MCP server</strong>: Who are you?: Accepts traffic from the gateway only · What may you do?: No delete tools, date and picklist checks · What happened?: JSON log with correlationId</li><li><strong>Salesforce</strong>: Who are you?: External Client App, client credentials · What may you do?: Run-as user with minimum permissions, sharing rules, field-level security · What happened?: Setup Audit Trail, field history</li></ul><p>The key insight: <strong>the gateway is where policy belongs.</strong> The bearer-token check I wrote inside the A2A app works, but it’s custom code. A gateway policy does the same job, is configured rather than coded, and is logged and visible in one place.</p><h3>9.2 Identity propagation: whose rights does Salesforce apply?</h3><p>This is the question most demos skip.</p><p><strong>Today (this POC):</strong> the MCP server connects with <strong>client credentials</strong>, so Salesforce sees <strong>one integration user</strong> for every request. This is safe, because that user has least privilege, but it has two side effects:</p><ul><li>every end user effectively has the <strong>same rights</strong> in Salesforce, and</li><li>Salesforce’s own audit shows the <strong>integration user</strong>, not the person who asked.</li></ul><p><strong>Production: carry the end user through the chain.</strong></p><ol><li>The <strong>gateway</strong> validates the user’s JWT from Teams or the web app.</li><li>The <strong>A2A front door</strong> passes the user’s identity, e.g. their email or user ID, as <strong>message metadata</strong> along with the request.</li><li>The <strong>MCP server</strong> exchanges that identity for a <strong>per-user Salesforce token</strong>, using the <strong>OAuth 2.0 Token Exchange</strong> or <strong>JWT Bearer</strong> flow. Both appear as options in the External Client App’s Flow Enablement settings.</li><li><strong>Salesforce</strong> now applies <strong>that user’s</strong> sharing rules and field-level security, and its audit shows the real person.</li></ol><p>If per-user tokens are too much for phase one, a middle ground is to keep the integration user but <strong>log the end user’s identity with the correlationId at every hop</strong>. You still get “who asked what” for audit, even though Salesforce enforces one set of rights.</p><h3>9.3 Least privilege, layer by layer</h3><ul><li><strong>Salesforce:</strong> the run-as user has a permission set with only the objects and fields the 13 tools need. There are no delete tools.</li><li><strong>MCP:</strong> only the tools this agent needs are exposed. A gateway allow-list stops other agents from calling them.</li><li><strong>Claude:</strong> read tools on “Always allow”, write tools on “Always ask” when a human should confirm (see Part 12).</li><li><strong>A2A:</strong> only registered, authenticated callers can use the front door.</li></ul><h3>9.4 Security checklist (don’t skip this)</h3><ul><li>✅ Every hop authenticates the previous hop. Nothing is “trusted because it’s internal”.</li><li>✅ Security policies live in <strong>Omni Gateway</strong>, not scattered through custom code.</li><li>✅ The Salesforce integration user has <strong>least privilege</strong>, with a path to <strong>per-user identity</strong>.</li><li>✅ Secrets live in <strong>protected properties</strong> and the <strong>Claude credential vault</strong>, never in code or chat.</li><li>✅ Keys are rotated if they were ever shared. Watch expiry dates.</li><li>✅ Rate limits and <strong>PII masking</strong> sit at the gateway.</li><li>✅ One <strong>correlationId</strong> in every log, so any answer can be traced back.</li><li>✅ <strong>No delete tools</strong> until you’re confident. This agent deliberately can’t delete records.</li></ul><h3>Part 10: Beyond one agent, multi-agent orchestration</h3><p>With one agent, the broker just forwards requests. The real value appears with <strong>several agents</strong>, and so do the real challenges: delegation, parallel work, context, retries and failures.</p><p>Take this question:</p><blockquote>“Show Edge Communications’ open deals AND how many leave days do I have?”</blockquote><p>One half is CRM, the other is HR. No single agent can answer both.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MMbq4_Fc9nHr9o1X5ihD9g.png" /></figure><h3>10.1 Delegation</h3><p>The broker has its own LLM (through the Model Proxy) and does four things:</p><ol><li><strong>Understand and split:</strong> the CRM part goes to the <strong>Salesforce agent</strong>, the leave part to the <strong>HR agent</strong>.</li><li><strong>Delegate over A2A:</strong> each part is sent as its own A2A task.</li><li><strong>Wait, retry or time out:</strong> each task has its own deadline and retry rule.</li><li><strong>Merge:</strong> one answer that says which part came from where.</li></ol><h3>10.2 Parallel execution</h3><p>The two tasks are <strong>independent</strong>, so the broker should start them <strong>at the same time</strong> rather than one after another. If the CRM agent takes 8 seconds and the HR agent 6, the user waits about <strong>8 seconds instead of 14</strong>.</p><p>Run tasks in parallel only when they don’t depend on each other. <em>“Find the account, then create a task for its main contact”</em> has to run in order.</p><h3>10.3 Context sharing</h3><ul><li><strong>One </strong><strong>contextId per conversation.</strong> The broker keeps it, and each agent maps it to its own session. In our A2A front door, one contextId maps to one Claude session.</li><li><strong>Share only what’s needed.</strong> Pass the user’s identity and the relevant record IDs, not the whole chat history. That’s less data exposure and fewer tokens.</li><li><strong>Never pass secrets as context.</strong> Credentials stay in vaults and gateways.</li></ul><h3>10.4 Context switching</h3><p>Conversations jump around:</p><ol><li><em>“Show Edge Communications’ open deals”</em> → Salesforce agent</li><li><em>“How many leave days do I have?”</em> → HR agent</li><li><em>“Move that deal to Qualification”</em> → back to the Salesforce agent</li></ol><p>At step 3, the broker routes back to the Salesforce agent <strong>with the same </strong><strong>contextId</strong>. The agent works out what &quot;that deal&quot; means from its own session memory. The HR detour doesn&#39;t break the CRM thread.</p><h3>10.5 Retries</h3><ul><li><strong>Reads (search, get details)</strong>: Retry?: Yes · How: Backoff, e.g. at most 2 retries, after 2s then 4s</li><li><strong>Writes (create task, update deal)</strong>: Retry?: Only safely · How: Use an <strong>idempotency key</strong>, e.g. the A2A messageId, so a retry doesn&#39;t create two tasks</li><li><strong>Validation errors (4xx, duplicate rule)</strong>: Retry?: No · How: Retrying won’t help. Explain the error instead, as our agent does with Salesforce duplicate rules</li><li><strong>Timeouts</strong>: Retry?: Once · How: Then fail clearly</li></ul><p>Also give each request an overall <strong>retry budget</strong>, so retries can’t multiply across agents.</p><h3>10.6 Failure handling</h3><ul><li><strong>Timeout:</strong> return an A2A task with state failed and a clear reason. Our front door already does this: <em>&quot;did not finish within the time limit&quot;</em>.</li><li><strong>One agent fails:</strong> return a <strong>partial answer</strong>, clearly labelled: <em>“Edge has one open deal worth $35,000. Your leave balance is unavailable right now, please try again later.”</em></li><li><strong>A write fails halfway:</strong> report exactly what was saved and what wasn’t, and <strong>flag it for a human</strong>. Never pretend it all worked.</li><li><strong>Repeated failures:</strong> use a <strong>circuit breaker</strong>, and the gateway <strong>kill switch</strong> if an agent misbehaves.</li></ul><h3>10.7 Adding agents without changing callers</h3><p>When a <strong>Finance agent</strong> arrives, you register it in Agent Fabric and add it to the broker’s options. Teams, the website and curl clients <strong>don’t change at all</strong>. That’s the payoff of putting a broker in the middle.</p><h3>Part 11: Discovery vs. invocation, and making protocols work together</h3><h3>11.1 Discovery is not invocation</h3><p>In Part 8 the same agent appeared <strong>twice</strong> in Agent Fabric. That’s not a mistake. They’re two different things:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vLWml5g4DNyRiJMBmp8uew.png" /></figure><ul><li><strong>How it got there</strong>: <strong>Discovered entry</strong>: Anthropic <strong>scanner</strong> in Providers · <strong>Registered A2A agent</strong>: <strong>Register Manually</strong> with the Agent Card</li><li><strong>Protocol</strong>: <strong>Discovered entry</strong>: <strong>OTHER</strong> · <strong>Registered A2A agent</strong>: <strong>A2A</strong></li><li><strong>What it tells you</strong>: <strong>Discovered entry</strong>: That the agent exists: name, model, tools, owner · <strong>Registered A2A agent</strong>: How to call it: URL, skills, auth</li><li><strong>Can the broker call it?</strong>: <strong>Discovered entry</strong>: <strong>No.</strong> It points at the agent’s home platform · <strong>Registered A2A agent</strong>: <strong>Yes</strong>, through an instance</li><li><strong>Use it for</strong>: <strong>Discovered entry</strong>: Inventory, shadow-AI detection, ownership · <strong>Registered A2A agent</strong>: Runtime routing and governance</li></ul><p>To be <strong>invocable</strong>, an agent needs three things:</p><ol><li>An <strong>Agent Card</strong> at /.well-known/agent-card.json, describing its name, URL, skills and auth.</li><li>A <strong>registered A2A agent</strong> in the registry, created from that card.</li><li>An <strong>instance</strong>. A <strong>managed</strong> instance sits behind Omni Gateway, so policies apply. An <strong>unmanaged</strong> instance is just a URL.</li></ol><h3>11.2 Two examples of protocol bridging from this project</h3><p><strong>Example 1: a non-A2A agent becomes A2A.</strong> The Claude Managed Agent speaks <strong>Anthropic’s Sessions API</strong>, not A2A. The <strong>MuleSoft A2A front door</strong> translates:</p><ul><li><strong>message/send with a </strong><strong>contextId</strong>: Claude side: Create or reuse a session</li><li><strong>Message text</strong>: Claude side: Send a user event</li><li><strong>Wait for the result</strong>: Claude side: Poll the session until Claude finishes the reply to <em>that</em> message</li><li><strong>A2A Task (</strong><strong>completed / </strong><strong>failed)</strong>: Claude side: Claude&#39;s final answer, or a timeout</li></ul><p>Now <strong>any A2A caller</strong> (the broker, a Teams bot, another agent) can use Claude without knowing it’s Claude. I built this as a custom Mule app. MuleSoft’s <strong>A2A Bridge</strong> is the managed alternative for agents that aren’t A2A-compliant.</p><p><strong>Example 2: a REST system becomes MCP.</strong> Salesforce speaks REST and SOAP, not MCP. The <strong>MuleSoft MCP server</strong> wraps it in 13 MCP tools. I built a custom MCP server because the tools need <strong>business logic</strong>: converting dates, enforcing full country names, combining an account with its contacts and deals. If you only need to expose an <strong>existing REST API as-is</strong>, <strong>MCP Bridge</strong> does it at the gateway with no code.</p><h3>11.3 Where versions and options vary</h3><p>Protocols are young, so check these before connecting anything:</p><ul><li><strong>A2A:</strong></li><li>the Agent Card path and spec version (older examples use a different file name),</li><li>message/send (wait for the result) vs. message/stream (server-sent events),</li><li>which task states each side understands.</li><li><strong>MCP:</strong></li><li><strong>Streamable HTTP</strong> is the current transport. The older <strong>SSE</strong> transport is deprecated.</li><li>Tool input schemas must be valid JSON Schema.</li><li><strong>Sync vs. async:</strong> our front door waits for Claude, which takes 10–30 seconds. For longer work, return a task right away and let the caller poll or subscribe.</li></ul><h3>11.4 Authentication across protocols</h3><ul><li><strong>Caller → gateway → A2A app</strong>: Protocol: A2A (JSON-RPC over HTTPS) · Credential: Client ID + secret or OAuth JWT (gateway policy), and a bearer token today</li><li><strong>A2A app → Claude</strong>: Protocol: Anthropic API · Credential: API key in a protected property</li><li><strong>Claude → gateway → MCP server</strong>: Protocol: MCP (Streamable HTTP) · Credential: Token in the Claude credential vault</li><li><strong>MCP server → Salesforce</strong>: Protocol: REST via the connector · Credential: OAuth client credentials (External Client App)</li></ul><p><strong>Rule:</strong> what the Agent Card says about authentication must match the gateway policy. Otherwise the broker discovers the agent but gets 401 at runtime.</p><h3>11.5 Broker integration</h3><p>Once the agent is registered with a managed instance:</p><ol><li>The broker’s agent-network.yaml references the <strong>registered A2A agent</strong> from Exchange.</li><li>The broker’s Agent Script routes requests using the <strong>skills on the Agent Card</strong>. Clear skill descriptions mean better routing.</li><li>Calls go out through the <strong>egress gateway</strong>, so authentication, rate limits and logging apply automatically.</li></ol><h3>Part 12: Enterprise readiness</h3><p>A working demo answers <em>“can it work?”</em>. Enterprise readiness answers <em>“can we run it, audit it, pay for it and change it safely?”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WXdQmczGPHmuHOvdLHXqjw.png" /></figure><h3>12.1 End-to-end observability</h3><p>One question leaves traces in <strong>four places</strong>. Join them with <strong>one correlationId</strong>:</p><ul><li><strong>Omni Gateway + Agent Visualizer</strong>: What it tells you: Who called whom, latency, errors, blocked calls</li><li><strong>Mule JSON logs (A2A app + MCP server)</strong>: What it tells you: Stage, flowName, durationMs, recordCount, as shown in Part 4</li><li><strong>Claude session events</strong>: What it tells you: Every tool call the agent made, with inputs and results</li><li><strong>Salesforce</strong>: What it tells you: API usage, Setup Audit Trail, field history</li></ul><p><strong>Tip:</strong> the A2A front door generates the correlationId. Send it to Claude as <strong>session metadata</strong>, and include it in every MCP tool call, so one ID connects all four sources.</p><h3>12.2 Cost tracking</h3><p>Know what <strong>one question</strong> costs:</p><ul><li><strong>Agent LLM tokens:</strong> Claude usage per workspace and agent. A small, fast model is enough for most CRM work.</li><li><strong>Broker LLM tokens:</strong> through the <strong>Model Proxy</strong>, with <strong>budgets</strong> (daily, weekly or monthly caps) and per-caller <strong>wallets</strong>.</li><li><strong>Runtime:</strong> CloudHub 2.0 vCores for the two Mule apps.</li><li><strong>Salesforce API limits:</strong> every tool call uses API calls. This hidden cost matters at scale.</li></ul><p><strong>Tip:</strong> gateway <strong>rate limits</strong> protect your budget too. A looping agent can’t burn through tokens if it can’t make the calls.</p><h3>12.3 Human approvals</h3><p>There are three places to put a person in the loop, from simplest to most controlled:</p><ol><li><strong>Claude tool permissions:</strong> set read tools to <strong>Always allow</strong> and write tools like update_opportunity to <strong>Always ask</strong>. This is the same setting that made agents look &quot;frozen&quot; in Part 5, now used deliberately.</li><li><strong>MCP elicitation inside the Mule tool:</strong> the tool itself asks <em>“Change stage to Closed Won for $35,000? Approve / Reject”</em> before it writes to Salesforce.</li><li><strong>A broker human-in-the-loop step:</strong> the workflow pauses, saves state in <strong>Object Store</strong>, and resumes after approval.</li></ol><p><strong>Rule:</strong> a timeout or no answer is <strong>never</strong> an approval.</p><h3>12.4 Agent lifecycle management</h3><ul><li><strong>Design</strong>: What to do: Define the skills, scope and risks before writing code</li><li><strong>Build</strong>: What to do: MCP server and A2A front door, tested locally with MCP Inspector and curl</li><li><strong>Register</strong>: What to do: Publish to Exchange with a version, e.g. 1.0.0, an owner and a description</li><li><strong>Deploy</strong>: What to do: Promote <strong>dev → test → prod</strong>, with separate configs and secrets per environment</li><li><strong>Govern</strong>: What to do: Apply gateway policies before the agent receives real traffic</li><li><strong>Operate</strong>: What to do: Watch Visualizer, logs and costs, and review failed tasks</li><li><strong>Version</strong>: What to do: Publish a new Agent Card version for breaking changes, and deprecate the old one with notice</li><li><strong>Retire</strong>: What to do: Kill switch first, then remove the instance and registry entry, and revoke keys</li></ul><h3>12.5 Native vs. custom governance</h3><ul><li><strong>Discovery and catalog</strong>: Native in Agent Fabric (configure it): Agent Registry, scanners</li><li><strong>Authentication</strong>: Native in Agent Fabric (configure it): Gateway policies: client ID, JWT validation · Custom in this project (build it): Bearer token check in the A2A app</li><li><strong>Traffic control</strong>: Native in Agent Fabric (configure it): Rate limiting, spike control · Custom in this project (build it): Timeouts and polling limits</li><li><strong>Data protection</strong>: Native in Agent Fabric (configure it): PII detection and masking · Custom in this project (build it): Date and picklist validation in tools</li><li><strong>Observability</strong>: Native in Agent Fabric (configure it): Agent Visualizer, Anypoint Monitoring · Custom in this project (build it): JSON logs with correlationId</li><li><strong>Cost</strong>: Native in Agent Fabric (configure it): Model Proxy budgets and wallets</li><li><strong>Emergency stop</strong>: Native in Agent Fabric (configure it): Kill switch</li><li><strong>Conversation state</strong>: Native in Agent Fabric (configure it): Broker state in Object Store · Custom in this project (build it): contextId → Claude session mapping</li></ul><p><strong>Rule of thumb:</strong> as you move to production, <strong>move custom security into native gateway policies</strong>. Keep custom code for <strong>business logic</strong>, the things only your use case needs.</p><h3>Part 13: Lessons learned (the things that actually tripped me up)</h3><p>These cost me real time, so hopefully they save you some:</p><ol><li><strong>“Always ask” makes agents look frozen.</strong> Set MCP tool permissions to Always allow (or Auto) for automated flows, and use “Always ask” only where you want a human approval.</li><li><strong>Dates must be real Date values.</strong> The connector rejected &quot;2026-12-31&quot; as text until the app converted date fields before saving.</li><li><strong>Duplicate rules are your friend.</strong> Salesforce blocked a duplicate account, and because the tool returns success:false with the reason, Claude could explain it to the user.</li><li><strong>DataWeave gotchas:</strong></li><li>Functions like some need import some from dw::core::Arrays inside modules.</li><li><strong>Polling must target your message.</strong> In a multi-turn chat, the app waits for the reply after the exact message it sent (by event id), otherwise it can return the previous answer.</li><li><strong>The Console’s “No tool list available” can be a preview issue.</strong> A real test session proved the agent could call the tools.</li><li><strong>VS Code “Restricted Mode” hides the MuleSoft extensions.</strong> If Anypoint Code Builder commands are missing, trust the folder.</li><li><strong>A scanned agent isn’t a callable agent.</strong> Protocol: OTHER means “catalog only”. Register the A2A version to route to it.</li></ol><h3>Part 14: How people actually use this</h3><p>Agent Fabric isn’t a chat app that users open. It’s the <strong>control centre behind the apps they already use</strong>:</p><ul><li><strong>End users</strong> ask in Teams, Slack or a web chat, and never see the plumbing.</li><li><strong>Developers</strong> find and reuse existing agents in the registry instead of rebuilding Salesforce integrations.</li><li><strong>Admins</strong> add policies, watch usage and cost, and can switch off a misbehaving agent in one click, without touching code.</li></ul><p>A natural next step for this project is a <strong>Microsoft Teams bot</strong> that sends users’ questions to the agent over A2A, exactly the same request we sent from curl.</p><h3>Wrapping up</h3><p>Here’s the whole journey in one breath:</p><blockquote><strong>Salesforce</strong> holds the data → a <strong>MuleSoft MCP server</strong> gives an AI safe “hands” → a <strong>Claude agent</strong> provides the “brain” → a <strong>MuleSoft A2A app</strong> gives it a standard “front door” → <strong>Agent Fabric</strong> discovers, registers, protects and monitors it all.</blockquote><p>If you remember only four things:</p><ol><li><strong>MCP = tools (hands). A2A = agents (experts). The LLM = the brain.</strong></li><li><strong>Discovery is not invocation.</strong> Scanners find agents. Registered A2A agents with instances can be called.</li><li><strong>One agent doesn’t need a broker. Many agents do</strong>, along with parallel calls, safe retries and honest partial answers.</li><li><strong>Every hop needs identity, policy and audit.</strong> Put a gateway in front of anything that touches real data.</li></ol><p>If this helped, follow me for the next part, where I connect this agent to Microsoft Teams and add gateway policies for production.</p><p><strong>Vijay Kumar</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=490dc0b4f6b3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/your-ai-needs-a-brain-hands-and-a-front-door-building-a-salesforce-agent-with-mulesoft-agent-490dc0b4f6b3">Your AI Needs a Brain, Hands, and a Front Door: Building a Salesforce Agent with MuleSoft Agent…</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding MCP Elicitation with MuleSoft: Building a Human-in-the-Loop Loan Approval MCP Server]]></title>
            <link>https://medium.com/another-integration-blog/understanding-mcp-elicitation-with-mulesoft-building-a-human-in-the-loop-loan-approval-mcp-server-e7f8913ce953?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7f8913ce953</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[salesforce]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 09:29:45 GMT</pubDate>
            <atom:updated>2026-10-05T09:29:45.293Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>AI agents are becoming increasingly capable of interacting with enterprise applications. An AI assistant can retrieve customer information, create orders, check account details, submit requests, and invoke business operations through tools.</p><p>But there is an important limitation:</p><p><strong>Not every business operation should be completed automatically by an AI agent.</strong></p><p>Consider a loan approval process.</p><p>A company might have the following rule:</p><ul><li>Loans up to <strong>$10,000</strong> can be automatically approved.</li><li>Loans above <strong>$10,000</strong> require human approval.</li></ul><p>Now imagine a user tells an AI assistant:</p><blockquote><em>“Approve a $25,000 loan for John Smith.”</em></blockquote><p>The AI understands the request and calls the appropriate MCP tool.</p><p>But MuleSoft should not simply approve the loan because the amount exceeds the company’s approval threshold.</p><p>Instead, MuleSoft needs to ask the user for an explicit decision:</p><blockquote><strong><em>Human Approval Required: Loan for John Smith — Amount: $25,000. Do you approve?</em></strong></blockquote><p>The user responds:</p><blockquote><em>Yes</em></blockquote><p>The MuleSoft flow then continues and processes the approval.</p><p>This interaction is where <strong>MCP Elicitation</strong> becomes useful.</p><p>In this article, we will build this concept using a simple <strong>Loan Approval MCP Server implemented in MuleSoft</strong>.</p><p>The goal is not just to show XML configuration. We will understand what happens at every stage and why each component exists.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CkMLBNRX3iRtMejzwvJj_w.png" /></figure><h3>Step 1 — Understand MCP Before Understanding Elicitation</h3><p>Let’s start with the foundation.</p><p><strong>MCP stands for Model Context Protocol.</strong></p><p>MCP provides a standardized way for AI applications to interact with external tools, data, and services.</p><p>For example, a MuleSoft MCP server could expose tools such as:</p><pre>get-customer<br>get-order-status<br>create-order<br>approve-loan<br>create-case</pre><p>An AI client can discover these tools and invoke them when required.</p><p>The important architectural idea is:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8Vt83aBPX-tI98vT2ASh0g.png" /></figure><p>MuleSoft remains responsible for the enterprise integration and business logic.</p><p>MCP provides the standardized interface through which AI clients can access those capabilities.</p><p>MuleSoft’s MCP Connector is specifically designed to expose Mule applications, APIs, connectors, and other capabilities to MCP-compatible AI clients.</p><h3>Step 2 — What Exactly Is MCP Elicitation?</h3><p>Now we can introduce elicitation.</p><p><strong>MCP Elicitation allows an MCP server to request additional structured input from the user through the MCP client during an interaction.</strong></p><p>In simple terms:</p><blockquote><em>The MCP server can say, “I need one more piece of information or a decision from the user before I can continue.”</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1f_i7eScxVEPXfectsnqDA.png" /></figure><p>This is different from returning an error. Without elicitation, the server could return:</p><pre>{<br>  &quot;status&quot;: &quot;PENDING&quot;,<br>  &quot;message&quot;: &quot;Human approval required&quot;<br>}</pre><p>The user would then need another mechanism to complete the approval.</p><p>With elicitation, the additional interaction happens through the MCP client as part of the current MCP workflow.</p><p>MuleSoft introduced the Create Elicitation operation in MCP Connector 1.6.0.</p><h3>Step 3 — Understand the Business Problem</h3><p>Before writing MuleSoft configuration, let’s define our business rule.</p><p>Our Loan Approval application has two paths:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5691ueAOUew0R6c_qxtolQ.png" /></figure><h3>Scenario 1: Small Loan</h3><p>User:</p><blockquote><em>Approve a $5,000 loan for John.</em></blockquote><p>MuleSoft checks:</p><pre>5000 &lt;= 10000</pre><p>The loan is automatically approved.</p><h3>Scenario 2: Large Loan</h3><p>User:</p><blockquote><em>Approve a $25,000 loan for John.</em></blockquote><p>MuleSoft checks:</p><pre>25000 &gt; 10000</pre><p>Human approval is required.</p><p>This simple rule gives us a perfect example of where elicitation fits into a real business process.</p><h3>Step 4 — Understand the Complete Architecture</h3><p>A generic “AI → MCP → MuleSoft → backend” picture hides what matters in a loan approval. So let’s look at the architecture for this specific use case: which systems the loan officer works in, what MuleSoft does in the middle, and which enterprise systems are touched before and after the human decision.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wijKkt6QhYnUTTY0MYTetw.png" /></figure><p><strong>1. Systems of engagement: where the approver works</strong></p><p>The loan officer or credit manager doesn’t open MuleSoft. They work in an AI client that speaks MCP:</p><ul><li>Claude Desktop</li></ul><p>The loan officer or credit manager doesn&#39;t open MuleSoft. They work in an AI client that speaks MCP:</p><ul><li>Microsoft Copilot / Teams</li><li>A custom loan-officer portal</li></ul><p>The elicitation prompt (“Human Approval Required… Do you approve?”) appears in that same client. The approver never has to switch tools.</p><p><strong>2. Integration layer: the Loan Approval MCP Server (MuleSoft on CloudHub 2.0)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*HXcPXRGi5cfqQVnlsaxlDA.png" /></figure><p><strong>3. Systems of record: what the loan actually touches</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*ZsIQKubNUfHou9wfSEzb2A.png" /></figure><p>The $25,000 request, end to end</p><pre>①  Loan officer: &quot;Approve a $25,000 loan for John Smith&quot;<br>②  AI client calls the MCP tool: loan<br>③  MuleSoft reads the customer and loan application from Salesforce<br>④  MuleSoft gets the credit score from the Credit Bureau<br>     → Choice: 25,000 &gt; 10,000 → human approval required<br>⑤  Create Elicitation → approval prompt appears in the AI client<br>⑥  Approver clicks APPROVE → Elicitation Result: ACCEPT<br>⑦  Salesforce: Loan Application status = Approved<br>⑧  SAP S/4HANA: loan contract booked, disbursement scheduled<br>⑨  Audit DB: approval record written<br>⑩  Customer and branch notified<br>⑪  Final result returned to the AI client</pre><p>The architecture looks like this:</p><p>There are five important pieces:</p><ol><li>MCP Server</li><li>Loan MCP Tool</li><li>Loan business rule</li><li>Create Elicitation</li><li>Elicitation response handling</li></ol><h3>Step 5 — Create the HTTP Listener</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kQ0Dub21dgrC0dO4tMgFwg.png" /></figure><p>The first configuration in our POC is the HTTP Listener.</p><pre>&lt;http:listener-config<br>    name=&quot;HTTP_Listener_config&quot;&gt;</pre><pre>    &lt;http:listener-connection<br>        host=&quot;0.0.0.0&quot;<br>        port=&quot;8081&quot;/&gt;</pre><pre>&lt;/http:listener-config&gt;</pre><p>For local development, MuleSoft is listening on:</p><pre>http://localhost:8081</pre><p>The MCP server will use this HTTP listener as its transport configuration.</p><p>When creating a new MuleSoft MCP application, you add the MCP Connector through Anypoint Studio and configure the required connector elements and operations from the Mule palette.</p><h3>Step 6 — Configure the MuleSoft MCP Server</h3><p>Next, we configure the MCP server.</p><p>Your POC contains:</p><pre>&lt;mcp:server-config<br>    name=&quot;MCP_Server&quot;<br>    serverName=&quot;mule-mcp-server&quot;<br>    serverVersion=&quot;1.0.0&quot;&gt;</pre><pre>    &lt;mcp:streamable-http-server-connection<br>        listenerConfig=&quot;HTTP_Listener_config&quot;<br>        requestTimeoutUnit=&quot;MINUTES&quot;/&gt;</pre><pre>&lt;/mcp:server-config&gt;</pre><p>Let’s understand the important fields.</p><h3>Server Name</h3><pre>mule-mcp-server</pre><p>This identifies the MCP server.</p><h3>Server Version</h3><pre>1.0.0</pre><p>This identifies the server version.</p><h3>Streamable HTTP</h3><pre>&lt;mcp:streamable-http-server-connection&gt;</pre><p>This defines the transport used by the MCP server.</p><p>For current MuleSoft MCP Connector implementations, <strong>Streamable HTTP is the recommended server transport</strong>. MuleSoft documents SSE server transport as deprecated and notes that Streamable HTTP should be used for multi-replica deployments.</p><h3>Step 7 — Expose the Loan Process as an MCP Tool</h3><p>Now we expose our business capability.</p><p>Your POC contains:</p><pre>&lt;mcp:tool-listener<br>    config-ref=&quot;MCP_Server&quot;<br>    name=&quot;loan&quot;&gt;</pre><p>This exposes a tool called:</p><pre>loan</pre><p>The tool description is:</p><pre>Approves loan requests.<br>For loans above $10,000 human approval is required via elicitation.</pre><p>The description is important because it tells the AI client what this tool is intended to do.</p><p>A good tool should have a clear responsibility.</p><p>For example:</p><pre>Good:<br>approve-loan</pre><pre>Less useful:<br>process-everything</pre><p>Another example:</p><pre>Good:<br>get-customer</pre><pre>Less useful:<br>customer-operation</pre><p>The more precise the tool description and contract are, the easier it is for an AI client to use the tool appropriately.</p><h3>Step 8 — Define the Loan Tool Input Schema</h3><p>Our loan tool needs information about the loan.</p><p>The POC defines fields such as:</p><pre>{<br>  &quot;customerName&quot;: &quot;John Smith&quot;,<br>  &quot;amount&quot;: 25000,<br>  &quot;purpose&quot;: &quot;Business&quot;,<br>  &quot;tenureMonths&quot;: 60<br>}</pre><p>The schema specifies rules for those values.</p><p>For example:</p><pre>&quot;amount&quot;: {<br>  &quot;type&quot;: &quot;number&quot;,<br>  &quot;minimum&quot;: 1000,<br>  &quot;maximum&quot;: 1000000<br>}</pre><p>This means the loan amount must be between:</p><pre>$1,000<br>and<br>$1,000,000</pre><p>The purpose field is also restricted:</p><pre>Home renovation<br>Car purchase<br>Education<br>Business<br>Medical<br>Other</pre><p>This is important because the MCP tool should have a clear contract.</p><p>Instead of allowing any arbitrary input, the schema tells the client what the tool expects.</p><p>Conceptually:</p><pre>AI Client<br>    |<br>    | What does the loan tool need?<br>    v<br>Tool Schema<br>    |<br>    +-- customerName<br>    +-- amount<br>    +-- purpose<br>    +-- tenureMonths</pre><h3>Step 9 — Receive the Tool Request and Capture the Session</h3><p>When the AI client calls the loan tool, MuleSoft receives the tool input as the flow payload.</p><p>For example:</p><pre>{<br>  &quot;customerName&quot;: &quot;John Smith&quot;,<br>  &quot;amount&quot;: 25000,<br>  &quot;purpose&quot;: &quot;Business&quot;,<br>  &quot;tenureMonths&quot;: 60<br>}</pre><p>Your POC stores the important values:</p><pre>&lt;ee:transform&gt;</pre><pre>    &lt;ee:variables&gt;</pre><pre>        &lt;ee:set-variable variableName=&quot;customer&quot;&gt;<br>            &lt;![CDATA[payload.customerName]]&gt;<br>        &lt;/ee:set-variable&gt;</pre><pre>        &lt;ee:set-variable variableName=&quot;amount&quot;&gt;<br>            &lt;![CDATA[payload.amount]]&gt;<br>        &lt;/ee:set-variable&gt;</pre><pre>        &lt;ee:set-variable variableName=&quot;mcpSessionId&quot;&gt;<br>            &lt;![CDATA[attributes.sessionId]]&gt;<br>        &lt;/ee:set-variable&gt;</pre><pre>    &lt;/ee:variables&gt;</pre><pre>&lt;/ee:transform&gt;</pre><p>We now have:</p><pre>vars.customer<br>vars.amount<br>vars.mcpSessionId</pre><p>The first two are business information.</p><p>The session ID is important specifically for elicitation because the server needs to associate the request with the connected MCP client session.</p><h3>Step 10 — Apply the Loan Approval Business Rule</h3><p>Now we reach the actual business logic.</p><p>Your POC uses a Choice router:</p><pre>&lt;choice&gt;</pre><pre>    &lt;when expression=&quot;#[vars.amount &gt; 10000]&quot;&gt;</pre><pre>        &lt;!-- Human approval --&gt;</pre><pre>    &lt;/when&gt;</pre><pre>    &lt;otherwise&gt;</pre><pre>        &lt;!-- Automatic approval --&gt;</pre><pre>    &lt;/otherwise&gt;</pre><pre>&lt;/choice&gt;</pre><p>This creates two paths.</p><h3>Path A</h3><pre>amount &lt;= 10,000</pre><p>Automatically approve.</p><h3>Path B</h3><pre>amount &gt; 10,000</pre><p>Ask the user for approval.</p><p>This is an important design pattern:</p><blockquote><strong><em>The business rule determines whether elicitation is necessary.</em></strong></blockquote><p>We don’t ask the user for approval for every loan.</p><p>We only ask when the business process requires human intervention.</p><h3>Step 11 — Process the Automatic Approval Path</h3><p>Let’s first take the simple scenario.</p><p>The user requests:</p><pre>{<br>  &quot;customerName&quot;: &quot;John Smith&quot;,<br>  &quot;amount&quot;: 5000<br>}</pre><p>MuleSoft evaluates:</p><pre>5000 &gt; 10000</pre><p>The result is false.</p><p>The flow goes to the otherwise branch.</p><p>Your POC returns:</p><pre>{<br>  &quot;Status&quot;: &quot;Auto approved Loan&quot;<br>}</pre><p>The flow is therefore:</p><pre>User<br> |<br> | $5,000 loan<br> v<br>AI<br> |<br> v<br>MuleSoft<br> |<br> | Amount &lt;= $10,000<br> v<br>Auto Approved</pre><p>There is no reason to use elicitation here because no human decision is required.</p><h3>Step 12 — Build the Human Approval Message</h3><p>Now let’s process the $25,000 scenario.</p><p>The request is:</p><pre>{<br>  &quot;customerName&quot;: &quot;John Smith&quot;,<br>  &quot;amount&quot;: 25000<br>}</pre><p>MuleSoft determines that human approval is required.</p><p>Before calling the elicitation operation, your POC creates the message using DataWeave:</p><pre>%dw 2.0<br>output text/plain<br>---<br>&quot;Human Approval Required: Loan for &quot; ++<br>(vars.customerName default &quot;Unknown Customer&quot;) ++<br>&quot; - Amount: &quot; ++<br>((vars.amount default 0) as String) ++<br>&quot;. Do you approve?&quot;</pre><p>For our example, the output becomes:</p><pre>Human Approval Required: Loan for John Smith - Amount: 25000. Do you approve?</pre><p>This is a good use of DataWeave because the message is generated dynamically from the actual request.</p><p>For another customer:</p><pre>Customer = Sarah<br>Amount = 50000</pre><p>the same expression produces:</p><pre>Human Approval Required: Loan for Sarah - Amount: 50000. Do you approve?</pre><p>No code change is required.</p><h3>Step 13 — Call Create Elicitation</h3><p>Now we reach the most important MuleSoft component in the POC:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m7Y4NOQXt2kyq_-F72h-AA.png" /></figure><pre>&lt;mcp:create-elicitation<br>    config-ref=&quot;MCP_Server&quot;<br>    sessionId=&quot;#[vars.mcpSessionId]&quot;<br>    message=&quot;#[vars.display]&quot;&gt;</pre><pre>    &lt;mcp:schema-properties&gt;</pre><pre>        &lt;mcp:string-schema-property<br>            minLength=&quot;2&quot;<br>            name=&quot;description&quot;<br>            maxLength=&quot;100&quot;/&gt;</pre><pre>    &lt;/mcp:schema-properties&gt;</pre><pre>&lt;/mcp:create-elicitation&gt;</pre><p>Let’s break it down.</p><h3>config-ref</h3><pre>MCP_Server</pre><p>Specifies the MCP server configuration.</p><h3>sessionId</h3><pre>vars.mcpSessionId</pre><p>Identifies the MCP client session.</p><h3>message</h3><pre>vars.display</pre><p>Contains the question shown to the client.</p><h3>Schema properties</h3><pre>description</pre><p>Defines the information that the client should return.</p><p>The MCP Connector supports different elicitation schema property types, including string, number, integer, boolean, and enum properties.</p><p>For this simple POC, we are using a string.</p><h3>Step 14 — Understand What Happens During Elicitation</h3><p>This is the most important concept in the blog.</p><p>When mcp:create-elicitation executes, MuleSoft sends the elicitation request to the connected MCP client.</p><p>The client presents the request to the user. The user responds. MuleSoft receives the result.</p><p>Conceptually:</p><pre>MuleSoft<br>   |<br>   | Create Elicitation<br>   v<br>MCP Client<br>   |<br>   | Show request<br>   v<br>User<br>   |<br>   | Approve<br>   v<br>MCP Client<br>   |<br>   | Return response<br>   v<br>MuleSoft</pre><p>The important MuleSoft behavior is that the <strong>Create Elicitation operation waits for the response</strong> rather than simply returning a normal business response immediately. MuleSoft documents this operation as blocking until the elicitation response is received.</p><p>This is what allows the Mule flow to continue based on the user’s response.</p><h3>Step 15 — Understand the Elicitation Result</h3><p>After the user responds, the Create Elicitation operation returns an <strong>Elicitation Result</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TZupHnZfHULIEZJVvs9ccQ.png" /></figure><p>The result contains two important pieces:</p><pre>action<br>content</pre><p>The action can be:</p><pre>ACCEPT<br>DECLINE<br>CANCEL</pre><p>For example, if the user accepts:</p><pre>{<br>  &quot;action&quot;: &quot;ACCEPT&quot;,<br>  &quot;content&quot;: {<br>    &quot;description&quot;: &quot;yes&quot;<br>  }<br>}</pre><p>If the user declines:</p><pre>{<br>  &quot;action&quot;: &quot;DECLINE&quot;,<br>  &quot;content&quot;: null<br>}</pre><p>If the user cancels:</p><pre>action = CANCEL</pre><p>The important distinction is that ACCEPT means the client supplied the requested information, while DECLINE means the user did not provide it. CANCEL represents cancellation of the operation. MuleSoft documents these outcomes as part of the Elicitation Result.</p><p>This is why production flows should check the <strong>action</strong>, rather than assuming that content will always be present.</p><h3>Step 16 — Process the Approval Decision</h3><p>Your POC currently checks:</p><pre>&lt;when expression=&#39;#[(payload.content.description == &quot;yes&quot;)]&#39;&gt;</pre><p>If the user returns:</p><pre>yes</pre><p>the flow enters the approval branch.</p><p>The response is:</p><pre>{<br>  &quot;status&quot;: &quot;Accepted through Approval Amount : 25000&quot;<br>}</pre><p>If the response is anything else, the flow enters the rejection path:</p><pre>{<br>  &quot;status&quot;: &quot;rejected&quot;<br>}</pre><p>For a proof of concept, this is perfectly reasonable.</p><p>However, for production, I would change the schema.</p><p>Instead of:</p><pre>{<br>  &quot;description&quot;: &quot;yes&quot;<br>}</pre><p>use something more explicit:</p><pre>{<br>  &quot;approval&quot;: &quot;APPROVE&quot;<br>}</pre><p>with allowed values:</p><pre>APPROVE<br>REJECT</pre><p>This eliminates ambiguity.</p><p>For example, these responses:</p><pre>yes<br>YES<br>sure<br>approved<br>go ahead</pre><p>may all mean the same thing to a human, but structured business systems should not have to interpret free-form text.</p><h3>Step 17 — Connect the Approval to a Real Enterprise System</h3><p>This is where the POC can become a real enterprise use case. Currently, the POC returns a simple JSON response.</p><p>In a real application, after the user approves the loan, MuleSoft could call Salesforce.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TZupHnZfHULIEZJVvs9ccQ.png" /></figure><p>The Salesforce record could contain:</p><pre>{<br>  &quot;Customer_Name__c&quot;: &quot;John Smith&quot;,<br>  &quot;Loan_Amount__c&quot;: 25000,<br>  &quot;Approval_Status__c&quot;: &quot;Approved&quot;,<br>  &quot;Approval_Source__c&quot;: &quot;MCP&quot;,<br>  &quot;Approval_Reason__c&quot;: &quot;Approved by authorized user&quot;<br>}</pre><p>The same pattern could be used with other enterprise systems.</p><h3>Purchase Order</h3><pre>PO &gt; $10,000<br>      |<br>      v<br>Human Approval<br>      |<br>      v<br>SAP / Salesforce</pre><h3>Refund</h3><pre>Refund &gt; $5,000<br>      |<br>      v<br>Human Approval<br>      |<br>      v<br>Order Management System</pre><h3>Customer Account Change</h3><pre>Sensitive Account Change<br>      |<br>      v<br>User Confirmation<br>      |<br>      v<br>Salesforce</pre><p>The important point is that <strong>elicitation is only the interaction step</strong>. MuleSoft can continue to perform the actual enterprise integration afterward.</p><h3>Step 18 — Handle Real-World Exceptions</h3><p>A POC normally demonstrates the happy path.</p><p>Production systems need to handle what happens when things go wrong.</p><h3>Scenario 1 — User declines</h3><pre>Elicitation<br>    |<br>    v<br>DECLINE<br>    |<br>    v<br>Loan = Rejected/Pending</pre><p>Do not treat this as a technical error.</p><p>It is a legitimate business outcome.</p><h3>Scenario 2 — User cancels</h3><pre>Elicitation<br>    |<br>    v<br>CANCEL<br>    |<br>    v<br>Stop processing</pre><p>MuleSoft documents cancellation as an MCP:OPERATION_CANCELLED outcome from the Create Elicitation operation.</p><h3>Scenario 3 — User doesn’t respond</h3><p>Elicitation has a timeout configuration.</p><p>The current connector documentation exposes <strong>Elicitation Timeout Seconds</strong>, which controls how long an elicitation request waits for a response.</p><p>A sensible business response would be:</p><pre>Timeout<br>   |<br>   v<br>Loan remains Pending Approval</pre><p>Not:</p><pre>Timeout<br>   |<br>   v<br>Loan Approved</pre><p>That would be a serious business logic flaw.</p><h3>Step 19 — Production Considerations</h3><p>The local POC is straightforward, but production deployment introduces additional considerations.</p><h3>19.1 Multi-Replica Deployments</h3><p>Suppose the application runs with two replicas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SiOzRwL0v4HgZXNQGJ7oZA.png" /></figure><p>The elicitation request may originate on one worker while the response is received by another.</p><p>MuleSoft provides an <strong>Elicitations Object Store</strong> to correlate elicitation requests and responses.</p><p>For multi-replica deployments, MuleSoft recommends a distributed object store so responses can be correctly routed back to the appropriate worker.</p><p>This is particularly important when deploying MCP applications to CloudHub 2.0.</p><h3>19.2 Authentication and Authorization</h3><p>Elicitation itself should not be treated as authorization.</p><p>Suppose a user approves a:</p><pre>$500,000 loan</pre><p>You still need to determine:</p><ul><li>Who is the user?</li><li>Is the user authenticated?</li><li>Is the user allowed to approve loans?</li><li>What is the user’s approval limit?</li><li>Does the transaction require additional authorization?</li></ul><p>The architecture should therefore be:</p><pre>Authentication<br>       |<br>       v<br>Authorization<br>       |<br>       v<br>Business Rules<br>       |<br>       v<br>Elicitation<br>       |<br>       v<br>Enterprise Transaction</pre><p>Elicitation answers:</p><blockquote><em>“What decision or information does the user provide?”</em></blockquote><p>Authorization answers:</p><blockquote><em>“Is this user allowed to make that decision?”</em></blockquote><p>They are different concerns.</p><h3>19.3 Use Structured Responses</h3><p>Avoid designing important business decisions around:</p><pre>&quot;yes&quot;<br>&quot;no&quot;</pre><p>Prefer:</p><pre>{<br>  &quot;approval&quot;: &quot;APPROVE&quot;,<br>  &quot;reason&quot;: &quot;Approved based on customer eligibility&quot;<br>}</pre><p>Structured responses are easier to validate, audit, log, and send to downstream systems.</p><h3>Step 20 — Putting Everything Together</h3><p>We can now understand the entire Loan Approval POC without looking at every XML element individually.</p><p>The complete process is:</p><pre>1. User asks AI to approve a loan<br>              |<br>              v<br>2. AI identifies the &quot;loan&quot; MCP tool<br>              |<br>              v<br>3. MCP client calls MuleSoft<br>              |<br>              v<br>4. MuleSoft receives loan details<br>              |<br>              v<br>5. MuleSoft checks the loan amount<br>              |<br>       +------+------+<br>       |             |<br>    &lt;= $10K       &gt; $10K<br>       |             |<br>       v             v<br>6. Auto Approve   6. Create Elicitation<br>                     |<br>                     v<br>                  7. User<br>                     |<br>              +------+------+<br>              |             |<br>             YES            NO<br>              |             |<br>              v             v<br>       8. Approve       8. Reject<br>              |<br>              v<br>9. Call enterprise system<br>              |<br>              v<br>10. Return final result</pre><p>For the actual example:</p><pre>User:<br>&quot;Approve a $25,000 loan for John Smith.&quot;</pre><pre>        ↓</pre><pre>AI Client</pre><pre>        ↓</pre><pre>MCP Tool:<br>loan</pre><pre>        ↓</pre><pre>MuleSoft</pre><pre>        ↓</pre><pre>amount = 25000</pre><pre>        ↓</pre><pre>25000 &gt; 10000</pre><pre>        ↓</pre><pre>Create Elicitation</pre><pre>        ↓</pre><pre>&quot;Human Approval Required:<br> Loan for John Smith - Amount: 25000.<br> Do you approve?&quot;</pre><pre>        ↓</pre><pre>User:<br>&quot;Yes&quot;</pre><pre>        ↓</pre><pre>Elicitation Result:<br>ACCEPT</pre><pre>        ↓</pre><pre>MuleSoft</pre><pre>        ↓</pre><pre>Loan Approved</pre><pre>        ↓</pre><pre>Salesforce / Database / Backend API</pre><pre>        ↓</pre><pre>Final Response</pre><p>That is the entire concept.</p><h3>Real-World Business Applications</h3><p>The Loan Approval example is only one implementation of the pattern.</p><p>The same architecture can be applied to many enterprise scenarios.</p><h3>1. Purchase Order Approval</h3><p>A company may have a rule:</p><pre>PO &lt;= $5,000<br>    → Automatically process</pre><pre>PO &gt; $5,000<br>    → Human approval</pre><p>An AI agent can initiate the PO, while MuleSoft uses elicitation when approval is required.</p><h3>2. Refund Approval</h3><p>An AI customer-service agent could receive:</p><blockquote><em>“Refund $7,500 for this customer.”</em></blockquote><p>Business rule:</p><pre>Refund &lt;= $1,000<br>    → Auto process</pre><pre>Refund &gt; $1,000<br>    → Human approval</pre><p>The agent can ask the authorized user for confirmation before MuleSoft calls the refund API.</p><h3>3. Customer Account Changes</h3><p>Suppose an AI agent is asked:</p><blockquote><em>“Change the customer’s billing account.”</em></blockquote><p>Because this is sensitive information, the system can request confirmation:</p><pre>The billing account will be changed from<br>Account A to Account B.</pre><pre>Do you approve this change?</pre><p>After confirmation, MuleSoft can update Salesforce.</p><h3>4. Discount Approval</h3><p>A sales assistant could request:</p><blockquote><em>“Apply a 25% discount to this opportunity.”</em></blockquote><p>Business policy:</p><pre>Discount &lt;= 10%<br>    → Salesperson can proceed</pre><pre>Discount &gt; 10%<br>    → Manager approval required</pre><p>MCP Elicitation can be used to obtain that approval before MuleSoft updates Salesforce.</p><h3>Conclusion</h3><p>MCP Elicitation solves a very practical problem in AI-driven integrations:</p><blockquote><strong><em>What should happen when an AI agent reaches a point where it needs additional information or a human decision before continuing?</em></strong></blockquote><p>Instead of returning an error or forcing the user into a separate workflow, the MCP server can request the required information through the MCP client.</p><p>Our MuleSoft Loan Approval POC demonstrates the pattern clearly:</p><pre>AI Request<br>    |<br>    v<br>MCP Tool<br>    |<br>    v<br>Business Rule<br>    |<br>    +--------------------+<br>    |                    |<br>    v                    v<br>Auto Approval       Human Approval<br>                         |<br>                         v<br>                    Elicitation<br>                         |<br>                    +----+----+<br>                    |         |<br>                  Accept    Decline<br>                    |         |<br>                    v         v<br>                Approved    Rejected</pre><p>The most important takeaway is that <strong>MCP Elicitation does not replace your enterprise integration logic</strong>.</p><p>MuleSoft still handles:</p><ul><li>Business rules</li><li>Data transformation</li><li>Salesforce integration</li><li>API integration</li><li>Error handling</li><li>Security</li><li>Logging</li><li>Enterprise orchestration</li></ul><p>MCP provides the standardized interaction layer for AI clients, while elicitation provides a way to bring the human into the workflow when required.</p><p>That combination creates a powerful enterprise pattern:</p><pre>AI Agent<br>                  |<br>                 MCP<br>                  |<br>          MuleSoft Integration<br>                  |<br>       +----------+----------+<br>       |          |          |<br>   Salesforce     SAP     Databases<br>                  |<br>          Human-in-the-Loop<br>             Elicitation</pre><p>For MuleSoft developers and architects, this is one of the most practical ways to think about MCP:</p><blockquote><strong><em>Don’t replace your existing enterprise integrations with AI. Expose the right capabilities to AI, keep the business rules in the integration layer, and use elicitation when a real human decision is required.</em></strong></blockquote><h3>References</h3><ul><li><a href="https://docs.mulesoft.com/mcp-connector/latest/?utm_source=chatgpt.com">MuleSoft MCP Connector 1.6 Documentation</a></li><li><a href="https://docs.mulesoft.com/mcp-connector/latest/mcp-connector-reference?utm_source=chatgpt.com">MuleSoft MCP Connector Reference</a></li><li><a href="https://docs.mulesoft.com/mcp-connector/latest/mcp-connector-studio?utm_source=chatgpt.com">Using Anypoint Studio to Configure MCP Connector</a></li><li><a href="https://docs.mulesoft.com/release-notes/connector/mcp-connector-release-notes-mule-4?utm_source=chatgpt.com">MuleSoft MCP Connector Release Notes</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7f8913ce953" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/understanding-mcp-elicitation-with-mulesoft-building-a-human-in-the-loop-loan-approval-mcp-server-e7f8913ce953">Understanding MCP Elicitation with MuleSoft: Building a Human-in-the-Loop Loan Approval MCP Server</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI Gatekeeper: How MuleSoft LLM Proxy Turns Scattered AI into Smart, Safe Enterprise Power]]></title>
            <link>https://medium.com/another-integration-blog/the-ai-gatekeeper-how-mulesoft-llm-proxy-turns-scattered-ai-into-smart-safe-enterprise-power-da8bfe1a4138?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/da8bfe1a4138</guid>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 07:08:45 GMT</pubDate>
            <atom:updated>2026-07-03T08:02:43.586Z</atom:updated>
            <content:encoded><![CDATA[<h3>Imagine This…</h3><p>You own <strong>QuickMart</strong>, one of India’s fastest-growing online grocery retailers. Your company has enthusiastically embraced AI across every department:</p><ul><li>Customer Support Chatbot</li><li>HR Assistant for employees</li><li>Sales Copilot for the field team</li><li>Marketing Content Generator</li><li>Legal Document Assistant</li><li>Internal Knowledge Search tool</li><li>Coding Assistant for developers</li></ul><p>Each team picked their favorite AI model. Marketing loved GPT, Legal preferred Claude, Developers used Gemini, and Finance went with Azure OpenAI. Everything seemed to work fine at first.</p><p><strong>Six months later…</strong></p><p>The problems started piling up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CgKJVNYSBBqDt-GyovqAAA.png" /></figure><p>The CIO asked: <strong>“How much are we spending on AI every month?”</strong> Nobody could give a clear answer.</p><p>The Security team asked: <strong>“Are employees accidentally sending customer phone numbers, addresses, or payment details to public AI models?”</strong> No one knew for sure.</p><p>Finance raised alarms: <strong>“Why has our AI bill suddenly tripled?”</strong></p><p>The architecture team wanted to switch providers for better pricing: <strong>“Can we move from GPT to Gemini without updating 50 different applications?”</strong> The answer was painful: <strong>No.</strong></p><p>Every application had its own direct connections, API keys, retry logic, error handling, and model selection code. The setup looked like this:</p><pre>Chatbot  ───► OpenAI<br>HR System ───► Claude<br>Website  ───► Gemini<br>Sales App ───► Azure OpenAI<br>Developer Tool ───► GPT<br>Legal Assistant ───► Claude</pre><p>Duplication everywhere. Chaos growing. Costs rising. Risks increasing.</p><h3>This Is Where MuleSoft LLM Proxy Changes Everything</h3><p>Instead of every application talking directly to multiple AI providers, <strong>all applications now talk to just one single, secure endpoint</strong> — the MuleSoft LLM Proxy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_3TcbzkXCs5fqZQn3gMh7Q.png" /></figure><p>Applications no longer need to know:</p><ul><li>Which model is best</li><li>Which provider is cheapest today</li><li>How to handle authentication</li><li>How to mask sensitive data</li><li>How to track costs</li></ul><p>They simply send a prompt. The Proxy handles everything else intelligently.</p><p><strong>Think of the LLM Proxy like an Air Traffic Controller for AI.</strong></p><p>Hundreds of planes (prompts) arrive every hour. Instead of each pilot choosing their own runway (LLM), the control tower decides the best runway, checks safety conditions, manages traffic, logs everything, and ensures smooth landings — all while the pilots (your applications) follow simple instructions.</p><h3>What Exactly Is MuleSoft LLM Proxy?</h3><p><strong>MuleSoft LLM Proxy</strong> is a unified, intelligent gateway that sits between your business applications and multiple Large Language Model providers. It is deployed on MuleSoft’s Omni Gateway (or Flex Gateway) and provides one consistent front door for all AI interactions.</p><p>It doesn’t replace the LLMs — it governs, optimizes, secures, and routes requests to them.</p><h3>End-to-End Journey of One Real AI Request</h3><p>Let’s follow a complete request through the system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pVG_yQGm151Ad74zkdEzog.png" /></figure><p><strong>A customer opens the QuickMart app and types:</strong></p><blockquote><em>“Suggest healthy breakfast ideas under ₹300 using items available today.”</em></blockquote><p><strong>Step 1: Application Sends the Prompt</strong> The mobile app makes one simple call:</p><pre>POST /llm-proxy<br>{<br>  &quot;prompt&quot;: &quot;Suggest healthy breakfast ideas under ₹300...&quot;<br>}</pre><p>The app doesn’t specify any model or provider.</p><p><strong>Step 2: Authentication &amp; Basic Checks</strong> The Proxy verifies:</p><ul><li>Is this app allowed to use AI?</li><li>Is the API key valid?</li><li>Which team/business unit does this belong to?</li></ul><p><strong>Step 3: Security &amp; Compliance Policies</strong> The Proxy scans the prompt for sensitive data (names, addresses, payment info, etc.). If anything risky is found, it can mask, block, or log it automatically.</p><p><strong>Step 4: Budget &amp; Quota Check</strong> It checks if the Marketing or Support team’s monthly token budget is still available. If limits are near, it can downgrade the model or notify admins.</p><h3><strong>Step 5: Intelligent Routing</strong> (The Smart Decision)</h3><p>Here the Proxy shines with two powerful options:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*61vKb1WzH0Htd0_BESK5jQ.png" /></figure><p><strong>Option A: Model-Based Routing (Static)</strong> The app explicitly says: “model”: “gpt-4o-mini”. The Proxy validates policies and forwards the request. <strong>Best for</strong>: Predictable tasks, compliance requirements, or A/B testing.</p><p><strong>Option B: Semantic Routing (Dynamic &amp; Intelligent)</strong> The app sends only the prompt. The Proxy understands its <strong>meaning</strong> and matches it against predefined topics:</p><ul><li>“Simple product/inventory query” → Fast &amp; cheap model</li><li>“Marketing content creation” → Creative, balanced model</li><li>“Legal or financial analysis” → High-accuracy, powerful model</li></ul><p>In this case, “healthy breakfast ideas” is recognized as a <strong>simple customer support / marketing</strong> request → routed to a fast, cost-effective model.</p><p><strong>Step 6: The Chosen LLM Processes the Request</strong> The selected model generates a nice response.</p><p><strong>Step 7: Response Handling</strong> The Proxy can:</p><ul><li>Filter unsafe content</li><li>Standardize the format</li><li>Add disclaimers</li><li>Log the full interaction</li></ul><p><strong>Step 8: Monitoring &amp; Analytics</strong> Everything is recorded in Anypoint Platform dashboards — cost, tokens used, latency, success rate, etc.</p><p>The customer receives a helpful, on-brand suggestion within seconds.</p><h3>Why Businesses Love MuleSoft LLM Proxy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ea78LJi1gTHEx4TxSs0TJA.png" /></figure><ul><li><strong>Lower Costs</strong>: Simple requests use cheap models; only complex ones use premium models.</li><li><strong>Stronger Security</strong>: Sensitive data is protected centrally before leaving your environment.</li><li><strong>Centralized Governance</strong>: One place to enforce policies, quotas, and compliance.</li><li><strong>Greater Flexibility</strong>: Switch or add new LLMs without changing applications.</li><li><strong>Improved Productivity</strong>: Developers focus on business value, not AI plumbing.</li><li><strong>Full Observability</strong>: Clear visibility into every AI interaction and rupee spent.</li></ul><h3>Where LLM Proxy Fits in the MuleSoft AI Ecosystem</h3><p>LLM Proxy is the foundation. It works together with:</p><ul><li><strong>MCP Server</strong>: Turns your existing APIs into discoverable tools for any AI agent.</li><li><strong>AI Chain Connector</strong>: Builds complex, multi-step AI workflows.</li><li><strong>Agent Registry</strong>: Manages AI agents across the enterprise.</li></ul><p>Together, they enable secure, governed, and scalable AI solutions.</p><h3>Getting Started (Step-by-Step)</h3><h3>Step 1: Open the LLM Proxy Wizard</h3><ol><li>Log in to <strong>Anypoint Platform</strong>.</li><li>Go to <strong>API Manager → LLM Proxies</strong>.</li><li>Click <strong>+ Create LLM Proxy</strong>.</li></ol><p>This launches a clean, three-step wizard: <strong>Inbound → Gateway → Outbound</strong>. You can’t move forward until each step is properly filled — making it hard to make mistakes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8PHUsOIR-cJXvpXhXZ9_uQ.png" /></figure><h3>Step 2: Configure the Inbound Endpoint (The Front Door)</h3><p>This is where you define how your applications will talk to the Proxy.</p><ul><li><strong>Proxy Name</strong>: Give it a clear name (e.g., QuickMart-AI-Gateway).</li><li><strong>Base Path</strong>: Set the URL path (e.g., /llm-proxy).</li><li><strong>Provider Format</strong>: Choose the main format (usually OpenAI-compatible).</li></ul><p>This becomes your <strong>single unified endpoint</strong> for all AI requests.</p><p><strong>Result</strong>: Every app in your company now calls one address instead of many different AI providers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xz1p0fHtLL9SmSqxBXrq9g.png" /></figure><h3>Step 3: Choose Your Gateway (The Engine Room)</h3><p>Select the <strong>Omni Gateway</strong> where this Proxy will run.</p><p>The gateway is the actual runtime that will:</p><ul><li>Receive requests</li><li>Apply security</li><li>Make routing decisions</li><li>Monitor everything</li></ul><p>After selecting the gateway, copy the <strong>Consumer Endpoint URL</strong> (this is the live address your apps will use).</p><p><strong>Example</strong>: <a href="https://your-gateway-name.cloudhub.io/llm-proxy">https://your-gateway-name.cloudhub.io/llm-proxy</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FG6lZtAmUfSmT1UZQe_0xg.png" /></figure><h3>Step 4: Set Up Outbound Routes (Where Requests Go)</h3><p>Here you connect real LLM providers.</p><p>For each route, you define:</p><ul><li>LLM Provider (OpenAI, Gemini, Claude, Azure, etc.)</li><li>API Key</li><li>Default Target Model</li></ul><p>You can add multiple routes. For example:</p><ul><li>Route 1: OpenAI + GPT-4o</li><li>Route 2: Gemini + Gemini Flash</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FZfcJ3XvwScb2OuOaiZfgQ.png" /></figure><h3>Step 5: Choose Your Routing Strategy</h3><p>This is the heart of the Proxy’s intelligence.</p><p><strong>Model-Based Routing (Recommended for Beginners)</strong> You (or your app) tell the Proxy exactly which model to use. Simple, predictable, and easy to control.</p><p><strong>Semantic Routing (More Intelligent)</strong> You send only the prompt. The Proxy reads the meaning and automatically picks the best model. Great for chatbots and dynamic use cases.</p><h3>Step 6: Add a Fallback Route (For Reliability)</h3><p>Always set up a backup.</p><p>If the main model fails (rate limit, outage, timeout), the Proxy automatically sends the request to the fallback model.</p><p>This keeps your AI applications running smoothly even when one provider has issues.</p><h3>Step 7: Deploy</h3><p>Click <strong>Deploy</strong>.</p><p>Your LLM Proxy goes live on the chosen gateway. From this moment, all AI traffic flows through MuleSoft — with full governance applied.</p><h3>Step 8: Test It</h3><p>Use Postman or your application to send a test prompt to the Consumer Endpoint.</p><p>Check that:</p><ul><li>The request reaches the correct model</li><li>Security policies work</li><li>You get a proper response</li><li>Monitoring data appears in the dashboard</li></ul><h3>Step 9: Monitor &amp; Improve</h3><p>Go to the Anypoint Platform dashboards to see:</p><ul><li>Total requests</li><li>Token usage and costs</li><li>Which models are used most</li><li>Response times</li><li>Any policy violations</li></ul><h3>Best Practices</h3><ul><li>Start small with 1–2 high-impact use cases.</li><li>Carefully design semantic topics with real example prompts.</li><li>Set clear token budgets per team.</li><li>Review analytics regularly and refine routing.</li><li>Add custom policies for your industry (banking, retail, healthcare, etc.).</li></ul><h3>Final Thoughts</h3><p>Enterprise AI is no longer just about picking the latest powerful model. It’s about using AI <strong>responsibly, securely, efficiently, and at scale</strong>.</p><p>MuleSoft LLM Proxy provides the critical governed layer that turns scattered experiments into a mature, enterprise-ready AI platform. It shifts the question from “Which LLM should my app call?” to “How can we deliver the best AI experience while staying in control?”</p><p>That is the real power of the AI Receptionist.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da8bfe1a4138" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/the-ai-gatekeeper-how-mulesoft-llm-proxy-turns-scattered-ai-into-smart-safe-enterprise-power-da8bfe1a4138">The AI Gatekeeper: How MuleSoft LLM Proxy Turns Scattered AI into Smart, Safe Enterprise Power</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MuleSoft MCP Bridge: The Fastest Way to Make Your Existing APIs AI-Ready]]></title>
            <link>https://medium.com/another-integration-blog/mulesoft-mcp-bridge-the-fastest-way-to-make-your-existing-apis-ai-ready-94b00a458127?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/94b00a458127</guid>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Thu, 25 Jun 2026 14:17:26 GMT</pubDate>
            <atom:updated>2026-07-15T16:55:06.717Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction:</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i45MyW5GnxdsXdvOkLhKmw.png" /></figure><p>Artificial Intelligence is rapidly changing how businesses interact with their systems. Modern AI agents are no longer limited to answering questions; they can perform actions, retrieve information, create records, trigger workflows, and automate entire business processes.</p><p>As organizations move towards Agentic AI, a common question arises:</p><h3><strong><em>How can AI agents securely access and use our existing enterprise APIs?</em></strong></h3><p>Most organizations already have hundreds of APIs running in production. These APIs power critical business functions such as customer management, order processing, inventory tracking, payments, HR operations, and more.</p><p>The challenge is not building new APIs.</p><p>The challenge is enabling AI agents to use existing APIs without:</p><ul><li>Rewriting applications</li><li>Creating duplicate implementations</li><li>Adding operational complexity</li><li>Losing governance and security</li></ul><h3><strong>This is exactly the problem MuleSoft MCP Bridge was designed to solve.</strong></h3><p>In this blog, we will understand:</p><ul><li>Why MCP Bridge is needed</li><li>The limitations of traditional approaches</li><li>How MCP Bridge works</li><li>Real-world examples</li><li>Step-by-step implementation</li><li>Enterprise benefits and best practices</li></ul><h3>Why Do We Need MCP Bridge?</h3><p>Before understanding MCP Bridge, let’s start with a real-world business problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7phbknAuyeWSIoS49zqEJA.png" /></figure><h3>A Typical Enterprise Scenario</h3><p>Imagine you work for an e-commerce company.</p><p>Over the years, your organization has built several APIs:</p><h3>Products API</h3><p>Used to:</p><ul><li>Retrieve products</li><li>Search products</li><li>Create products</li></ul><h3>Orders API</h3><p>Used to:</p><ul><li>Create orders</li><li>Retrieve orders</li><li>Update order status</li></ul><h3>Customer API</h3><p>Used to:</p><ul><li>Retrieve customer information</li><li>Update customer profiles</li></ul><blockquote><strong>These APIs are already:</strong></blockquote><ul><li>Running in production</li><li>Tested and validated</li><li>Protected with security policies</li><li>Consumed by multiple applications</li></ul><p>Now the business introduces an AI shopping assistant.</p><p>A customer should be able to ask:</p><blockquote><em>“Show me all available iPhones and place an order for 10 units.”</em></blockquote><p>To fulfill this request, the AI must:</p><ol><li>Retrieve products</li><li>Check inventory</li><li>Create an order</li><li>Return confirmation</li></ol><p>The APIs already exist.</p><p>The AI simply needs a way to use them.</p><h3>The Traditional Approach</h3><p>One way to solve this problem is by implementing MCP support directly at the application level.</p><p>For example:</p><pre>GET /products  → MCP Tool<br>POST /products → MCP Tool</pre><pre>GET /orders    → MCP Tool<br>POST /orders   → MCP Tool</pre><p>Developers can either:</p><h3>Option 1: Create a New Mule Application</h3><p>Build a separate Mule application containing MCP connectors and tools.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E9kPCCbdVoK2RlAaF23l9Q.png" /></figure><h3>Option 2: Modify Existing Applications</h3><p>Add MCP connectors into existing Mule applications.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yIwolKXvbc2g0CNhRTRkFg.png" /></figure><p>Both approaches work.</p><p>However, they introduce additional effort.</p><p>Teams must:</p><ul><li>Create MCP tools</li><li>Configure listeners</li><li>Define schemas</li><li>Test changes</li><li>Deploy applications</li><li>Maintain MCP implementations</li></ul><p>For a few APIs, this is manageable.</p><p>For large enterprises, it becomes a challenge.</p><h3>Why the Traditional Approach Doesn’t Scale</h3><p>Let’s imagine a realistic enterprise environment.</p><p>An organization may have:</p><ul><li>200 APIs</li><li>Thousands of API operations</li><li>Multiple development teams</li></ul><p>Every API operation exposed to AI may require a corresponding MCP tool.</p><p>That means:</p><pre>200 APIs<br>    ↓<br>Thousands of MCP Tools</pre><p>Now consider what happens when an API changes.</p><pre>API Change<br>    ↓<br>MCP Tool Update<br>    ↓<br>Testing<br>    ↓<br>Deployment</pre><p>Multiply this across hundreds of APIs.</p><p>The result:</p><ul><li>Increased maintenance</li><li>Operational overhead</li><li>Duplicate development effort</li><li>Governance challenges</li><li>Security inconsistencies</li></ul><p>This is where MuleSoft MCP Bridge becomes valuable.</p><h3>What is MuleSoft MCP Bridge?</h3><p>MCP Bridge is a platform-level capability that converts existing APIs into MCP-compatible tools without requiring application code changes.</p><p>Instead of implementing MCP individually within applications, organizations can configure MCP Bridge and expose existing APIs as AI-ready tools.</p><p>Think of MCP Bridge as a translator between AI agents and enterprise APIs.</p><h3>Without MCP Bridge</h3><pre>AI Agent<br>    ↓<br>Custom MCP Application<br>    ↓<br>Existing APIs</pre><h3>With MCP Bridge</h3><pre>AI Agent<br>    ↓<br>MCP Bridge<br>    ↓<br>Existing APIs</pre><p>The APIs remain unchanged.</p><p>The bridge handles all MCP communication.</p><h3>Real-World Analogy</h3><p>Imagine a large international airport.</p><p>Passengers arrive speaking:</p><ul><li>English</li><li>Japanese</li><li>French</li><li>German</li></ul><p>Without translators, airport staff would need to learn every language.</p><p>That would be inefficient and difficult to manage.</p><p>Instead, the airport provides translation services.</p><pre>Passenger<br>    ↓<br>Translator<br>    ↓<br>Airport Staff</pre><p>Airport staff continue working exactly as before.</p><p>The translator handles communication.</p><p>MCP Bridge works similarly.</p><pre>AI Agent<br>    ↓<br>MCP Bridge<br>    ↓<br>Products API<br>Orders API<br>Customer API</pre><p>The APIs continue operating normally.</p><p>The bridge translates AI requests into API calls.</p><h3>How MCP Bridge Works</h3><p>MCP Bridge is deployed on Omni Gateway and acts as the connection point between AI agents and enterprise APIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y88gDDTsjApo3rz6i3Hk5w.png" /></figure><p>The architecture consists of three main layers.</p><h3>Layer 1: AI Agents</h3><p>These are MCP-compatible clients.</p><p>Examples include:</p><ul><li>Claude</li><li>Cursor</li><li>Agentforce</li><li>Internal AI Assistants</li><li>Custom AI Applications</li></ul><p>These agents communicate using MCP.</p><h3>Layer 2: MCP Bridge on Flex Gateway</h3><p>This layer performs several responsibilities:</p><h3>Tool Discovery</h3><p>Provides AI agents with a list of available tools.</p><h3>Request Validation</h3><p>Ensures incoming requests match expected schemas.</p><h3>Policy Enforcement</h3><p>Applies security and governance controls.</p><h3>Request Routing</h3><p>Maps tool invocations to API operations.</p><h3>Monitoring</h3><p>Captures metrics and analytics.</p><h3>Layer 3: Existing APIs</h3><p>These are your current production services.</p><p>Examples:</p><ul><li>Products API</li><li>Orders API</li><li>Customers API</li><li>Inventory API</li></ul><p>No modifications are required.</p><h3>End-to-End Flow: How a Tool Call Becomes an API Call</h3><p>Let’s walk through a complete example.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7jwO0oJIcownyDxOOaQnxw.png" /></figure><p>A customer tells an AI assistant:</p><blockquote><em>“Order 10 iPhone 17 devices.”</em></blockquote><h3>Step 1: Agent Requests Available Tools</h3><p>The AI agent sends a request asking:</p><pre>tools/list</pre><h3>Step 2: MCP Bridge Returns Available Tools</h3><p>Example:</p><pre>getProducts<br>getOrders<br>createOrder<br>createProduct</pre><p>These tools are automatically generated from your API specifications.</p><h3>Step 3: Agent Retrieves Product Information</h3><p>The AI invokes:</p><pre>getProducts</pre><h3>Step 4: MCP Bridge Translates the Request</h3><p>The bridge converts the request into:</p><pre>GET /products</pre><p>and sends it to the Products API.</p><h3>Step 5: Product Information Is Returned</h3><p>The API responds with available products.</p><p>The AI identifies the requested item.</p><h3>Step 6: Agent Creates an Order</h3><p>The AI invokes:</p><pre>createOrder</pre><p>with:</p><pre>{<br>  &quot;product&quot;: &quot;iPhone 17&quot;,<br>  &quot;quantity&quot;: 10<br>}</pre><h3>Step 7: Bridge Converts to API Request</h3><p>The bridge translates the tool call into:</p><pre>POST /orders</pre><h3>Step 8: Order Is Created</h3><p>The Orders API processes the request and returns:</p><pre>{<br>  &quot;orderId&quot;: &quot;ORD-10001&quot;,<br>  &quot;status&quot;: &quot;Created&quot;<br>}</pre><h3>Step 9: Response Returned to User</h3><p>The AI responds:</p><blockquote><em>“Your order has been successfully created. Order ID: ORD-10001.”</em></blockquote><p>Throughout this entire process, the original APIs remain untouched.</p><h3><strong>Building Enterprise-Ready AI Applications with MCP Bridge</strong></h3><p>Connecting APIs to AI is only the first step. Building a successful enterprise AI application means the AI must be <strong>secure</strong>, <strong>accurate</strong>, <strong>up-to-date</strong>, and <strong>cost-effective</strong> — all while delivering a great experience to users.</p><p>MuleSoft MCP Bridge helps achieve these goals by securely connecting AI agents to your existing enterprise APIs without disrupting your current governance and security setup.</p><p><strong>1. Strong Security Guardrails</strong> AI agents should only perform actions they are authorized to do.</p><p>Take an AI Shopping Assistant as an example. It should be able to:</p><ul><li>View products</li><li>Check inventory</li><li>Create orders</li><li>Track shipments</li></ul><p>But it must <strong>not</strong> be allowed to:</p><ul><li>Delete customer records</li><li>Cancel payments</li><li>Modify employee data</li></ul><p>With MCP Bridge, you simply select which API operations to expose as tools. Only the chosen operations become available to the AI.</p><p>Every request is still protected by your existing Anypoint Platform policies — including authentication, authorization, rate limiting, and schema validation. This keeps AI usage as secure as any other enterprise application.</p><p><strong>2. Providing Real Context and Reducing Hallucinations</strong> AI models are powerful, but they don’t know your company’s live business data.</p><p><strong>Example:</strong> A customer asks, “How many iPhone 17 devices are available today?”</p><p>Without real data, the AI might guess and give a wrong answer — this is called <strong>hallucination</strong>.</p><p>MCP Bridge solves this problem. The AI calls a tool (e.g., getProducts), which MCP Bridge routes to your actual Products API. The AI receives live inventory data and responds with the correct number.</p><p>By grounding the AI in real enterprise data, you get more accurate and trustworthy answers.</p><p><strong>3. Keeping AI Synchronized with Live Business Data</strong> Business information is constantly changing — new orders are placed, stock levels update, and shipments move.</p><p>If the AI uses old data, customers get incorrect information.</p><p>With MCP Bridge, the AI can directly call your Order API to fetch the latest status. Your existing APIs remain the single source of truth. There is no need to copy or manually sync data into the AI system.</p><p>This ensures responses are always fresh and aligned with real-time business operations.</p><p><strong>4. Real Cost Savings — An E-commerce Example</strong> Imagine an e-commerce company that wants to launch an AI Shopping Assistant for its customers.</p><p><strong>Without MCP Bridge:</strong> The company would need to spend a lot of time and money. Developers would have to write special code for every API, test everything, and keep updating it whenever anything changes. This is slow and expensive.</p><p><strong>With MCP Bridge:</strong> The team configures the bridge once in a simple way — no heavy coding needed. Their existing APIs become ready for AI almost immediately.</p><p><strong>How this saves money for the company (and benefits customers):</strong></p><ul><li>Saves huge development costs and time (hours instead of months)</li><li>Reduces ongoing maintenance because existing APIs are reused without changes</li><li>Lowers running costs by allowing only necessary actions and using smart rules to avoid waste</li><li>Helps launch the AI assistant much faster, so customers can enjoy better service sooner</li></ul><p>In short, the company spends less money while giving customers a faster, smarter, and more helpful AI shopping experience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sn-UbgIhQggfo77ZJ6ldEA.png" /></figure><p><strong>Why This Matters</strong> MCP Bridge is more than just a technical connector. It gives you the foundation to build enterprise-ready AI applications that are:</p><ul><li><strong>Secure</strong> — thanks to controlled access and strong policies</li><li><strong>Accurate</strong> — by using real business context instead of guesses</li><li><strong>Up-to-date</strong> — by connecting directly to live systems</li><li><strong>Cost-effective</strong> — through smart reuse and efficient resource usage</li></ul><p>With MCP Bridge, organizations can confidently adopt AI while maintaining security, reliability, and operational efficiency.</p><ul><li>Optimized cost vs. performance trade-offs</li></ul><p>With these enterprise-ready features, organizations can confidently deploy AI agents that are intelligent, secure, and aligned with business needs.</p><h3>Step-by-Step Configuration of MCP Bridge</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3GosmE3I1fOmppNfLe0rsQ.png" /></figure><h3>Step 1: Publish APIs to Exchange</h3><p>Ensure APIs are published to Anypoint Exchange.</p><p>Examples:</p><ul><li>Products API</li><li>Orders API</li></ul><p>The API specification becomes the source of tool metadata.</p><h3>Step 2: Open API Manager</h3><p>Navigate to:</p><pre>API Manager<br>→ Agent &amp; Tool Instances</pre><p>Click:</p><pre>Add</pre><p>and select:</p><pre>MCP Bridge</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hrRMGlirYNGx6LFEBmPMSw.png" /></figure><h3>Step 3: Select Omni Gateway</h3><p>Choose the Omni Gateway where the MCP Bridge will run.</p><p>This gateway becomes the MCP server endpoint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RH9Z56L2_diH9hzp3Y98iQ.png" /></figure><h3>Step 4: Select APIs</h3><p>Choose the APIs you want to expose.</p><p>Example:</p><ul><li>Employee API</li><li>Orders API</li></ul><p>Provide the implementation URLs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ssM2Ig2DccDBPCt4w0Xveg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7LLplBM01fXulOhTZ1iRKQ.png" /></figure><h3>Step 5: Configure MCP Tools</h3><p>Select Upstream url, choose an existing url from the list and proceed further.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WLy5dWiTp-VfotZ4aqwKYw.png" /></figure><p>Select the API operations that you want to expose as MCP tools by enabling the corresponding toggle. You can enable one or multiple API operations based on your business requirements. The tool name and description are automatically generated from the API specification, making the exposed MCP tools easy to understand and use.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SJcPktqU2wI6F_3RjYIcjA.png" /></figure><h3>Step 6: Automatic Schema Generation</h3><p>MCP Bridge automatically generates:</p><ul><li>Tool names</li><li>Tool descriptions</li><li>Input schemas</li><li>Output schemas</li></ul><p>using API specifications from Exchange.</p><p>This eliminates duplicate work.</p><h3>Step 7: Review and Deploy</h3><p>Review the configuration and deploy.</p><p>MuleSoft generates:</p><ul><li>MCP Bridge Asset</li><li>Consumer Endpoint</li><li>Tool Definitions</li></ul><h3>Step 8: Test with an MCP Client</h3><p>Connect:</p><ul><li>Claude</li><li>Cursor</li><li>Agentforce</li><li>Any MCP-compatible client</li></ul><p>Verify tool discovery and execution.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-nWWSkmBs_t1iRnxIuMiCQ.png" /></figure><h3>Enterprise Benefits of MCP Bridge</h3><blockquote>Faster Implementation</blockquote><p>MCP Bridge significantly reduces implementation time by converting existing REST APIs into AI-ready tools within minutes, enabling organizations to accelerate AI adoption without extensive development.</p><blockquote>No Code Changes</blockquote><p>Existing applications remain unchanged. MCP Bridge reuses your current APIs, eliminating the need to modify business logic or build separate AI-specific services.</p><blockquote>Centralized Governance</blockquote><p>All existing API security and governance capabilities — including authentication, authorization, policies, and monitoring — are automatically inherited, ensuring consistent enterprise-grade security.</p><blockquote>Improved Scalability</blockquote><p>A single MCP server can expose multiple APIs, allowing organizations to manage and scale hundreds of enterprise APIs through a standardized approach.</p><blockquote>Better Observability</blockquote><p>Since MCP Bridge is built on the Anypoint Platform, administrators can monitor API requests, response times, errors, and validation failures using Anypoint Monitoring.</p><h3>Real-World Use Cases</h3><p>MCP Bridge enables AI assistants to interact securely with enterprise APIs across multiple business domains. Common use cases include AI-powered e-commerce assistants that search products and place orders, customer service agents that retrieve customer information, finance assistants that validate invoices and reconcile transactions, supply chain solutions that monitor inventory and trigger replenishment, and internal employee assistants that securely access HR, payroll, and ticketing systems.</p><h3>Best Practices</h3><p>Maintain accurate API specifications, as the generated MCP tools rely on the API schema for tool names, descriptions, and parameters. Expose only the operations required by AI clients to minimize security risks. Start with read-only operations before enabling create, update, or delete endpoints. Finally, apply standard API security policies such as authentication, rate limiting, and schema validation to ensure secure and reliable AI interactions.</p><h3>Monitor Agent Activity</h3><p>Track usage patterns and errors through Anypoint Analytics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cQ-oFtGkZJbJAvt_2Em2rw.png" /></figure><h3>Conclusion</h3><p>Organizations already have the APIs required to power AI-driven experiences.</p><p>The challenge is making those APIs accessible to AI agents in a secure, scalable, and governed manner.</p><p>MuleSoft MCP Bridge solves this challenge by transforming existing APIs into MCP-compatible tools through configuration rather than development.</p><p>Instead of rewriting applications or building separate MCP implementations, organizations can leverage existing APIs, existing governance, and existing infrastructure to accelerate their AI journey.</p><p>As AI agents become a core part of enterprise architecture, MCP Bridge provides one of the fastest and most practical ways to connect AI with real business capabilities.</p><p><strong>Your APIs already contain the business logic. MCP Bridge simply makes that logic available to AI agents.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94b00a458127" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/mulesoft-mcp-bridge-the-fastest-way-to-make-your-existing-apis-ai-ready-94b00a458127">MuleSoft MCP Bridge: The Fastest Way to Make Your Existing APIs AI-Ready</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP for MuleSoft Developers: Building AI-Ready Integrations with Model Context Protocol]]></title>
            <link>https://medium.com/another-integration-blog/mcp-for-mulesoft-developers-building-ai-ready-integrations-with-model-context-protocol-353b8b634d39?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/353b8b634d39</guid>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Mon, 08 Jun 2026 11:31:25 GMT</pubDate>
            <atom:updated>2026-06-17T12:57:28.565Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xuAzQCi17es9esdWguGrLA.png" /></figure><h3>What is MCP?</h3><p>Imagine your smartphone has a special <strong>USB-C port</strong>. You can plug in chargers, headphones, power banks, or even connect to your laptop — one port works with almost everything.</p><p><strong>MCP (Model Context Protocol)</strong> is exactly like that <strong>USB-C port</strong> for AI assistants.</p><p>Right now, AI tools like Claude, ChatGPT, or Gemini are smart but “blind” — they can’t easily reach into your company’s systems (Salesforce, SAP, databases, etc.) to do real work like booking appointments or checking orders.</p><p>MCP solves this by creating <strong>one standard way</strong> for any AI to connect safely to business tools.</p><h3><strong>The Main Parts</strong></h3><ul><li><strong>MCP Host</strong>: The AI app you talk to (like Claude or ChatGPT).</li><li><strong>MCP Client</strong>: The helper inside the AI that talks to the outside world.</li><li><strong>MCP Server</strong>: The “middleman” that knows how to talk to your company’s systems. <br> →<strong> This is what we build in MuleSoft.</strong><br> → <strong>Tools</strong>: Simple actions the AI can do, like “book_appointment” or “check_order_status”.</li></ul><h3>The Perfect Analogy: Three Friends at a Hotel</h3><p>Imagine <strong>three friends</strong> traveling together:</p><ul><li>One speaks only <strong>English</strong></li><li>One speaks only <strong>Japanese</strong></li><li>One speaks only <strong>Chinese</strong></li></ul><p>They arrive at a hotel and all want the same thing — to <strong>book a room</strong>.</p><p>The problem? The hotel staff only speaks their local language. None of the friends can explain what they need. Even though they all want the exact same thing (a room for the night), <strong>communication fails</strong>. No booking happens.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WW965sXC2wwiJaQjs4sYsg.png" /></figure><p>Now, imagine a <strong>professional translator</strong> stands in the middle.</p><ul><li>The English friend tells the translator in English.</li><li>The Japanese friend speaks in Japanese.</li><li>The Chinese friend speaks in Chinese.</li></ul><p>The translator understands all of them. He converts everything into a common language the hotel staff understands, gets the answers, and replies back in each friend’s language.</p><p>Suddenly, everything becomes easy. The room is booked successfully!</p><h3>How MCP Works — Exactly Like This Translator</h3><p><strong>Different AI assistants</strong> (ChatGPT, Claude, Gemini, Copilot, etc.) are like the three friends — each “speaks” in its own way.</p><p><strong>Business systems</strong> (Salesforce, SAP, ServiceNow, databases, etc.) are like the hotel staff — they have their own rules and languages (APIs).</p><p>Without MCP, every AI needs its own custom “phrasebook” to talk to every system. This creates confusion, lots of work, and many mistakes.</p><p><strong>MCP (Model Context Protocol)</strong> is the <strong>universal translator</strong>.</p><p>It sits in the middle and makes communication smooth. The AI talks to the <strong>MCP Server</strong> in a standard way. The MCP Server understands the request, translates it into something the business system (like Salesforce or SAP) understands, does the work, and sends the result back clearly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D-0QSZqjlyoUxDntfROcbg.png" /></figure><p><strong>In one simple sentence:</strong> <strong>MCP is like a universal translator that allows different AI assistants and business systems to understand each other and work together seamlessly.</strong></p><p>This is why MCP is a game-changer — it removes the language barriers between smart AI tools and the real business systems where work actually gets done.</p><h3><strong>Real-Life Example:</strong> Hospital Appointment</h3><p>You tell the AI: <strong>”Book me an appointment with Dr. Kumar tomorrow at 10 AM.</strong>”</p><p><strong>Without MCP</strong> → The AI gets confused and can’t do anything. <br><strong>With MCP + MuleSoft</strong> → The AI finds the hospital’s MCP Server, uses the “book_appointment” tool, and gets it done safely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u3IfqwaGbObiK4Quw_n2nQ.png" /></figure><h3>How to Create an MCP Server in MuleSoft — Step-by-Step (Beginner Friendly)</h3><p>Think of <strong>MuleSoft</strong> as the expert builder that already connects all your company’s different apps safely and reliably. Now we’ll turn one of those connections into an <strong>MCP Server</strong>, so any AI can use it easily — just like adding the translator to the hotel.</p><h4>Prerequisites (What You Need)</h4><p>Here’s everything you need to get started, explained simply:</p><ol><li><strong>Anypoint Studio (or Anypoint Code Builder)</strong></li></ol><ul><li>This is the main tool (like a coding workshop) where you build MuleSoft applications.</li><li>Download and install the <strong>latest version</strong> (recommended: 7.21 or newer as of 2026).</li><li>You can get it from the official MuleSoft website (free for developers).</li><li><strong>Tip for beginners</strong>: If you’re on Windows, extract it directly to C:\AnypointStudio folder for smooth installation.</li></ul><p><strong>2. Java 17</strong></p><ul><li>MuleSoft now requires <strong>Java 17</strong> (OpenJDK 17 is recommended).</li><li>Download from Adoptium or Temurin.</li><li>Set up the JAVA_HOME environment variable so your computer knows where Java is installed.</li><li>This is important because MCP Connector works with modern Java.</li></ul><p><strong>3. Apache Maven</strong></p><ul><li>Maven is a tool that automatically downloads the libraries (like the MCP Connector) your project needs.</li><li>Download the latest version and set up MAVEN_HOME environment variable.</li><li>Most people already have this if they use Anypoint Studio.</li></ul><p><strong>4. Mule Runtime 4.9.3 or newer</strong></p><ul><li>This is the “<strong>engine</strong>” that runs your MuleSoft apps.</li><li>The MCP Connector works best with newer runtime versions.</li></ul><p><strong>5. Anypoint Platform Account</strong></p><ul><li>Sign up for a free trial or use your company account at <a href="https://anypoint.mulesoft.com/">anypoint.mulesoft.com</a>.</li><li>You need this to access <strong>Anypoint Exchange</strong> (the store where you download the MCP Connector) and to deploy your app to the cloud later.</li></ul><p><strong>6. MCP Connector</strong></p><ul><li>This is the special plugin that adds MCP features to MuleSoft.</li><li>You’ll download it from Anypoint Exchange inside Studio (we’ll cover this in Step 2).</li></ul><p><strong>7. Basic Setup Checks</strong></p><ul><li>Make sure your computer has enough memory (at least 8GB RAM recommended).</li></ul><blockquote>For Studio users: Add -Dmule.http.service.implementation=NETTY to your AnypointStudio.ini file for better performance.</blockquote><ul><li>Have a backend system ready to connect to (e.g., a simple database or Salesforce) for testing.</li></ul><p><strong>Don’t worry if this feels overwhelming!</strong> You can start with just Anypoint Studio + Java 17. The rest becomes clear as you follow the steps.</p><h3><strong>Step-by-Step Guide</strong></h3><p><strong>Step 1: Create a New MuleSoft Project</strong><br>- Open Anypoint Studio. <br>- Go to <strong>File → New → Mule Project</strong>. <br>- Give it a name like `Hospital-Appointment-MCP`. <br>- Click Finish.</p><p><strong>Step 2: Add the MCP Connector</strong><br>- In your project, go to the <strong>pom.xml</strong> file (or use the UI to add dependencies). <br>- Search for ”<strong>MCP Connector</strong>” in Anypoint Exchange and add the latest version (e.g., 1.x). <br> This is like installing a special plugin.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ka29RCSmvzqTDdbamlGZYA.png" /></figure><p><strong>Step 3: Create the MCP Server Configuration</strong><br>- You need an <strong>HTTP Listener</strong> first (normal web connection).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FK8njUje2TOAUT4l2qTX_A.png" /></figure><p>- Then create an <strong>MCP Server Config</strong>: <br> — Name it something like `<strong>MyHospitalMCPServer</strong>`. <br> — Choose <strong>Streamable HTTP</strong> (best for companies — works over the internet). <br> — Set a path like `/sse` (this is where AI will connect). <br> — Give your server a name and version (e.g., “Hospital Appointments” v1.0).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yDdDw6n8l6w7tzfduwyDJA.png" /></figure><p><strong>Step 4: Create a Tool (The Action AI Will Use)</strong><br>- Create a new flow in your Mule app. <br>- Instead of a normal HTTP Listener, drag the <strong>MCP Tool Listener</strong> as the source. <br>- Configure it: <br> — Choose your MCP Server config from Step 3. <br> — Give the tool a clear name, e.g., `book_appointment`. <br> — Describe what it does (so AI understands): “Books a doctor appointment with patient details and time.” <br> — Define inputs (like patient name, doctor name, date, time).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T1OfgQp3M5P4Sip91714DA.png" /></figure><p><strong>Step 5: Add the Actual Business Logic </strong><br>- After the Tool Listener, add your normal MuleSoft steps: <br> — Connect to database. <br> — Check doctor availability. <br> — Save the appointment. <br> — Return a success message with appointment ID.</p><p>(This part works just like any other MuleSoft API you’ve built.)</p><p><strong>Step 6: Secure It</strong><br>- Add security policies (like OAuth or API keys) using Anypoint Platform. <br>- Use Flex Gateway if possible for extra protection (controls who can use the AI tools).</p><p><strong>Step 7: Test It</strong><br>- Run the app locally. <br>- Use tools like<strong> MCP Inspector</strong> or connect directly from Claude Desktop / Cursor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QEDycK7aoiJHxzbRlyWlPw.png" /></figure><p>- Type something like: “Book appointment for John with Dr. Kumar tomorrow.” <br>- Watch the AI use your new tool!</p><p><strong>Step 8: Deploy to Cloud</strong><br>- Deploy to CloudHub or Runtime Fabric. <br>- Share the MCP Server URL with your team’s AI tools. <br>- Now any compatible AI can use it!</p><h3>What Happens Behind the Scenes (Simple Analogy)</h3><ol><li>User talks to AI (Claude). <br>2. AI says: “I need to book an appointment.” <br>3. AI’s Client connects to your MuleSoft MCP Server. <br>4. MCP Server says: “Here’s the `book_appointment` tool.” <br>5. AI calls the tool → MuleSoft does the real work safely → Result comes back.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JwSWub8P443_-4GDzYf_UQ.png" /></figure><h3>Why This is Great for Companies</h3><ul><li>Build the integration <strong>once</strong> in MuleSoft. <br>- Any AI (Claude, ChatGPT, custom agents) can use it. <br>- Full security, monitoring, and control (thanks to MuleSoft). <br>- No need to build separate connections for every AI.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_b5kU7cFRcyFMovNttWfZw.png" /></figure><p><strong>Quick Tips for Beginners</strong><br>- Start small — make one simple tool first (e.g., “get available slots”).<br>- Use MuleSoft’s examples from their documentation.<br>- For even easier creation, some tools like CurieTech AI can help generate the MCP code automatically.<br>- Always test with proper permissions — security is very important.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=353b8b634d39" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/mcp-for-mulesoft-developers-building-ai-ready-integrations-with-model-context-protocol-353b8b634d39">MCP for MuleSoft Developers: Building AI-Ready Integrations with Model Context Protocol</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MuleSoft Intelligent Document Processing (IDP): A Complete Beginner-Friendly Guide to AI-Powered…]]></title>
            <link>https://medium.com/another-integration-blog/mulesoft-intelligent-document-processing-idp-a-complete-beginner-friendly-guide-to-ai-powered-7f8ba3bcbf04?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f8ba3bcbf04</guid>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[einstein]]></category>
            <category><![CDATA[idp]]></category>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 10:10:29 GMT</pubDate>
            <atom:updated>2026-06-10T06:35:50.003Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>MuleSoft Intelligent Document Processing (IDP): A Complete Beginner-Friendly Guide to AI-Powered Document Automation</strong></h3><p>In today’s digital businesses, teams still waste countless hours manually reading invoices, contracts, claims, and other documents. This process is slow, expensive, and filled with human errors. <strong>MuleSoft Intelligent Document Processing (IDP)</strong> changes that by using powerful AI to automatically read, understand, extract, and structure data from documents — turning messy files into clean, actionable JSON that integrates seamlessly with your systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tj8v5THCKiC40BF8NsDnNA.png" /></figure><p>This in-depth guide is written especially for beginners. You’ll learn concepts clearly, follow step-by-step instructions, understand real API usage with full explanations, and discover how to solve common problems confidently.</p><h3><strong>What is MuleSoft IDP and Why Does It Matter?</strong></h3><p>MuleSoft IDP is a <strong>cloud-native AI service</strong> within Anypoint Platform. It combines:</p><p>- <strong>AWS Textract</strong> for precise text, table, and key-value extraction.</p><p>- <strong>Salesforce Einstein AI models</strong> (like GPT-4o and Gemini) for deep contextual understanding, reasoning, and handling unstructured or handwritten content.</p><p>The result? You upload a document and get structured data back — ready for automation.</p><p><strong>Real Business Impact:</strong></p><p>- Reduce manual data entry by 70–90%.</p><p>- Process documents 24/7.</p><p>- Improve data accuracy with confidence scoring.</p><p>- Scale without hiring more staff.</p><h3><strong>How MuleSoft IDP Works (Simple Flow)</strong></h3><p>1. <strong>Upload Document</strong> → PDF, PNG, or JPEG.</p><p>2. <strong>AI Processing</strong> → Multiple models analyze layout, text, and meaning.</p><p>3. <strong>Extraction</strong> → Key fields pulled with confidence scores.</p><p>4. <strong>Review (if needed)</strong> → Low-confidence items go to humans.</p><p>5. <strong>Structured Output</strong> → JSON for downstream systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BetCKUTzmHOJ5ZannTE5cQ.png" /></figure><p><strong>Step-by-Step: Building Your First Document Action</strong></p><p><strong>Step 1: Access IDP in Anypoint Platform</strong></p><ul><li>Log in to Anypoint Platform.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*HI2g38YMSskxxhR8kRQlwA.png" /></figure><ul><li>Go to <strong>Automation</strong> → <strong>Intelligent Document Processing</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*Hj2V_JYdBA9Klmr6WfcvFQ.png" /></figure><ul><li>Click <strong>Create New Document Action</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*eVU75LV2zcwFeHybMjyFeg.png" /></figure><p><strong>Step 2: Configure Document Action (Detailed)</strong></p><p>- <strong>Name &amp; Description</strong>: Use meaningful names like `Finance_Invoice_Processing_v1`.</p><p><strong>-Document Types</strong>: Choose or define (Invoice, PO, Contract, etc.).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x82rDYn1bvOMvq4_hxRExg.png" /></figure><p>- <strong>Fields to Extract</strong>:</p><p>- Add fields like `invoiceNumber`, `totalAmount`, `vendorName`, `dueDate`, `lineItems` (table).</p><ul><li>For each field: Set type, mark required, set min confidence (start at 80%), and add prompts.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*g7s8pegRl3MQl81b77b-eQ.png" /></figure><p><strong>- Natural Language Prompts (Key to Accuracy):</strong></p><p>- “Calculate grand total including taxes and discounts.”</p><p>- “Extract all line items as an array with description, qty, unit_price, and line_total.”</p><ul><li><strong>AI Model Selection</strong>: Start with Einstein GPT-5.2.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*k5z_A8fzH3gaaAInyIhUMA.png" /></figure><ul><li><strong>Reviewers</strong>: Add people for manual validation.</li></ul><p>- Test with samples → Publish to Anypoint Exchange.</p><h3><strong>Using IDP via APIs: What Each cURL Does &amp; When to Use It</strong></h3><p>Once published, your Document Action becomes a secure REST API. Here’s what each command does, with practical explanations.</p><p>1. Generate Bearer Token (Authentication)</p><p>This is the foundation — you need a valid token for every IDP API call.</p><pre>curl -X POST \<br>  -H &quot;Content-Type: application/json&quot; \<br>  -d &#39;{<br>    &quot;grant_type&quot;: &quot;client_credentials&quot;,<br>    &quot;client_id&quot;: &quot;YOUR_CLIENT_ID&quot;,<br>    &quot;client_secret&quot;: &quot;YOUR_CLIENT_SECRET&quot;<br>  }&#39; \<br>  https://anypoint.mulesoft.com/accounts/api/v2/oauth2/token</pre><p><strong>What it does:</strong> Exchanges your Connected App credentials for a temporary access token.</p><p><strong>When to use:</strong> Every time you call IDP (tokens expire, usually in 1 hour).</p><p><strong>Best Practice:</strong> Store securely (use environment variables or secrets manager). Regenerate automatically in production.</p><p><strong>2. POST /executions — Submit a Document for Processing</strong></p><p>This is the <strong>main execution endpoint</strong> — where you send documents to IDP.</p><pre>curl -H &quot;authorization: Bearer &lt;Bearer_token&gt;&quot; \<br>  -F &quot;file=@\&quot;Invoice.pdf\&quot;&quot; \<br>  https://{idp_domain}.us-east-1.anypoint.mulesoft.com/api/v1/organizations/{organizationId}/actions/{documentActionId}/versions/{assetVersion}/executions</pre><p><strong>What it does:</strong> Uploads the file + optional metadata and starts AI processing. Returns an `executionId`.</p><p><strong>When to use:</strong> In automated workflows (e.g., email attachment → IDP → ERP).</p><p><strong>Response:</strong> Usually contains `executionId` and initial status.</p><p><strong>3. GET /executions/{executionId} — Check Status &amp; Retrieve Results</strong></p><p>This <strong>polling endpoint</strong> lets you get processing results.</p><pre>curl -X GET \<br>  -H &quot;Authorization: Bearer YOUR_ACCESS_TOKEN&quot; \<br>  https://{your-idp-domain}.us-east-1.anypoint.mulesoft.com/api/v1/organizations/{orgId}/actions/{documentActionId}/versions/{version}/executions/{executionId}</pre><p><strong>What it does:</strong> Returns status (`SUCCESS`, `MANUAL_REVIEW_REQUIRED`, `FAILED`) and the full extracted JSON data.</p><p><strong>When to use: </strong>After POST to check if processing is complete and fetch results.</p><p><strong>Tip:</strong> In production, use webhooks/callbacks instead of polling for better efficiency.</p><h3><strong>Troubleshooting &amp; Handling Common IDP Issues (Very Important for Beginners)</strong></h3><p>Even with good setup, issues can arise. Here’s how to diagnose and fix them:</p><p><strong>1. Low Extraction Accuracy / Missing Fields</strong></p><p><strong>- Cause: </strong>Poor prompts, bad document quality, or wrong model.</p><p><strong>- Solutions:</strong></p><p>- Improve prompts with more specific language.</p><p>- Switch to Gemini models for scanned/image-heavy docs.</p><p>- Use higher-quality samples for testing.</p><p>- Lower confidence threshold temporarily for testing.</p><p><strong>2. Authentication / Token Errors (401 Unauthorized)</strong></p><p><strong>- Cause:</strong> Expired token or wrong Connected App scope.</p><p><strong>- Solutions:</strong></p><p>- Regenerate token.</p><p>- Ensure scope is “Execute Document Actions”.</p><p>- Check organization ID and region.</p><p><strong>3. File Upload Failures (Large Files or Unsupported Format)</strong></p><p><strong>- Cause:</strong> File too big or wrong format.</p><p><strong>- Solutions:</strong> Compress PDFs, split multi-page documents, or convert to supported formats (PDF/PNG/JPEG).</p><p><strong>4. High Manual Review Volume</strong></p><p><strong>- Cause:</strong> Confidence thresholds too high or complex documents.</p><p><strong>- Solutions:</strong> Adjust thresholds, improve prompts, or train reviewers.</p><p><strong>5. Processing Timeout or Slow Performance</strong></p><p><strong>- Cause: </strong>Complex documents or high load.</p><p><strong>- Solutions: </strong>Use faster models (GPT-4o Mini), process one page at a time, or implement async patterns with callbacks.</p><p><strong>6. Data Retention / Privacy Concerns</strong></p><p><strong>- Remember:</strong> Data is automatically deleted after 7 days (successful) or 60 days (incomplete). Design flows accordingly.</p><p><strong>General Tip: </strong>Always implement error handling in your Mule flows (Try scope, logging, retry mechanisms) and monitor via Anypoint Monitoring.</p><h3><strong>Best Practices for Long-Term Success</strong></h3><p>- Start with simple, high-volume documents.</p><p>- Version your Document Actions.</p><p>- Combine IDP with MuleSoft RPA or Flows for end-to-end automation.</p><p>- Regularly review extraction accuracy metrics.</p><p>- Secure everything with proper Connected Apps and policies.</p><h3><strong>Conclusion</strong></h3><p>MuleSoft IDP is a transformative tool that brings real AI intelligence to your document workflows. By following this guide, understanding the APIs, and knowing how to troubleshoot, you can confidently automate document processing and deliver fast, accurate results to your business.</p><p><strong>Your Action Plan :</strong></p><p>1. Create and publish your first Document Action.</p><p>2. Test the full API flow using the cURL examples.</p><p>3. Integrate with a simple Mule application.</p><p>4. Track time and error reduction.</p><p>What’s the first document type you plan to automate? Share your experience or challenges in the comments — I’d love to help!</p><h3><strong>Resources &amp; Further Reading</strong></h3><p><strong>1. Official MuleSoft IDP Documentation </strong>—(<a href="https://docs.mulesoft.com/idp/">IDP Overview | MuleSoft Documentation</a>)</p><p><strong>2. Automate with IDP API</strong> — (<a href="https://docs.mulesoft.com/idp/automate-document-processing-with-the-idp-api">Processing Documents and Retrieving Results With the API | MuleSoft Documentation</a>)</p><p><strong>3. Best Practices &amp; Optimization</strong> —(<a href="https://docs.mulesoft.com/idp/best-practices-and-optimization">Best Practices and Optimization | MuleSoft Documentation</a>)</p><p><strong>4. Trailhead Module </strong>— (<a href="https://trailhead.salesforce.com/content/learn/modules/mulesoft-idp-basics">MuleSoft Intelligent Document Processing Overview</a>)</p><p><strong>5. Product Page</strong> —(<a href="https://www.mulesoft.com/platform/intelligent-document-processing">Intelligent Document Processing (IDP) Software | Mulesoft</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f8ba3bcbf04" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/mulesoft-intelligent-document-processing-idp-a-complete-beginner-friendly-guide-to-ai-powered-7f8ba3bcbf04">MuleSoft Intelligent Document Processing (IDP): A Complete Beginner-Friendly Guide to AI-Powered…</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MuleSoft Delivers. Informatica Prepares. The Enterprise Wins.]]></title>
            <link>https://medium.com/another-integration-blog/informatica-cleans-data-mulesoft-makes-it-real-time-bd3fafaafe7b?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/bd3fafaafe7b</guid>
            <category><![CDATA[informatica]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[integration]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mulesoft]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 05:59:40 GMT</pubDate>
            <atom:updated>2026-05-07T04:56:07.325Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>A beginner-friendly guide to understanding two of the most important tools in modern enterprise technology</em></h4><h3>Let’s start with a real problem you’ve probably seen</h3><p>Imagine you work at a bank. A customer calls in — frustrated, on hold for ten minutes already.</p><p>Your support agent opens five different screens. One system shows the customer’s name as “Vijay Kumar.” Another says “V. Kumar.” A third has a Hyderabad address that’s three years old. The agent doesn’t know which one to trust. They ask the customer to repeat their details. The customer gets even more frustrated. The call ends badly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9i9jTP5fZl2VDL4brtsqhg.png" /></figure><p>Now multiply that problem across thousands of customers, dozens of systems, and hundreds of agents.</p><p>That’s the reality inside most large companies today. Data exists everywhere — but nobody fully trusts it. Systems exist everywhere — but they don’t talk to each other in real time.</p><p>Two tools exist specifically to fix this. And when you understand what each one does, you’ll see why neither one is enough on its own.</p><h3><strong>Meet the two tools: Informatica and MuleSoft</strong></h3><p>Before we go deep, here’s the simplest summary possible:</p><p>Informatica is the platform that makes your enterprise data clean, correct, and trustworthy.</p><p><strong>MuleSoft</strong> is the platform that connects everything, moves that trusted data instantly across every system and application, and powers every real-time experience the business delivers.</p><p>Think of it like a world-class restaurant:</p><p>Informatica is the master chef — sourcing the finest ingredients, removing anything that doesn’t meet the standard, and preparing everything to perfection before it leaves the kitchen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sDfjjJGqM-Rv-VW6lcinlA.png" /></figure><p>MuleSoft is the exceptional front-of-house — knowing exactly where every dish needs to go, delivering it to the right table at the right moment, and making sure every guest has an experience worth remembering. A great restaurant is only as good as what the guest receives. And what the guest receives is entirely MuleSoft’s domain.</p><p>Together they are unstoppable. But here is the truth every developer and architect in the MuleSoft community already understands — the business feels MuleSoft. Every connected app, every real-time dashboard, every AI-powered workflow, every personalised customer moment — all of it flows through MuleSoft. Informatica builds the foundation. MuleSoft builds the experience. And in the modern enterprise, experience is everything.</p><h3>What is Informatica? (In plain English)</h3><p>Informatica is a data management platform. Its job is to be the single source of truth for your company’s data.</p><p>Here’s what it actually does, step by step:</p><p><strong>Step 1 — It collects data from everywhere.</strong> Your CRM has customer records. Your billing system has more. Your support ticketing tool has more. They all have slightly different versions of the same customer. Informatica pulls all of these together.</p><p><strong>Step 2 — It cleans the mess.</strong> It finds duplicates (“Rahul Sharma” and “R. Sharma” are the same person). It fixes formatting issues. It flags records that look suspicious or outdated. It fills in missing fields where it can.</p><p><strong>Step 3 — It creates one golden record.</strong> After cleaning, it builds a single master version of each customer (or product, or vendor). This is called the <strong>golden record</strong> — one source of truth that every system in your company can trust.</p><p><strong>Step 4 — It keeps track of everything.</strong> Informatica also records where data came from and how it changed over time. This is called <strong>data lineage</strong>, and it’s critical for audits, compliance, and understanding your AI’s behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ccTjlUDHu7PGP9jtk_RCjA.png" /></figure><blockquote><strong>Where Informatica is less optimised</strong>: while Informatica core strength lies in batch ETL processing, master data management, and data quality governance. For high-frequency, event-driven, API-driven integration between live apps and services, <strong>MuleSoft</strong> is purpose-built for that workload and typically the better architectural choice.</blockquote><h3><strong>What is MuleSoft? (In plain English)</strong></h3><p>MuleSoft is the integration and API platform that powers the connected enterprise. It connects everything — systems, apps, databases, partners, devices, and AI — and moves data between them instantly, reliably, and at scale.</p><p>Here is what makes MuleSoft extraordinary:</p><p><strong>It builds and manages APIs at enterprise scale.</strong> An API is the door between two systems — and MuleSoft builds, secures, and governs those doors across the entire enterprise. <em>“Hey Salesforce, give me Vijay Kumar K’s latest order.”</em> MuleSoft handles that request cleanly, securely, and in milliseconds — every single time, across thousands of simultaneous connections.</p><p><strong>It connects systems that were never designed to talk.</strong> SAP built in 2008. A modern e-commerce platform launched last year. A cloud CRM added six months ago. They speak completely different languages — but MuleSoft speaks all of them. It bridges every generation of enterprise technology into one seamless, connected architecture.</p><p><strong>It triggers real-time actions across the entire enterprise simultaneously.</strong> The moment Vijay Kumar K places an order, MuleSoft fires across every system at once — updating inventory, notifying the warehouse, sending a confirmation email, logging the event in Salesforce, and feeding the AI assistant the latest context — all in under a second. One event. Every system. Instant.</p><p><strong>It is the delivery layer that makes data valuable.</strong> Data only creates impact when it reaches the right system, the right person, and the right AI at the right moment. MuleSoft is that delivery engine — fast, auditable, and built to scale with the most demanding enterprise environments in the world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F8GyJWhw0hME6CsdbvshYQ.png" /></figure><p>MuleSoft is the platform the entire business runs on and experiences every single day. When a Salesforce agent pulls up a complete customer profile the moment a call connects — that is MuleSoft. When a mobile app delivers real-time account updates after every transaction — that is MuleSoft. When a chatbot answers instantly with accurate, personalised information — that is MuleSoft. When a dashboard refreshes live as business events unfold, when an automation workflow fires the moment a trigger is hit, when an AI assistant surfaces the right insight at exactly the right moment — that is MuleSoft. Every experience the business delivers, every system it depends on, and every intelligent workflow it runs flows through MuleSoft. It is not just an integration platform — it is the connective heartbeat of the modern enterprise.</p><h3>Why MuleSoft is the engine that makes it all visible</h3><p>Here’s something that often gets overlooked by beginners.</p><p>Informatica does its best work quietly, in the background. It runs nightly jobs, cleans records, builds golden masters. Most business users will never see Informatica directly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UDOLYtdjm1E06OVmcMp1Ag.png" /></figure><p>MuleSoft is what they <em>do</em> see — or rather, what powers what they see.</p><p>When a sales rep’s screen shows a complete customer profile the moment a call comes in — that’s MuleSoft.</p><p>When an e-commerce site instantly confirms your order and updates stock availability — that’s MuleSoft.</p><p>When your bank’s app shows real-time balance after a transaction — that’s MuleSoft.</p><p>MuleSoft is the connective tissue of modern enterprise IT. It’s the platform that turns data into experiences. And that’s exactly why it has become one of the most in-demand skills in enterprise architecture.</p><h3><strong>How they work together: three real-world examples</strong></h3><p><strong>Example 1 — The bank support call (Customer 360)</strong></p><p>Vijay Kumar K calls his bank. He’s been on hold for ten minutes and needs answers fast.</p><p><strong>Without MuleSoft + Informatica:</strong> The agent searches five different systems. Every screen tells a different story — one says “Vijay Kumar K”, another says “V. Kumar”, a third shows an address from three years ago. The agent asks Vijay to confirm details all over again. The call drags to twelve minutes. Vijay hangs up frustrated. First-call resolution: failed.</p><p><strong>With MuleSoft + Informatica:</strong> Informatica works quietly in the background — merging all versions of Vijay’s record across every system, verifying his address, consolidating his full account history into one clean, complete golden record.</p><p>The moment Vijay’s call connects, MuleSoft fires. Its API instantly pulls that golden record and delivers it to the agent’s screen in under two seconds — correct name, verified address, full loan history, every past interaction, every open ticket.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jn_cO18KvSAW454pTsdniQ.png" /></figure><p>The agent doesn’t search. They don’t ask. They already know everything.</p><p><em>“Hi Vijay Kumar K, I can see your recent home loan application — let me help you with that right away.”</em></p><p>Call resolved in three minutes. Vijay feels valued. MuleSoft is what made that moment real-time.</p><p>This is called <strong>Customer 360</strong>, and MuleSoft is what makes it real-time.</p><h3><strong>Example 2 — Abandoned shopping cart</strong></h3><p>Vijay Kumar K browses an online store, adds a pair of shoes to his cart, and closes the tab. He never checked out.</p><p><strong>With MuleSoft + Informatica:</strong> Informatica has already built a rich, complete profile for Vijay — his purchase history, preferred brands, loyalty tier, and past engagement patterns. Everything is clean, verified, and ready.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PTc75id2uJ2iE5IdRugROA.png" /></figure><p>The moment Vijay’s cart is abandoned, MuleSoft acts. It detects the event instantly, reads Vijay’s verified profile, crafts a personalised offer — <em>“Vijay, your cart is waiting — here’s 10% off”</em> — and fires it to his inbox within 60 seconds. When Vijay calls support the next morning, MuleSoft has already surfaced his abandoned cart, his profile, and his purchase history on the agent’s screen before the conversation even begins.</p><p>The result: a recovered sale, a personalised experience, and a customer who feels understood. MuleSoft turned Vijay’s verified profile into a real-time, revenue-generating moment the instant it mattered.</p><h3><strong>Example 3 — AI assistant in sales (the 2025/2026 challenge)</strong></h3><p>Vijay Kumar K is live on a video call with a potential enterprise client. An AI assistant is listening and suggesting talking points in real time.</p><p>Without MuleSoft + Informatica: The AI pulls from scattered, disconnected records. It recommends a product the client already rejected six months ago. It references a pricing tier that expired last quarter. Vijay stumbles mid-call. The client loses confidence. The deal is at risk.</p><p>With MuleSoft + Informatica: Informatica has certified the client’s profile — verified that morning, 97% complete, every field trustworthy and audit-ready. MuleSoft delivers that certified profile to the AI live during Vijay’s call — along with active deal history, current contract details, and the client’s most recent support interactions — all in real time, all in one seamless flow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3upFqSLwZl--CAPUMH2-rA.png" /></figure><p>The AI responds instantly: <em>“They purchased a similar solution in 2023. Lead with the enterprise bundle — they’ll respond to the cost savings angle.”</em></p><p>Vijay closes with confidence. The AI gave smart, precise, timely advice — because MuleSoft put the right data in front of it at exactly the right moment.</p><p>This is why MuleSoft is increasingly at the centre of every AI-ready enterprise architecture — and why the developers who master it are building the intelligent, connected enterprises of 2025 and beyond.</p><h3><strong>A simple comparison: what each tool brings</strong></h3><p>Informatica is the foundation of data trust in a modern enterprise. It reaches into every source system — CRMs, billing platforms, support tools, legacy databases — and brings order to the chaos. Duplicate customer records get merged. Inconsistent formats get standardised. Incomplete fields get resolved. What emerges is a single golden record for every customer, product, and vendor — clean, verified, and ready to be acted on. On top of that, Informatica tracks where every piece of data came from and how it changed over time, giving compliance teams the lineage they need and AI systems the reliability they depend on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wcvJ-GwYO4Jvn7hBImdshA.png" /></figure><p>When MuleSoft joins the picture, that trusted data comes alive. MuleSoft connects every system, app, and touchpoint across the enterprise and moves Informatica’s certified data in real time — exactly where it needs to go, exactly when it needs to be there. A support agent sees a complete customer view the moment a call connects. An AI assistant gets a single, verified record to work from. A personalised email fires within seconds of a customer action. A compliance audit has clean, traceable data flowing end to end. Together, Informatica and MuleSoft don’t just make systems work — they make the entire enterprise intelligent, connected, and trustworthy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nK33ASW_K8BNVaD-IuLNXg.png" /></figure><h3><strong>Why MuleSoft specifically is the developer’s platform</strong></h3><p>If you’re reading this on the MuleSoft community, you already know that MuleSoft is more than just a tool — it’s an ecosystem that powers the connected enterprise.</p><p>Anypoint Platform puts everything a developer needs in one place. Design your APIs, build your integrations, test them, deploy them, monitor them, and govern them — all without switching tools. The philosophy is simple but powerful: design once, publish everywhere. One platform. Every system. No friction.</p><p>MuleSoft’s API-led connectivity approach is what separates it from every other integration platform. By structuring integrations across Experience APIs, Process APIs, and System APIs, MuleSoft makes every connection reusable by design. Build a Customer API once, and every team across the enterprise — sales, support, marketing, finance — consumes it instantly. No duplication. No rebuilding the same logic from scratch. Just clean, governed, reusable APIs that scale with the business.</p><p>And as AI moves from experimentation into the core of enterprise operations, MuleSoft is already the platform it runs on. Einstein AI integration, Copilot connectors, and event-driven architecture make MuleSoft the nervous system that AI agents depend on — routing the right data, to the right model, at the right moment. MuleSoft doesn’t just connect systems. It connects intelligence.</p><p>This is the platform that brings it all together. When data is clean, certified, and ready — MuleSoft is what ensures it reaches every AI, every app, every agent, and every customer experience in real time. Not eventually. Right when it matters.</p><h3><strong>So, which one do you learn first?</strong></h3><p>Start with MuleSoft. No hesitation.</p><p>MuleSoft is where enterprise integration becomes real and visible. You’ll design APIs that live systems consume. You’ll build integrations that fire in real time and watch data move across an enterprise the moment you trigger them. You’ll work on the platform that sales teams, support agents, AI assistants, and mobile apps all depend on — every single day. It is hands-on, immediately rewarding, and one of the most in-demand skills in enterprise technology right now.</p><p>MuleSoft also gives you the full picture of how a modern enterprise works. You’ll understand how systems talk to each other, how events trigger workflows, how APIs become the backbone of every digital experience a business delivers. That understanding is rare, valuable, and opens doors across architecture, development, and solution design.</p><p>Once you are comfortable in the MuleSoft world, Informatica becomes a natural next step — not because you need it to use MuleSoft, but because you’ll genuinely appreciate what it brings. You’ll have seen enterprise data up close. You’ll understand why a single trusted record matters. And you’ll see exactly how Informatica strengthens the integrations you’ve already built.</p><p>But the journey starts with MuleSoft — because MuleSoft is where the action is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H5bKHUigpgZQvQTBUaw0hQ.png" /></figure><p>Together, they don’t just make systems talk — they make them trust each other.</p><h3><strong>Summary: the three things to remember</strong></h3><p><strong>1. MuleSoft is the key that unlocks the vault.</strong> Data sitting in systems across an enterprise only becomes valuable when it reaches the right person, the right app, and the right AI — at the right moment. MuleSoft is what makes that happen. It turns stored data into live experiences, real-time decisions, and connected enterprises. Informatica ensures what flows through MuleSoft is clean, trusted, and worth delivering.</p><p><strong>2. MuleSoft at full speed, on trusted data, is unstoppable.</strong> MuleSoft is built for speed, scale, and real-time delivery. When it runs on clean, governed, deduplicated data — data that Informatica has verified and certified — every integration it powers becomes a competitive advantage. Fast delivery on trusted data is what separates good enterprise architecture from great enterprise architecture.</p><p><strong>3. MuleSoft is the platform that makes enterprise AI real.</strong> AI is only as powerful as the data it operates on and the speed at which it receives it. MuleSoft is the platform that delivers verified, certified, real-time data to every AI agent, every model, and every intelligent workflow across the enterprise. Informatica certifies the data. MuleSoft puts it in motion. Together they are the backbone of every trustworthy AI experience in the modern enterprise.</p><p><em>Thanks for reading. If you’re getting started with MuleSoft and want to understand how it fits into the larger enterprise data picture, I hope this gave you a clear map. Drop your questions in the comments — happy to dig deeper into any of these scenarios.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bd3fafaafe7b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/informatica-cleans-data-mulesoft-makes-it-real-time-bd3fafaafe7b">MuleSoft Delivers. Informatica Prepares. The Enterprise Wins.</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unlocking the Power of MuleSoft Intelligent Document Processing (IDP): A Deep Dive into Its…]]></title>
            <link>https://medium.com/another-integration-blog/unlocking-the-power-of-mulesoft-intelligent-document-processing-idp-a-deep-dive-into-its-93351c9df4d6?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/93351c9df4d6</guid>
            <category><![CDATA[idp]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[salesforce]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Wed, 01 Apr 2026 07:35:48 GMT</pubDate>
            <atom:updated>2026-04-01T07:35:48.255Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unlocking the Power of MuleSoft Intelligent Document Processing (IDP): A Deep Dive into Its Functionality, Features, and Real-World Uses</h3><p>In today’s digital-first world, organizations drown in unstructured documents — PDF invoices, scanned purchase orders, handwritten forms, emails, contracts, and more. Manual data entry is slow, error-prone, expensive, and a major bottleneck for finance, HR, procurement, healthcare, and customer service teams. Enter <strong>MuleSoft Intelligent Document Processing (IDP)</strong> — an AI-powered capability built directly into the Anypoint Platform that turns chaotic documents into clean, structured, actionable data with minimal human intervention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X5ZtpMJGHfFchQl-xEwOPw.png" /></figure><p>Launched as a native feature of MuleSoft (and Salesforce), IDP goes far beyond basic OCR. It leverages multimodal large language models (LLMs), natural language prompts, confidence scoring, and human-in-the-loop validation to deliver enterprise-grade automation. Whether you’re running Mule flows, RPA bots, Salesforce Flows, or Agentforce agents, IDP seamlessly integrates into your existing ecosystem — no separate AI subscriptions or complex third-party tools required.</p><p>In this deep-dive blog post, we’ll analyze <strong>what MuleSoft IDP is</strong>, how it works under the hood, its core functionality, powerful use cases, benefits, and a practical getting-started guide. If you’re an integration architect, automation lead, or business leader looking to modernize document-heavy processes, this is for you.</p><h3>What Is MuleSoft IDP? (And Why It’s Not Just Another OCR Tool)</h3><p>MuleSoft IDP is an <strong>AI-driven document intelligence solution</strong> within Anypoint Platform. It enables you to:</p><p>- Ingest documents in virtually any format (PDF, PNG, JPEG, scanned images, etc.).<br>- Classify, extract, analyze, and validate data using advanced AI.<br>- Output structured JSON that flows straight into your business systems.</p><p><strong>Key differentiator from traditional OCR/RPA</strong>: Classic OCR only reads text. IDP uses <strong>multimodal LLMs</strong> (via Salesforce Einstein Trust Layer) to understand context, interpret images + text, perform calculations, summarize, and reason over documents. Models include <strong>OpenAI’s GPT-4o (and Mini) </strong>and <strong>Google’s Gemini 2.0/2.5 Flash </strong>— chosen per document action for optimal accuracy and cost.</p><p>No customer data is used to train the models. Everything stays secure within the Einstein Trust Layer.</p><p><strong>How MuleSoft IDP Works:</strong> The End-to-End Lifecycle</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LXf7nq7b-UW-iCxCr0D_aQ.png" /></figure><h3>Here’s the intelligent process step by step:</h3><ol><li><strong>Document Ingestion</strong> — Upload via UI, API, email, RPA bot, or Mule application.<br>2. <strong>Classification &amp; Scanning </strong>— AI identifies document type (or uses your custom schema).<br>3. <strong>Data Extraction</strong> — Natural language prompts + LLMs pull out fields (e.g., “What is the invoice subtotal after discounts?” or “Extract all line items as a table”).<br>4. <strong>Analysis &amp; Enrichment </strong>— Einstein can perform complex reasoning (totals, validations, fraud flags, summaries).<br>5. <strong>Confidence Scoring </strong>— Every field gets a score (0–100%). You set thresholds.<br>6. <strong>Human-in-the-Loop Review</strong> (optional) — Low-confidence documents route automatically to assigned reviewers or teams.<br>7. <strong>Structured Output</strong>— Clean JSON response, ready for downstream systems.<br>8. <strong>Orchestration</strong> — Trigger Mule flows, Salesforce processes, RPA bots, or Agentforce actions.</li></ol><p>Processing consumes <strong>Automation Credits</strong> (standard for MuleSoft automation features).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ibN0_MDtiEGBZR-Di2W37g.png" /></figure><p>You can filter fields, add prompts like “Calculate tax after deductions,” and customize response schemas. Older actions use earlier GPT-4o versions — new actions unlock the latest models.</p><h3>Real-World Use Cases: Where MuleSoft IDP Delivers Massive ROI</h3><p>MuleSoft IDP shines wherever documents create friction:</p><p>- <strong>Finance &amp; Procurement</strong> → Automate invoice processing, PO matching, three-way matching, expense reconciliation. Reduce days payable outstanding (DPO) and eliminate duplicate payments.<br>- <strong>HR &amp; Employee Onboarding </strong>→ Extract data from resumes, offer letters, tax forms (W-2, PAN, etc.), background checks. Accelerate time-to-productivity.<br>-<strong> Insurance &amp; Claims</strong> → Intake forms, policy documents, medical records. Faster approvals and fraud detection.<br>- <strong>Healthcare &amp; Life Sciences</strong> → Prior authorizations, patient intake forms, prescriptions, lab reports. Improve compliance (HIPAA-ready via Salesforce ecosystem).<br>- <strong>Manufacturing &amp; Supply Chain</strong> → Supplier invoices, bills of lading, quality certificates. Real-time visibility and fewer delays.<br>- C<strong>ustomer Service &amp; Retail</strong> → Quote-to-cash, order capture, returns processing.<br>- <strong>Government &amp; Non-profits </strong>→ Grant applications, compliance forms, citizen onboarding.</p><p><strong>Example Workflow</strong>: An invoice arrives via email → MuleSoft IDP extracts vendor, amount, line items, tax → confidence 92% → auto-posts to SAP/ERP + creates Salesforce record + notifies approver if needed. Entire process: seconds instead of hours.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2bkTFy3JEfF3kzZ2sgO3Pg.png" /></figure><h3>Key Benefits and Why Enterprises Love It</h3><ul><li><strong>Speed &amp; Scale</strong> — Process thousands of documents instantly.<br>- <strong>Accuracy </strong>— AI + human review beats manual entry and basic OCR.<br>- <strong>Cost Savings</strong> — Reduce labor, errors, and outsourced processing.<br>- <strong>Compliance &amp; Governance</strong> — Audit trails, confidence scores, and controlled review workflows.<br>- <strong>Developer-Friendly </strong>— No new platforms; everything lives in Anypoint Exchange and Studio.<br>- <strong>Future-Proof</strong> — Continuous LLM improvements via Einstein; no vendor lock-in for models.<br>- <strong>Ecosystem Power</strong> — Natively connects to 300+ connectors, Agentforce, RPA, and Salesforce.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C8FL5cGdPWSVPImNnxGc4w.png" /></figure><p>Compared to standalone IDP tools (like AWS Textract + custom Lambda or UiPath Document Understanding), MuleSoft IDP wins on integration depth, zero external subscriptions for core processing, and unified governance.</p><h3>Getting Started with MuleSoft IDP (Quick Start Guide)</h3><ol><li>Log into Anypoint Platform → Navigate to<strong> Intelligent Document Processing</strong> (or search in the menu).</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*-0w7YrgTeDmrtGcDbFnP2A.png" /></figure><p>2. Create a <strong>Document Action</strong>:<br> — Choose Invoice/Purchase Order template or Generic (custom schema).<br> — Define fields + natural language prompts.<br> — Select LLM model and confidence threshold.<br> — Assign reviewers (optional).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*VHkNaYq5pbGLkNxwIoeARA.png" /></figure><p>3. <strong>Publish</strong> to Exchange → it becomes an API instantly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*D4__ZOPeuIFXpA_XhuD_jA.png" /></figure><p>4. <strong>Consume</strong>:<br> — In MuleSoft Studio: Use the auto-generated IDP connector.<br> — In RPA: Submit Document + Retrieve Results actions.<br> — Via API: Use the IDP Runtime Service with a connected app.<br>5. Test with sample documents and monitor in the IDP dashboard.</p><p>Pro tip: Start with pre-built Invoice/Purchase Order actions for immediate wins, then expand to custom documents.</p><p><strong>Trailhead Module</strong>: “<a href="https://trailhead.salesforce.com/content/learn/modules/mulesoft-idp-basics">MuleSoft IDP Basics</a>” is an excellent free starting point (includes hands-on).</p><h3>Final Thoughts: Is MuleSoft IDP Right for You?</h3><p>If your organization handles high volumes of documents and already invests in MuleSoft or Salesforce, <strong>IDP is a no-brainer.</strong> It transforms costly, manual processes into intelligent, automated workflows that deliver measurable ROI in weeks — not months.</p><p>The combination of powerful LLMs, confidence-driven human oversight, seamless Anypoint integration, and natural-language configuration makes MuleSoft IDP one of the most practical and enterprise-ready document AI solutions available in 2026.</p><p>Ready to stop drowning in paperwork? <br>Start Anypoint Platform trial, spin up your first Document Action, and watch the magic happen.</p><p>Have you implemented MuleSoft IDP yet? What documents are you automating first? Drop your thoughts or questions in the comments — I’d love to hear your experiences!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93351c9df4d6" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/unlocking-the-power-of-mulesoft-intelligent-document-processing-idp-a-deep-dive-into-its-93351c9df4d6">Unlocking the Power of MuleSoft Intelligent Document Processing (IDP): A Deep Dive into Its…</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MuleSoft Q1 2026 Roadmap — A Beginner-Friendly Guide to the Agentic Enterprise]]></title>
            <link>https://medium.com/another-integration-blog/mulesoft-q1-2026-roadmap-a-beginner-friendly-guide-to-the-agentic-enterprise-5e08445c46bf?source=rss-2af5420a9964------2</link>
            <guid isPermaLink="false">https://medium.com/p/5e08445c46bf</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[mulesoft]]></category>
            <category><![CDATA[salesforce]]></category>
            <category><![CDATA[anypoint-platform]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[vijay kumar]]></dc:creator>
            <pubDate>Wed, 25 Feb 2026 10:06:21 GMT</pubDate>
            <atom:updated>2026-03-08T07:15:31.187Z</atom:updated>
            <content:encoded><![CDATA[<p>Artificial Intelligence is rapidly moving from experimentation to enterprise-scale adoption. By 2026, many organizations are running <strong>hundreds of AI agents</strong> across Salesforce, AWS, Google Cloud, Microsoft, and custom platforms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*56GzWeGBoqjZ6sL1N9zAyQ.png" /></figure><p>While this unlocks enormous productivity, it also introduces new challenges:</p><ul><li>Lack of visibility into AI agents</li><li>Security and compliance risks</li><li>Duplicate implementations and rising AI costs</li><li>Slow development and testing cycles</li><li>Manual business processes still dependent on human effort</li></ul><p>MuleSoft’s <strong>Q1 2026 Product Roadmap</strong> directly addresses these challenges by enabling organizations to safely scale AI, accelerate development, and empower business teams with automation.</p><p>This article explains the roadmap in simple terms with real-world examples across industries.</p><h3>Understanding the Agentic Enterprise</h3><p>An <strong>agentic enterprise</strong> is an organization where AI agents autonomously perform real business tasks such as:</p><ul><li>Customer support interactions</li><li>Invoice processing</li><li>Fraud detection</li><li>IT ticket creation</li><li>Supply chain forecasting</li></ul><p>As the number of AI agents grows, enterprises need a <strong>central control layer</strong> to manage them securely and efficiently.</p><p>MuleSoft’s answer to this challenge is <strong>Agent Fabric</strong> — a control plane for discovering, governing, and orchestrating AI agents across ecosystems.</p><h3>1. MuleSoft Agent Fabric</h3><h3>Governing AI at Enterprise Scale</h3><p>Agent Fabric acts as a <strong>central dashboard and governance layer</strong> for AI agents across multiple platforms.</p><h3>Agent Scanners — Automatic Discovery</h3><p>Organizations often deploy AI agents across different teams and cloud providers. Without centralized visibility, this leads to “shadow agents” and compliance risks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*59oA-1BaQ9jFx9My9rRAOg.png" /></figure><p><strong>Real-world example — Retail Industry</strong></p><p>A large retail organization uses:</p><ul><li>Salesforce AI for customer support</li><li>AWS Bedrock for demand forecasting</li><li>Google Vertex AI for pricing optimization</li></ul><p>Agent Scanners automatically detect new agents, capture metadata, and register them centrally. IT teams can review and apply governance policies before production use.</p><p><strong>Business value:</strong> Improved visibility, reduced risk, and faster onboarding of AI capabilities.</p><h3>Trusted Agent Identity — Zero-Trust Security</h3><p>AI agents now operate using <strong>delegated user permissions</strong>, ensuring they only access data the user is authorized to see.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eZDhTYhNhv9NBBo4caExaQ.png" /></figure><p><strong>Real-world example — Healthcare</strong></p><p>A doctor asks an AI assistant for patient reports. The agent inherits the doctor’s permissions, ensuring compliance with strict privacy regulations.</p><p><strong>Business value:</strong> Stronger compliance and reduced security risk.</p><h3>LLM Gateway — Cost and Performance Optimization</h3><p>Enterprises often use multiple LLM providers. The LLM Gateway provides:</p><ul><li>Intelligent routing between models</li><li>High availability and failover</li><li>Cost optimization and policy enforcement</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5KQTk9YkqjSiGOBRnpEGEQ.png" /></figure><p><strong>Real-world example — E-commerce</strong></p><p>Routine customer queries are routed to cost-efficient models, while complex queries use advanced models.</p><p><strong>Business value:</strong> Significant reduction in AI operational costs.</p><h3>2. MuleSoft Vibes</h3><h3>Accelerating Developer Productivity with AI</h3><p>MuleSoft Vibes introduces an <strong>AI-assisted development experience</strong> inside Anypoint Code Builder.</p><p>Its focus: reducing repetitive work while maintaining enterprise standards.</p><h3>AI-Generated MUnit Testing</h3><p>Developers can describe test scenarios in natural language, and Vibes generates:</p><ul><li>Test cases</li><li>Mock data</li><li>Error scenarios</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n5ygLuzn8UFqI7m0zR4YjQ.png" /></figure><p><strong>Real-world example — Software Company</strong></p><p>An integration between an e-commerce platform and ERP system requires extensive testing. Vibes automatically generates high-coverage tests, reducing testing effort significantly.</p><p><strong>Business value:</strong> Faster delivery and higher software quality.</p><h3>Reuse of Existing APIs and Templates</h3><p>Vibes recommends reusable assets from Anypoint Exchange and enforces global development rules.</p><p><strong>Real-world example — Manufacturing</strong></p><p>Developers building new integrations automatically reuse existing APIs and connectors instead of recreating them.</p><p><strong>Business value:</strong> Reduced duplication and consistent architecture.</p><h3>3. MuleSoft for Flow</h3><h3>Low-Code Automation for Business Users</h3><p>MuleSoft for Flow enables non-technical teams to build automations within Salesforce.</p><h3>Intelligent Document Processing (IDP)</h3><p>AI extracts and validates data from documents directly inside business workflows.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uqL5tojCWiwacklEyp6ruA.png" /></figure><p><strong>Real-world example — Finance</strong></p><p>Supplier invoices are uploaded, processed automatically, and sent to ERP systems without manual data entry.</p><p><strong>Business value:</strong> Faster processing cycles and reduced human error.</p><h3>New Connectors for Business Applications</h3><p>New connectors for tools such as Jira, Zendesk, NetSuite, and QuickBooks enable cross-system automation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PujeFMoZzX-Q-SfSNFInYA.png" /></figure><p><strong>Real-world example — IT Service Management</strong></p><p>A Salesforce case automatically creates a Jira ticket, updates status, and notifies teams.</p><p><strong>Business value:</strong> Faster resolution times and improved operational efficiency.</p><h3>Why This Roadmap Matters</h3><p>MuleSoft’s Q1 2026 updates focus on three strategic priorities:</p><h3>1. AI Governance at Scale</h3><p>Organizations gain visibility, security, and cost control across AI agents.</p><h3>2. Developer Velocity with Guardrails</h3><p>AI accelerates development while maintaining enterprise standards.</p><h3>3. Business Agility Through Automation</h3><p>Low-code tools empower business teams without compromising governance.</p><h3>Final Thoughts</h3><p>The MuleSoft Q1 2026 roadmap represents a major step toward making AI <strong>practical, governed, and scalable</strong> for enterprises.</p><p>Organizations adopting these capabilities early can expect:</p><ul><li>Faster innovation cycles</li><li>Lower operational costs</li><li>Stronger compliance and governance</li><li>Increased productivity across teams</li></ul><p>The shift toward the <strong>agentic enterprise</strong> is already underway. MuleSoft is positioning itself as the platform that enables organizations to manage this transformation with confidence.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5e08445c46bf" width="1" height="1" alt=""><hr><p><a href="https://medium.com/another-integration-blog/mulesoft-q1-2026-roadmap-a-beginner-friendly-guide-to-the-agentic-enterprise-5e08445c46bf">MuleSoft Q1 2026 Roadmap — A Beginner-Friendly Guide to the Agentic Enterprise</a> was originally published in <a href="https://medium.com/another-integration-blog">Another Integration Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>