MuleSoft Formulates Mix For Galvanized Agentic AI Connections

Like concrete, software is a mix. Just as a good concrete typically features a cement mix of lime, silica and a variety of other chemical compounds mixed with a sand or gravel “aggregate” for bulk and strength; a good software service is built from a base kernel and has core code compounds that are bound to application programming interfaces and other points of interconnection.

Both concrete and software can be galvanized for robust performance where needed. Both can be stress tested, both can suffer from fissures and cracks over time, both can be broken down and refactored into a “new build”, the production of both features tea and coffee breaks… but only one features a trowel and a hard hat. Where modern software systems go next in their mixing process is, of course, the addition of agentic AI with its non-deterministic logic and ability to provide human-like reasoning intelligence to our lives.

Software Mixology & Management

While every enterprise software vendor of any shape is now defining itself as an agentic AI platform specialist, it’s worth looking below the hype to try and understand how the foundational services underpinning the modern software are working. Part of the Salesforce family, MuleSoft is an enterprise integration platform company known for its API-centric connectivity capabilities and its low-code/no-code API lifecycle management services. Although the company shares a close association with Salesforce, it’s worth noting that MuleSoft integrates and enables agent action “inside and outside” of the Salesforce ecosystem today. Given its pedigree in integration, the company is now extending its core platform and tools to offer an increasing number of agentic AI-facing technologies.

But why does integration matter so much in the agentic space and how do we lay the foundations for this technology so the bricks and mortar are tough enough to stand up?

As MuleSoft product marketing specialist Aston Whiteling reminds us, “In the not-so-distant future, AI agents are going to become one of the core consumers of APIs.” If that statement needs widening, what we’re saying is that agentic AI functions are going to start forging requests to interconnect one application or service (or operating system) with another service via a defined API route, automatically, as a result of the requests we ourselves make to AI services.

How all this changed is interesting.

The software engineering processes associated with connecting applications at any significant level has always been an essentially “request-driven” action where businesspeople’s requirements are translated into software coding instructions that may include a degree of interconnectivity. Multiple software services are connected once the developer and operations function agree on configuration pathways, protocols and policy. That core truth has been around for over half a century, but the status quo has now changed. As AI continues to flourish (and inevitably flounder in places) we will find software agents making the connections, a reality which will happen after users issue instructions – often via natural language – which drive agents to make autonomous decisions around which APIs to call and where to take action.

“The IT team will continue to define the scaffolding, most likely empowered with a separate set of generative AI tools, to rapidly implement these connections. They’ll have to consider the parsability of an API by an agent during the development process, though; soon enough, developers will be designing APIs specifically with agent usage in mind,” wrote Whiteling, in a recent blog. He suggests that this technology can be seen in action if we look at MuleSoft for Agentforce, a collection of assistive and autonomous agents that can reason, plan and act across a business based on user inputs.

The Analyst Viewpoint

“IDC last ranked MuleSoft as one of several leaders in the Integration space, because of its depth of capabilities, platform openness, and collaboration channels with the Salesforce ecosystem. Since then, Salesforce has made deep investments in agentic technology… and MuleSoft is key enablement factor in that. A key challenge organizations might not realize they will have with Integration and API management is that the APIs built for yesterday’s automation flows may need to be tweaked or even refactored before they are used in agentic workflows,” clarified Shari Lava, senior director for AI and automation at analyst house IDC. “MuleSoft now has features to help organizations control which APIs are made available to agents in the Salesforce ecosystem, although that capability is of course narrowed to Salesforce-specific software implementations. In addition, MuleSoft like many integration vendors has been quick to add MCP support and works with Google’s A2A protocol (an agent-to-agent communications layer), demonstrating a responsive focus on solving barriers to AI adoption in the hopes of getting more customers agent-ready.”

For completeness, let’s remember that MCP & A2A technolgies expand to agents across the entire enterprise technology landscape with established players including Perplexity, OpenAI, Google & Anthropic all supporting the MCP standard.

As noted by Lava, MuleSoft has now provided support for Model Context Protocol in Beta. A new but already widely lauded technology standard, MCP is an open protocol that enables integration between large language model applications and external data, services and tools. It enables language model and agent-based applications to communicate with each other in a consistent form. With all the focus on agentic connections, MCP provides ways for LLMs to get access to the live data flowing through external systems and their executing actions via a standardized protocol layer.

Because AI agents are now on the road to consuming APIs of their own volition, we need ways to channel the “opinionated design choices” that developers have when using API creation practices. In the non-deterministic world of agentic AI, open semantics across APIs can make agent actions hard to govern and control. MuleSoft says that because LLMs need access to the API specifications, they must be annotated with metadata that the LLMs can reason with. In other words, the freedom to build custom-aligned API technologies can actually cause incongruent complexity, so MuleSoft MCP Support (Beta) addresses these challenges.

Carrying these thoughts forward, MuleSoft SVP and general manager Andrew Comstock spoke to press and analysts this month in London to detail where the company’s platform is going next in terms of providing foundational blocks for agentic AI to be able to flourish.

Extending An Existing Ethos

Comstock says that MuleSoft has been focused on digital transformation through standards-based, very structured API connections “for a very long time” now; he proposes that what the company is now doing with these new connection protocols is a natural evolution of its cloud computing foundations as it extends that philosophy into an agentic world.

“Today it’s all about how agents can work with each other, how agents can work within software systems, how agents can work with applications… and of course how humans can work with them via natural language interfaces. We’ve worked with thousands of organizations building composable enterprise stacks, so even with all these new protocols, our view is that these are things that our customers have been doing for years already and we’ve been building and extending our services to get ready for this next generation of technology. This is the central underpinning truth behind what’s going on now,” said Comstock. “Cloud shifted technology in terms of how it was bought, run and scaled… this is the next progression. We haven’t seen this type of disruption in the enterprise tech space since cloud, but what matters now is how developers take advantage of this shift.”

A recurrent theme in this field of technology is the use of non-deterministic logic. Comstock reminds us that, in our old pre-millennial world, computing was largely deterministic. This meant that if we performed the same actions with the same applications in the same computing scenarios, we would get the same results. That doesn’t necessarily happen with non-deterministic AI agents, even when they draw from really high-quality information. We could ask an AI agent to draw us an image of a beautiful sunrise on a rainy day and we would get different images each time, which is the inherent result of the generative technologies underneath.

“Software developers need to design for API connections in applications with an appreciation for this non-deterministic scope,” urged Comstock. “Whether we call it guardrails, limitations, structure, context or whatever, it’s all about trying to work with non-deterministic systems as effectively as possible. An API might have a date range and a quantity range, it might also have a minimum and maximum value. The result from querying the API would be defined by these parameters and by the query made to the API. The more specific the demand, the more specific the result. But, explained Comstock, when we ask an agent to ‘give me the highest number’, it doesn’t always give us the highest number – and that’s a very different way of computing than we had in the past.”

Einstein Trust Layer

This discussion has mentioned guardrails and controls and this will always be a part of analysis in this space. The team here makes reference to the Salesforce Einstein Trust Layer, a security architecture designed to promote responsible AI, eradicate bias and protect sensitive data. It’s what Comstock calls a process of bringing structure to chaos in the pursuit of more consistent operations.

“We don’t want identical [AI results, as that would dilute non-determinism], but we want more consistency in the execution,” he said. “The power of agents is in their autonomy, so we need to give them access to connections to the appropriate information and, with MuleSoft, we have been looking at how to do this and bring capabilities around MCP and other agent frameworks into action. This way, we can make sure that the agents have the right actions so that they don’t wander into traffic, but they do on the road. Again, we’re not taking autonomy from the agent, but we’re making sure the results are coming back in the right tone and the right syntax that we’re looking for. This is where MuleSoft can help extend that via our Agentforce capabilities by enabling more complex actions.”

On the immediate road ahead, Comstock and team say that they will be thinking about agent connectivity scalability challenges and how to overcome them. In environments where enterprises need agents to potentially work with thousands of internal and external applications – both inside the Salesforce universe and outside of it – we’re at a sensitive point in terms of the dream of the composable enterprise, so these building blocks are what MuleSoft promises it is focused on shaping, honing and forging.

Asked whether we’re likely to see a “hierarchy of agents” now develop across the agentic AI landscape, Comstock echoes the egalitarian sentiments expressed by other developer advocates at his level i.e. there’s no hierarchy here, it’s a network and team, not a pecking order.

Competitive Analysis: MuleSoft

All said and done, MuleSoft obviously has a wide-ranging platform, toolset and approach. Its strengths appear to lie in the fact that the company has a purist approach to API-driven integration, something its advocates would suggest it helped pioneer within the tech industry.

There is breadth here i.e. MuleSoft offers a full suite of API design, API publishing, API runtime management, analytics and secure governance services. Across all hybrid multi-cloud deployments, MuleSoft has unsurprisingly deep levels of integration with the Salesforce platform (and connects externally too, as already noted above), which arguably gives it something of an edge in terms of customers and user community.

Thinking about what might keep MuleSoft awake at night, it could be the fact that the integration market is vast and populated by a large number of very established vendors. Key competitors in this space include Microsoft Azure Integration Services, which has a mature developer community and strong serverless integration capabilities – but suffers from more narrow alignment to Microsoft’s Azure cloud platform. Then there is Google Apigee, which has exemplary API analytics functions and impressive API monetization services, but lacks the end-to-end integration capabilities… meaning it can’t extend across as many applications and databases as some platforms.

We can’t talk about integration without mentioning Boomi. Like MuleSoft, Boomi has some pleasing low-code interface functions, but it may also offer better and simpler drag-and-drop functionalities. Also of note here is IBM Cloud Pak for Integration, which has some snazzy automated mapping recommendations and a particular focus on some deep vertical industry applications for highly regulated industries that other integration players will have to act more slowly on. As well as Tibco in the integration space, there is also Workato, which is known for its business-user friendliness as much as it is known for its lack of customizability.

Where MuleSoft would like us to leave this open showcase of its competitors is probably a reminder of how its platform enables DevOps teams wanting serverless-native integration stacks to operate. MuleSoft Anypoint Exchange is logically named i.e. the technology features an asset repository that enables teams to reuse pre-built APIs, accelerators, connectors and templates.

Why is MuleSoft called MuleSoft? Because it claims to take away the “donkeywork” of integration, if you needed an extra carrot of incentivization.