Multi-Agent System with MCP: An Illustrative Sales Success Story

The Real-World Problem

Picture this: It's 9 AM on quarter-end. Joe, your account executive, needs to prepare for a renewal call with Acme Corp. He navigates through a labyrinth of tabs—Salesforce to review the opportunity, Fireflies to analyze last week's meeting notes, LinkedIn to decode org-chart dynamics, and Slack to gather competitive intelligence. Forty-five minutes and thirty browser tabs later, Joe still hasn't answered the critical questions that could make or break the deal:

• Who actually signs the purchase order now that Acme's CIO just left?
• Did pricing objections surface in the last customer call?
• Has a competitor quietly infiltrated this deal?
• What's the real sentiment behind their "budget concerns"?

Now envision Joe typing a single plain-English question into a Deep Research interface: "What are the current risks for the Acme Corp renewal based on recent calls and leadership changes?" Within sixty seconds, he receives a comprehensive briefing with citations, risk assessment, and recommended next actions. His focus shifts from "hunting for information fragments" to "strategically closing the deal."

This transformation isn't just about convenience — it's about competitive advantage. Teams implementing this workflow report reducing preparation time by 60% and accelerating pipeline velocity by 20%. But sales is merely the opening act. Finance teams demand automated audit trails, marketing teams want agent-driven campaign insights, and IT teams envision autonomous incident response systems. The need for intelligent, automated research spans every business function.

The challenge lies in moving from prototype to production-ready solution that meets enterprise standards for security, governance, and scalability.

Enter TrueFoundry – the enterprise-grade AI platform that transforms multi-agent system development from complex infrastructure challenges into streamlined, production-ready solutions. In the following sections, we'll explore how TrueFoundry's comprehensive platform addresses the multi-agent imperative, simplifies MCP server deployment, and provides the enterprise governance necessary for successful AI transformation.

The Multi-Agent & MCP Mandate for Enterprises

The USB Analogy: Why We Need MCP Servers

Before diving into multi-agent architectures, let's address the connectivity problem. Imagine if every device in your office required a different cable — one for your monitor, another for your keyboard, a third for your external drive. The chaos would be overwhelming. USB solved this by creating a universal standard.

Enterprise AI faces the same fragmentation problem. Traditional approaches require custom integrations for each data source: bespoke code for Salesforce, specialized APIs for Fireflies, unique authentication for LinkedIn. This creates maintenance nightmares and scaling bottlenecks.

Model Context Protocol (MCP) servers function as the "USB-C for AI" — providing standardized connections between AI agents and enterprise systems. As TrueFoundry's comprehensive MCP blog demonstrates, MCP servers eliminate the need for custom integrations by exposing standardized "ports" to enterprise applications. Agents call tools through MCP with consistent protocols, just as modern devices connect through universal cables.

The values TrueFoundry brings for MCP setup, configuration, and deployment could be found also here.

Beyond Single-Agent Limitations

A monolithic LLM handling complex sales research is like expecting a single Swiss Army knife to build a house — theoretically possible, but practically insufficient. 

This multi-agent approach offers several critical advantages over monolithic solutions:

1. Specialized Expertise: Each agent is optimized for specific tasks, resulting in higher-quality outputs
2. Parallel Processing: Multiple agents can work simultaneously, dramatically reducing response times
3. Fault Tolerance: If one agent fails, others can continue processing
4. Scalability: Individual agents can be scaled independently based on demand
5. Maintainability: Focused agents are easier to debug, update, and enhance

We'll leverage LangGraph for agent orchestration, as detailed in TrueFoundry's LangGraph deployment guide. While other frameworks like LlamaIndex, AutoGen, or Dynamiq offer similar capabilities, LangGraph provides robust enterprise-grade orchestration with TrueFoundry's platform integration. TrueFoundry will publish comprehensive pattern comparisons in upcoming blog posts, exploring various multi-agent architectures and their optimal use cases.

The MCP Server Revolution

The Model Context Protocol represents more than just another API standard—it's a fundamental shift toward interoperable AI systems. Traditional approaches require teams to build custom connectors for each data source, creating technical debt and maintenance overhead. MCP servers provide several transformative advantages:

• Developer Productivity: Instead of weeks spent building custom integrations, developers can spin up MCP servers in minutes. TrueFoundry's AI Gateway playground allows immediate testing of MCP connections, enabling rapid prototyping and validation.
• Reusability: The same "CustomerSentiment" tool that powers sales research can instantly serve marketing's competitive intelligence needs or finance's risk assessment workflows. This reusability accelerates development cycles and reduces duplicate effort.
• Security and Governance: MCP servers implement enterprise-level security through encrypted data transmission, role-based access controls, and comprehensive audit logging. They support data residency requirements and provide fine-grained permissions management.
• Testability: TrueFoundry's AI Gateway playground enables developers to test MCP server interactions in a controlled environment, validating functionality before production deployment.

Enterprise Governance: The Non-Negotiable Foundation

Enterprise CIOs evaluate AI solutions through a governance lens first. Technical capabilities matter, but security, compliance, and observability determine adoption success. TrueFoundry addresses these requirements comprehensively:

• Guardrails and Policy Enforcement: Asynchronous compliance filters scan outputs before delivery, ensuring regulatory adherence without performance degradation. Custom policies can be implemented for industry-specific requirements like HIPAA, SOX, or GDPR.
• Role-Based Access Control (RBAC): Granular permissions determine which users can access specific data sources, agents, or research capabilities. This enables secure multi-tenant deployments across large organizations.
• Data Residency and Privacy: TrueFoundry supports on-premises deployment and cloud-specific data residency requirements, ensuring sensitive information never leaves authorized boundaries.
• Observability and Monitoring: Comprehensive dashboards provide real-time visibility into agent performance, cost allocation, and system health. This enables proactive optimization and rapid issue resolution.

All these aspects are by design well covered by TrueFoundry as elaborated in its Trust Center Capabilities.

Solution Architecture by TrueFoundry: Enterprise-Grade Multi-Agent Deep Research

System Overview

Our enterprise architecture implements a sophisticated multi-agent system (MAS) orchestrated through LangGraph, with standardized data access via MCP servers and comprehensive governance through TrueFoundry's platform capabilities:

Implementation Deep Dive

LangGraph Agent Orchestration

Following the patterns outlined in TrueFoundry's LangGraph deployment guide, our implementation leverages the supervisor-worker pattern for maximum efficiency:

async def create_fireflies_agent():
   """Create Fireflies agent with MCP tools."""
   client = MultiServerMCPClient({
       "fireflies": {
           "url": "https://ml.tfy-eo.truefoundry.cloud/fireflies-mcp-deep-research-8000/mcp",
           "transport": "streamable_http",
           "headers": {
               "Authorization": f"Bearer {os.getenv('FIREFLIES_KEY')}"
           },
       }
   })
  
   tools = await client.get_tools()
  
   return create_react_agent(
       model=llm,
       tools=tools,
       prompt=(
           "You are a Fireflies meeting assistant.\n\n"
           "INSTRUCTIONS:\n"
           "- Assist ONLY with meeting-related tasks such as summarizing discussions, extracting action items, and identifying speakers\n"
           "- Use tools to transcribe, analyze, and summarize conversations from platforms like Google Meet\n"
           "- After completing your task, submit the summary directly to the meeting organizer or designated stakeholder\n"
           "- Respond ONLY with the meeting summary or key outcomes, do NOT include ANY extra commentary or unrelated content."
       ),
       name="fireflies_agent",
   )
async def create_supervisor_with_salesforce_and_fireflies():
   """Create supervisor that manages all four agents."""
   salesforce_agent = await create_salesforce_agent()
   fireflies_agent = await create_fireflies_agent()
  
   return create_supervisor(
       model=llm,
       agents=[research_agent, math_agent, salesforce_agent, fireflies_agent],
       prompt=(
           "You are a supervisor managing three agents:\n"
           "- a research agent. Assign research-related tasks to this agent\n"
           "- a math agent. Assign math-related tasks to this agent\n"
           "- a salesforce agent. Assign Salesforce/CRM-related tasks to this agent\n"
           "- a fireflies agent. Assign Fireflies meeting-related tasks to this agent\n"
           "Assign work to one agent at a time, do not call agents in parallel.\n"
           "Do not do any work yourself."
       ),
       add_handoff_back_messages=True,
       output_mode="full_history",
   ).compile()

‍

MCP Server Utilization for Agents

As highlighted in TrueFoundry's MCP documentation, we could have MCP servers deployed on TrueFoundry; on having the deployment at hand, test-driving, evaluating, and deploying MCP servers becomes straightforward with TrueFoundry:

One could enter “Playground” of TrueFoundry’s AI Gateway, and click on “MCP Servers”, and opt in / out tools for each MCP server:

and make them available under the prompt:

The playground interaction also makes it clear which tools get invoked in a real AI chat, which helps developers to clearly see the big picture of the whole flow.

Of course, we could also go back to “Deployment” to double check and re-edit the MCP server deployment settings:

‍

As expected, we see that in the Python code above, the MCP server endpoint for agent instantiation is just the one that is deployed. By doing this, we really have good re-usability of existing tested MCP servers.

 client = MultiServerMCPClient({
       "fireflies": {
           "url": "https://ml.tfy-eo.truefoundry.cloud/fireflies-mcp-deep-research-8000/mcp",
           "transport": "streamable_http",
           "headers": {
               "Authorization": f"Bearer {os.getenv('FIREFLIES_KEY')}"
           },
       }
   })

Another thing to note down is that sometimes we need to reconfigure the environment variables by adding new credentials, we could enrich the existing environment variable list and in the code to have that called. For example, in the above Python code:

 "Authorization": f"Bearer {os.getenv('FIREFLIES_KEY')}" 

in the headers serves that purpose and one can find the variable 'FIREFLIES_KEY' under “Edit Service”.

A Quick Experiment on Multi-Agent System

We could quickly build a 3-agent system where a supervisor agent oversees two worker agents: a Salesforce agent and a Fireflies agent. With that, we could create wrapping TrueFoundry Service around the Langgraph Python code, and we can test drive that particular service in TrueFoundry UI:

With the output:

Which shows that the supervisor agent correctly identifies the intention of the prompt – retrieving sales call scripts and then it delegates in the right way to Fireflies agent to get the answer to the user.

Example Output from the Fully Fledged Deep Research

‍

Deep Research Analysis: Acme Corp Q3 Renewal
Deal Health Score: 68% (At-Risk)
Key Findings:
Pricing Sensitivity: Negative sentiment detected in 2 of last 3 calls regarding cost concerns
Leadership Change: New interim CFO announced via LinkedIn (July 14, 2025)
Competitive Pressure: Competitor "TechRival" mentioned 3 times in recent calls
Support Health: Zero critical support tickets in past 90 days (positive indicator)
Risk Factors:
Budget Constraints (High Risk): CFO transition may delay decision-making
Competitive Evaluation (Medium Risk): Active comparison with alternative solutions
Stakeholder Alignment (Medium Risk): Key champion (CTO) availability uncertain
Supporting Evidence:
Fireflies Call [July 10]: "Budget is tighter than expected this quarter" (Sentiment: -0.7)
LinkedIn Post [July 14]: "Acme Corp appoints Bill Johnson as interim CFO"
Salesforce Opportunity: Stage=Negotiation, Amount=$850K, Close Date=July 31
Generated: July 16, 2025, 7:30 PM PST | Confidence: 87% | Processing Time: 2.3 seconds

Summary: The TrueFoundry Advantage for Enterprise AI

Multi-agent systems represent a fundamental shift in how organizations approach complex AI workflows, moving from monolithic solutions to collaborative, specialized intelligent systems. 

TrueFoundry's cloud-agnostic platform, combined with sophisticated multi-agent orchestration patterns and comprehensive MCP server support, creates a unique enterprise-grade foundation for building scalable, secure, maintainable, and highly efficient multi-agent architectures.

The platform's key differentiators include:

• Economic Efficiency: substantial reduction in infrastructure costs through intelligent resource management
• Rapid Deployment: Development cycles reduced from weeks to days through pre-built templates and automated deployment
• Enterprise Security: Comprehensive governance, compliance, and observability built into every component
• Developer Productivity: Zero vendor lock-in, unified APIs, and comprehensive tooling for rapid development
• Operational Excellence: Automated scaling, monitoring, and maintenance reducing operational overhead

The future of enterprise AI lies not in individual model deployments, but in collaborative agent ecosystems that combine specialized capabilities with high grade compliance & governance. 

TrueFoundry's platform provides the foundation for this future, enabling organizations to build, deploy, and manage sophisticated multi-agent systems with confidence and efficiency.