Copilot Studio: Connect to Foundry

Key insights

• Copilot Studio + Microsoft Foundry overview
  Connects user-facing conversational agents (Copilot Studio) with backend agent and model processing (Foundry) so you can route queries to specialized agents automatically.
• MCP (Model Context Protocol) and core components
  MCP acts as the bridge and uses an MCP Server (gateway), MCP Client, and MCP Inspector for discovery, invocation, and testing of Foundry agents.
• Prerequisites
  Gather the Foundry agent name and the project endpoint URL (https://YourFoundryProject-resource.services.ai.azure.com/api/projects/YourFoundryProject) and have a Microsoft Entra ID account for authentication.
• Connection steps
  Open the Agents tab in Copilot Studio → choose “Add” → select Microsoft Foundry as an external agent → create or select a connection → paste the Foundry endpoint → authenticate with Microsoft Entra ID → Copilot Studio creates the connected agent configuration and lists the agent.
• Foundry IQ knowledge base and custom role
  Create a Foundry IQ knowledge base, ingest and index your content, then test queries from Copilot Studio; create a custom role with least-privilege access and assign it to the integration to secure agent calls.
• Advanced integration and operational notes
  Bring Azure AI Foundry models into Copilot Studio by enabling administrative settings (data access and AI provider options) and deploying model resources; use the MCP Inspector to validate endpoints, and monitor logs and permissions for reliable, secure operations.

At the Microsoft MVP Summit 2026 in Redmond, Rafsan Huseynov published a detailed walkthrough showing how to connect Copilot Studio to Microsoft Foundry. The video, co-presented with David Lorenzo, focuses on a practical integration that links conversational agents to backend compute and model resources. In addition, the presenter outlines use cases, setup steps, and security considerations that matter for organizations planning a hybrid agent architecture. Consequently, this article summarizes those key points and highlights tradeoffs and operational challenges for editorial readers.

What the video demonstrates

The presentation begins with a clear use-case overview that frames Copilot Studio as the user-facing orchestrator and Microsoft Foundry as the computational engine. Then, Rafsan walks through the full solution so viewers can see both the big picture and the detailed steps. Moreover, the video shows how Foundry agents and models can be treated as callable tools inside Copilot Studio using a bridging protocol. As a result, teams gain a workable pattern for combining low-code conversational flows with pro-code compute resources.

Importantly, the video highlights the Model Context Protocol (MCP) as the key connector between platforms, explaining how MCP endpoints expose agent capabilities. Rafsan also demonstrates the process of creating a Foundry IQ knowledge base and setting up a custom role for controlled access. Finally, timestamps guide viewers to specific sections such as connection setup, knowledge-base creation, and role configuration. Therefore, the material serves both newcomers and experienced practitioners who want a practical blueprint.

How the connection works

At a technical level, the integration relies on three components: an MCP gateway or server, a client interface in Copilot Studio, and an inspector or testing tool. First, the MCP gateway surfaces Foundry agent APIs so Copilot Studio can discover and call them. Next, the Copilot Studio agent list treats connected Foundry agents like native tools, which simplifies orchestration and routing. Consequently, multi-agent scenarios can operate in real time without custom routing logic for each domain.

In practice, the system discovers agent metadata and uses it to choose the right agent for a user query, for instance routing biology questions to a biology agent. Meanwhile, Foundry handles heavy compute or domain-specific models that are less suited to a purely conversational environment. This separation keeps the user interface lightweight and pushes intensive work to the appropriate backend. Thus, teams benefit from modularity and clearer responsibility boundaries.

Step-by-step setup

Rafsan outlines a concise series of setup steps that start with two prerequisites: the Foundry agent name and the project endpoint URL. First, users open the Agents tab in Copilot Studio and choose to add an external agent, then select Microsoft Foundry from the list. Next, they either create a new connection or pick an existing one, then enter the Foundry project endpoint and authenticate using Microsoft Entra ID. Finally, Copilot Studio completes the configuration and lists the Foundry agent alongside other agents.

The video also covers creating a Foundry IQ knowledge base and the need to configure access controls for safe operation. In addition, Rafsan shows how to define a custom role to limit what the connected agent can do, which reduces blast radius in case of misuse. He stresses that careful role design is a simple but effective governance step. Therefore, administrators should treat role creation as part of the initial deployment checklist.

Tradeoffs and challenges

While the pattern offers clear benefits, the presenters acknowledge tradeoffs between ease of use and security, and between low-code speed and pro-code flexibility. On one hand, treating Foundry agents as native tools speeds integration and reduces repeated coding. On the other hand, exposing endpoints increases the need for robust authentication, role management, and monitoring. Consequently, teams must balance rapid prototyping against long-term governance and compliance requirements.

Performance and latency present further tradeoffs because routing queries to specialized Foundry agents can add network overhead and introduce failure modes. Moreover, troubleshooting distributed agent flows requires new observability tools and practices to track context across systems. Cost is another factor: running heavy models in Foundry can be more expensive than simpler agents, so teams should monitor usage and optimize where possible. Thus, organizations need to adopt both technical and operational controls before scaling.

Practical guidance and next steps

For teams ready to try the integration, Rafsan’s steps form a practical starting point: gather the endpoint and agent ID, connect through the Agents tab, authenticate using Microsoft Entra ID, and validate with the inspector tool. After the initial connection, prioritize role-based access and logging, and then test with representative queries to confirm routing and results. Furthermore, document agent metadata and model versions so teams can audit decisions and reproduce behavior when needed.

In closing, the video gives a hands-on roadmap for combining conversational UX with backend model power using Copilot Studio and Microsoft Foundry. By addressing the setup, security, tradeoffs, and operational hurdles, the walkthrough helps teams make informed choices. Consequently, readers can decide whether this hybrid pattern fits their needs and plan workstreams that balance agility, cost, and governance. Overall, Rafsan’s presentation serves as a useful field guide for practical multi-agent orchestration.

Keywords

connect Copilot Studio to Microsoft Foundry, Copilot Studio Microsoft Foundry integration, Microsoft Foundry Copilot Studio setup, Copilot Studio Foundry tutorial, link Copilot Studio to Foundry step by step, Copilot integration with Microsoft Foundry, authenticate Copilot Studio Foundry connection, configure Copilot Studio for Microsoft Foundry