The State of MCP in the Enterprise: What works and what comes next

The Model Context Protocol (MCP), introduced by Anthropic, has captured the attention of developers and AI system designers with a bold promise: standardize the way large language models (LLMs) interact with external applications.

For anyone trying to build production-grade AI systems, this is a compelling vision. Instead of brittle one-off integrations, MCP offers a structured approach for mapping human requests to application APIs—bringing order to the chaos of tool invocation.

But for enterprises hoping to deploy AI in complex functional workflows, the reality is more complicated. MCP offers a useful building block, but it is not yet ready to support the kinds of agentic, multi-system workflows that businesses actually run.

In its current form, MCP falls short across some key enterprise needs—from handling multi-step tasks sequentially and understanding app-specific data models to reacting to real-time events and collaborating with humans in the loop.

In this blog, we’ll explore the current state of MCP in the enterprise, where it hits limits and what the broader ecosystem, including players like Ema, is building to fill the gaps.

Why MCP Needs More in the Enterprise

While the Model Context Protocol (MCP) promises to standardize AI-tool integrations, its usefulness faces challenges due to limitations that hinder its full potential. Organizations are finding it difficult to fully incorporate enterprise-specific context into MCP and develop MCP servers due to reliance on external partners.

Additionally, the lack of supplementary tools for creating more independent AI systems capable of managing complex, real-world workflows without disruptions poses a significant obstacle.

While MCP shows promise, these limitations, including a restricted function library, lack of application data model understanding, single LLM dependency, and the need for coding expertise, must be addressed to unlock its full potential for agentic applications in the enterprise environment.

1. Limited Out-of-the-Box Function Library: MCP supports very few applications out-of-the-box, requiring developers to write custom function libraries for applications and data sources before MCP can consume them. This adds considerable overhead and delays adoption.
2. No Understanding of Application Data Models: MCP lacks inherent knowledge of application-specific data models. For example, when interacting with Workday's API to request vacation days, MCP cannot contextualize details like the employee's location (e.g., Canada) or local vacation day codes. Developers must manually handle such nuances, limiting its usability in complex workflows.
3. Tied to One LLM: Although MCP can theoretically work with multiple large language models (LLMs), it is primarily tied to one LLM at a time. Enterprises tackling diverse problems often require the combined strengths of multiple LLMs, which MCP does not currently support.
4. Lack of Tooling for Multi-Step Workflows: MCP excels at executing individual tasks but struggles with orchestrating comprehensive workflows involving multiple actions, such as knowledge searches, human-in-the-loop (HITL) approvals, or interdependent tasks. This limits its ability to handle complex enterprise operations.
5. No Out-of-the-Box Support for Event-Driven Triggers: MCP does not natively support triggering workflows based on application events or user queries. Enterprises must build custom mechanisms to enable such functionality, adding complexity and reducing efficiency.
6. Requires Coding Expertise: Despite its promise as a standardizing protocol, MCP still requires significant coding effort for setup and integration. This makes it less accessible for organizations without robust technical teams.

Addressing these limitations will be crucial for MCP to evolve into a truly agentic protocol capable of meeting the dynamic needs of modern enterprises.

Why This Matters in the Enterprise

At first glance, MCP seems like a step forward in making AI more programmable. But in enterprise environments—where real business value depends on precision, reliability, and context-awareness—its current limitations become roadblocks. Here’s why:

Enterprise Workflows Are Not Single-Function Tasks

Most AI tooling demos are a one-shot task: “Create a Jira ticket,” “Send a Slack message,” or “Fetch a Salesforce contact.” In contrast, enterprise workflows are long-running, stateful, and often span multiple systems. Take employee onboarding as an example: it requires provisioning email accounts, assigning equipment, enrolling benefits, verifying compliance trainings, and more—across different tools, governed by org-specific policies.

These aren’t isolated function calls—they’re conditional, interdependent flows. Enterprises need orchestration, memory, policy checks, and escalation paths. MCP does not support this natively.

Context Is King in Enterprise Use Cases

A single function call is only useful if the model understands the context—like which business unit it’s operating in, which geographies are in scope, or which policy version applies. Enterprise systems don’t have a uniform schema, and terms like “priority,” “approval,” or even “customer” can vary dramatically depending on team or tool.

MCP provides no mechanism for context modeling, semantic translation, or disambiguation across apps. This leaves too much burden on the prompt—or worse, on the end user.

Cost, Accuracy, and Security Aren’t Trade-Offs—They’re Requirements

Enterprise AI must work within strict bounds. A model can’t be “mostly accurate” in financial reconciliation, or “fast enough” in fraud detection. Enterprises also need to route workloads based on data sensitivity—ensuring customer PII doesn’t leave their cloud boundary, or that pricing data isn’t processed by external APIs.

MCP is agnostic to model routing, governance, or compliance zones. Without these controls, enterprise use is limited to sandboxed, non-critical tasks.

AI Adoption Is Still Early—and Complex Tooling Slows It Down

Many enterprise teams are still navigating their first real AI integrations. In such an environment, tools that demand extensive setup, code maintenance, and LLM-specific knowledge are unlikely to scale. Enterprises need AI systems that work off-the-shelf, adapt to enterprise realities, and require minimal upkeep from internal engineering teams.

The burden of defining functions, writing adapters, and maintaining integrations for every app puts MCP out of reach for many teams trying to operationalize AI in 2024.

Re-imagining and Complementing MCP: A Generative Approach

To be truly enterprise-ready, MCP needs more than standardization. It needs orchestration, abstraction, and continuous adaptation. This is where the ecosystem needs to evolve—from MCP as a spec, to a Generative MCP as a programmable platform that can automate, contextualize, and scale across any enterprise stack.

We’re contributing to this evolution at Ema with Generative MCP—a production-grade system that builds on the core ideas of MCP but fills in critical enterprise gaps. It works alongside our Generative Workflow Engine™ (GWE) and EmaFusion™, our multi-model LLM fusion technology, to turn protocol-level integrations into intelligent, autonomous, and secure AI-driven workflows.

Here’s what Ema’s Generative MCP does differently—and why it matters for enterprises.

Generative MCP leverages MCP

Generative MCP leverages the Model Context Protocol (MCP) to automate interactions with external systems through the following actions:

• Identifies the application to fulfill a user's request.
• Determines the function or API endpoint to call within the application.
• Maps and optimizes the parameters for the chosen API call.

So, if a user requests to "Open a ticket for access to a specific folder in SharePoint."

• Generative MCP identifies that the ticket needs to be created in ServiceNow.
• Ema’s Generative MCP selects the appropriate function to execute a POST call to the URL: https://<Instance>.service-now.com/api/now/table/incident
• It also determines right parameters such as short description, description, and urgency

Generate

One of the biggest challenges with MCP is the lack of its function library. Generative MCP addresses that by creating a function library by parsing an application’s OpenAPI or Swagger specification. Integrations are hard. Data and application integration companies have tried to automate that using GUI-based tools for years. Writing workflows by hand is so 90’s. Many companies have 100s of developers working on developing these integrations.

Ema can utilize existing MCP servers or generate MCP servers from OpenAPI or Swagger specifications. By generating these functions, Generative MCP instantly creates a function library for 200+ applications. Compared to MCP’s function generation, Ema’s approach offers additional benefits:

• Authorization: Supports diverse organizational authorization modes (e.g., API key, access token, refresh token). You simply set the authorization mode, and Ema generates the correct code to use it.
• Pagination: GET methods within most applications can return numerous results. Similar to authorization mode, you can declare the pagination configuration, and Ema generates the correct code to use it.
• Support for older OpenAPI specs: Unlike MCP’s tools, which only generate code from OpenAPI v3 spec, Ema can generate code from older specifications, including Swagger.

Generative MCP can be used by partners and customers to generate function libraries for their custom applications.

Catalog

Generative MCP also provides a mechanism to “catalog” the frequently used functions. This provides tenant administrators with visibility and control over the operations that can be carried out by Ema’s virtual AI employees.

For example, some organizations may want to implement guardrails to prevent virtual employees from executing deletion operations, such as those that delete a lead from Salesforce, delete employee records from SuccessFactors, or delete Jira projects entirely. The cataloging functionality allows administrators to define and enforce policies that align with their organization's specific requirements and risk tolerance.

Contextualize

The "Contextualize" step in Ema's Generative MCP is where the magic truly happens. It's akin to teaching the system the language of each specific application and the unique dialects that exist within an organization.

Let's take Jira as an example. On the surface, it's a simple project management tool with tickets moving through statuses like "To Do," "In Progress," and "Done." But anyone who's worked in a complex project knows that Jira can be customized with a myriad of statuses and corresponding codes.

Imagine an employee using a chatbot to update a Jira ticket's status to "Done." Generative MCP doesn't just blindly pass that command to the Jira API. It first understands the context of the project, identifies the possible "Done" states (which might have custom names and codes), and ensures the correct transition occurs. If there's ambiguity, it intelligently queries the user for clarification, preventing errors and miscommunications.

Similarly, when an employee asks about their remaining vacation days, it's not a simple database lookup. Generative MCP considers the employee's location, their grade within the company, and the specific vacation policies that apply to them. It then fetches the relevant data and presents it in a clear, human-readable format, stripping away unnecessary codes and jargon.

In essence, the "Contextualize" step bridges the gap between human intent and application-specific requirements, ensuring that every interaction is accurate, efficient, and tailored to the user's needs.

Event-Awareness using External Triggers

MCP's limitation in detecting application events can be its Achilles' heel. Imagine a sales team eagerly awaiting a new lead in Hubspot, a customer support representative needing immediate notification of a new Zendesk ticket, or an HR team needing to onboard a new employee added to Workday. These scenarios highlight the critical need for real-time event awareness within AI systems.

Generative MCP allows users to set up triggers so that any event in an application, such as the creation of a new Zendesk ticket by a critical customer, can trigger a virtual AI employee to take immediate action.

Going beyond single LLMs: Powered by EmaFusion™

Most MCP implementations are tied to a single LLM, limiting their flexibility. But different tasks require different model trade-offs: cost, latency, or domain specialization.

EmaFusion™, our proprietary model fusion technology, allows Generative MCP to dynamically select and blend outputs from 100+ open and closed-source models. It applies:

• Task-aware routing (e.g., summarization vs classification)
• Learned routing for novel inputs
• Cascading based on confidence thresholds
• Fusion of multiple outputs for complex reasoning

The result: better accuracy, lower costs, and resilient performance—even under provider downtime.

EmaFusionTM combines the power of 100+ LLMs and through advanced orchestration, dynamically selects the best LLM for each task, ensuring optimal outcomes.

By leveraging EmaFusionTM as its LLM layer, Generative MCP instantly taps into the power of many different LLMs and can recommend custom fine-tuned LLMs for specific tasks, aligning with the EmaFusion capability to "leverage the strengths of each model while mitigating their weaknesses."

Supports Complex, Multi-step Workflows with GWETM

Ema’s Generative Workflow Engine (GWETM) serves as the orchestrator of agentic actions within Ema's Generative MCP, effectively acting as its "brain." GWE addresses several key limitations of the standard MCP:

• Extensive Agent Library: GWE offers a vast library of over 100 specialized agents, each tuned for specific tasks such as "search and respond," "extract rules," "validate rules," or "call external action using generative MCP." This diverse toolkit enables the construction of intricate agent graphs, incorporating human-in-the-loop steps for approvals when necessary, to manage even the most complex agentic tasks.
• No-Code Creation: Building a Virtual AI employee with GWE eliminates the need for coding expertise. Its intuitive, no-code approach democratizes the creation process, making it accessible to a broader range of users.
• Dynamic ephemeral app Generation: GWE agents possess the ability to generate "ephemeral apps" on demand. For instance, if an employee requests vacation time through a chatbot, the external action caller agent can instantly create an ephemeral, custom form with the necessary fields and controls (e.g., a calendar control for selecting dates), prompting the user to input the required information.
• Versatile Trigger Mechanisms: Virtual AI employees powered by GWE can be triggered through multiple channels:
  • Events in applications
  • Time-based events
  • Requests from humans via web, mobile app, or voice interface
  • Requests from other virtual AI employees

Generative MCP in conjunction with EmaFusion and GWE perfectly complements MCP and makes it enterprise ready.

From Protocol to Production

MCP is an important step toward standardizing how LLMs talk to software. But for enterprise adoption, standardization isn’t enough. Organizations need a way to translate protocol-level intent into real, secure, contextual action—at scale.

That’s where Generative MCP comes in. Built on top of the MCP foundation, it adds the critical layers enterprises need to operationalize AI:

• Authorization- and pagination-aware code generation to automate function libraries across hundreds of tools
• Cataloging and controls to ensure visibility and policy-based governance over every interaction
• Application-specific context modeling to turn generic intent into system-aware, precise API calls
• Event triggers and reactivity for proactive, always-on workflows
• EmaFusion™, our multi-model LLM router, to optimize every task for accuracy, latency, and cost
• Generative Workflow Engine™ for orchestrating multi-agent, multi-step, human-in-the-loop workflows with no code

Together, these layers transform MCP from a protocol into a platform. They enable enterprises to automate and scale mission-critical processes—not just reliably, but intelligently. This is what enterprise-grade Agentic AI looks like: not just possible, but production-ready.

If you’re building agentic systems for the enterprise, the future isn’t just about tool invocation. It’s about orchestration, adaptability, and trust. And that’s what Generative MCP delivers.