Introduced by Anthropic, MCP is gaining adherents as an open standard protocol for building modular, scalable, and context-aware AI applications. It is a means by which AI agents (such as LLMs) understand the context necessary to call external tools, including APIs.
In theory, MCP could allow a developer to build a single AI agent that successfully interacts with a broad range of APIs. "In theory," because the idea and the reality don't match up.
Let's step back a minute and look at the bigger picture.
Many SaaS teams are building chatbots. It's an obvious and inexpensive place to start incorporating AI into systems. But things become complicated when one needs the chatbot to perform real-world tasks.
Let's say your app is an order management system, and you want your chatbot to check the status of an order for your customer in your system, update a record in that customer's Salesforce, and then notify the customer via Slack. So, you prompt the AI agent, call each API directly, and assemble all the pieces. It works, and your customer is happy. But the solution doesn't scale.
"Aha," you say, "that's why we have MCP!" You are partly correct. An MCP server provides predefined tools to an AI agent. And that helps to ensure that the AI, for example, doesn't hallucinate API calls.
However, we still have less-than-ideal interactions because MCP won't solve all agent communication problems. It doesn't:
- Provide automatic handling of partial failures or poor feedback from third parties.
- Handle input validation of critical operations
- Take the fewest number of steps to reach the outcome
In addition to the above, the more complex the request, the less likely it is to generate deterministic results. So, MCP makes AI agents more useful, but the resulting solution still lacks precision.
Prismatic is the abstraction layer you need
With all its connectors, flows, triggers, and actions, we've designed Prismatic to make it easy for you to build integrations between your product and all the other apps your customers use. That means we handle all of those API connections and (perhaps more importantly) all of the logic that needs to sit between the API and the requesting or receiving AI agent.
To make things even easier, we are releasing an MCP server that you can connect to your AI agents. Then, in Prismatic, you can define the structured, deterministic flows that describe precisely what is expected. That way, instead of using an AI agent with MCP to make a dozen API calls with fragile prompts (the software equivalent of playing "20 Questions"), you make a single call to your integration in Prismatic and let the integration flow handle the logic, auth, sequencing, and everything else that's necessary to drive the proper outcome.
And because you are doing that inside our embedded iPaaS, everything is testable, observable, and auditable. That's how Prismatic enables consistent, reliable results for your AI agent prompts and, by extension, your customers.
Why we are focusing on flows and not actions
Most MCP endpoints today are mirrors of existing API endpoints. They are not task-focused and are often much lower level than the prompts and requests. AI agents sometimes figure out how to call these tools in sequence to accomplish a task, but each call results in extra cycles, which burn tokens and, ultimately, money.
It's worth noting that AI agents can also become lost because there's too much ambiguity in even a single action to make the tool call effective. In these cases, it's not uncommon for AI agents to hallucinate data or data structures that don't exist.
We first explored converting individual integration steps, which we call actions, into functions that could be exposed to an AI agent via MCP. After experimenting with this approach, we discovered that directly calling actions in this way created a poor UX for all but the simplest tasks.
However, using flows (a series of actions plus the related logic) as the primary mechanism to extend AI functionality for our customers is a real solution with provable results.
Here's why.
Flows abstract away the "messy middle"
AI users often express their prompts in simple sentences like, "Show me tracking information for my outstanding deliveries" or "Issue payment for Invoice 12345." While these requests are superficially simple, fulfilling them involves complex processes, including interacting with multiple systems, performing data analysis, and handling notifications and errors.
A core challenge with integrations is determining where the logic should reside. Devs don't want to embed variable logic within applications, and third-party vendors aren't equipped to handle specific app requirements. This dilemma is known as the "messy middle."
We enable the representation of this "messy middle" as configurable flows in the integrations that connect your product with the other apps your customers use. These flows handle per-user variability and changing business needs along with built-in logging, monitoring, and deployment management. They align user intentions with business process requirements, which users can't be expected to know, and AI agents can't infer from user input alone.
These flows excel at expressing user intent. They are composed of several, sometimes hundreds, of actions, each accomplishing a specific task. While it's technically feasible for users to achieve their goals using individual actions, expecting them to assemble these flows prompt-by-prompt is unrealistic and leads to a terrible UX.
Flows bridge the gap between the user and AI
Extending AI functionality via MCP or direct function calling involves communicating your app's capabilities to the AI agent without altering the app or affecting other users. And that's where a translation layer comes into the picture.
Expressing integration flows as callable functions for AI agents simplifies the process by reducing input parameters. While individual actions may have numerous parameters, flows operate at a higher abstraction level, smoothing out the user experience.
Flows enable leveraging the power of CNI
The ability to create code-native integrations (CNI) is one of our most exciting features, highly requested by teams that prefer traditional software development tools over low-code solutions. Since its release, CNI has seen rapid adoption and is being used by many of our customers.
CNI represents code internally just like our low-code designer does. This allows teams to choose the best approach for them and enables a smooth conversion from low-code to code-native integrations when that makes sense.
CNI also supports flows as a core concept, allowing CNI flows to be used with AI agents via the same mechanism as with low-code integrations.
Why we are launching an MCP server
Our MCP server is the first step in enabling MCP functionality with Prismatic. You can connect your AI agent (ChatGPT, Claude, etc.) to our endpoint, register the tools you want to use, and point them to your flows in Prismatic – no need to stand up any infrastructure or build a bunch of scaffolding.
For MCP server details, including how to connect your AI agent, check out our docs.
What this means for you
Many B2B SaaS teams are attempting to connect business logic with LLMs. But many are missing the mark because what they are assembling doesn't address their customers' real-world business needs.
We've been working on embedded integration infrastructure for some time. We know what it takes to build software that enables your devs (and non-devs) to create the solutions your customers need.
We also understand the value AIs and MCP can bring and how to use Prismatic to maximize that value for your team and customers by leveraging the power of flows to ensure the consistent results you need.
If you'd like to use MCP with AI agents to drive next-generation solutions that provide insights and answers for your customers, schedule a demo, and let us show you how it can work.
