Enterprise AI is now multi-vendor by default

Your employees aren't waiting for a single AI platform to win. They’ve already picked several.

Copilot agents are running in Microsoft Outlook and Teams. A line-of-business team, empowered with Claude Code and GitHub Copilot, spun up five agents using LangGraph last quarter, and are running it in Microsoft Foundry. The AI center of excellence (CoE) is struggling to keep track of twenty different Model Context Protocol (MCP) servers and five different agent run-times they are not even skilled on. IT is fielding tool requests from every direction and desperately trying to maintain security, privacy, and governance standards over this agent sprawl. This isn’t chaos; this is the new normal we live in.

The question is shifting from which AI tools an organization should adopt to how those tools work together safely, consistently, and at scale.

That was the conversation I heard most often at Microsoft Build: not “which AI platform should we bet on?” but “how do we orchestrate work when agents from multiple vendors are operating inside the same business process?”

The organizations moving from pilots to production are treating this as an architecture decision, not just a tooling decision.

The thing pilots don't test

Pilots are useful because they prove that an agent can solve a defined problem in a controlled environment. But they rarely test what happens when that agent becomes part of a department-wide process, when multiple departments use different agents, or when IT has to govern handoffs, data access, policies, exceptions, and auditability across the full system.

That is where enterprise AI often slows down: not because the models are incapable, but because the operational layer that connects agents, systems, data, and people is not yet in place.

AI at scale requires more than model performance. It requires process orchestration, IT governance, security, policy enforcement, exception handling, and observability across business workflows. A Foundry agent that calculates risk scores may hand off to a UiPath automation that triggers a payment workflow. The harder problem is coordinating those actions with the right controls, the right human review, and a complete audit trail.

Without an orchestration layer, they're just a more complicated version of the manual process you were trying to replace.

Microsoft 365 is where people collaborate

Microsoft 365 is where many enterprise processes begin because it is where people collaborate, make decisions, and manage the work of the business. Work arrives in Outlook, moves through Teams, is shaped in documents, and becomes a decision or action that someone needs to complete. That makes Microsoft 365 a natural surface for enterprise AI: it is where context, collaboration, and human judgment already come together.

But executing processes like claims management, medical referrals, loan processing, and finance operations require agents, automations, policy checks, exception handling, system updates, and long-running workflows across many applications before work is actually complete. Microsoft 365 is where the problem is surfaced and resolved with people in the loop. Agents are where much of the work gets done. UiPath Maestro™ is what orchestrates those AI agents, automations, and human handoffs into an end-to-end enterprise process.

The joint architecture is designed to connect those layers: the collaboration layer where people work, and the orchestration layer that coordinates how work is completed across agents, systems, and teams.

Customers should not have to choose between innovation and control, or between the AI tools their teams want to use and the governance their enterprises require. The work UiPath is doing makes that possible: giving organizations the flexibility to build with the agents, platforms, and applications that are right for them, while creating the connective tissue needed to operate those systems safely at scale. This is exactly the kind of open, enterprise-ready partnership customers are asking for as they move from AI pilots to real business transformation.”

Matthew Kerner, CTO, WSS CTO Management, Microsoft

What we built together, and why it matters

Acting as the “process glue” in the joint architecture is UiPath Maestro™, the orchestration layer that coordinates across the full multi-vendor stack. Not as a UiPath-specific orchestrator. As the layer that knows when to call which agent, what to do with the result, how to handle an exception, when to escalate to a person, and how to keep a complete record of everything that happened.

That distinction matters. An orchestration layer isn't just another agent in the chain. It's what makes agents from different vendors behave like a coherent system instead of a collection of disconnected automations.

We showcased four specific capabilities at Microsoft Build:

Bi-directional agent and workflow integration through MCP. Copilot Studio and Microsoft Foundry agents can discover and call any UiPath artifact—including UiPath Agents and Maestro workflows—through MCP.

And it goes the other way: UiPath Maestro™ can discover and invoke Microsoft agents through MCP. Neither side is locked into only working with its own agents. That flexibility is what makes genuine agent-to-agent collaboration possible at enterprise scale.

Conversational agents in Teams. Conversational UiPath Agents now operate in Microsoft Teams. Employees can ask for help, supply missing information, and check work status without leaving Teams. The process comes to where people already work, rather than asking them to go somewhere new.

Governed enterprise execution. UiPath Agents can soon be governed within Microsoft Agent 365—agent identity, lifecycle management, audit trails, and security/ privacy monitoring with Microsoft Defender and Purview. This is what turns a pilot into something a CIO can scale. Without it, every new department that spins up agents creates a new governance gap.

UiPath skills and CLI for GitHub Copilot developers. GitHub Copilot developers can now use UiPath skills and CLI to quickly build, validate, and run agentic automation on the UiPath Platform™. UiPath skills give GitHub Copilot the UiPath-specific context it needs—platform patterns, APIs, CLI commands, validation steps, and deployment guidance—so developer teams can build across flow automations, coded workflows, RPA, case management, and Maestro processes without leaving VSCode.

More than 400 customers are already using the bi-directional integration between Copilot and UiPath. Many of those implementations are task automations or early agentic pilots. The ones ready to scale have started treating orchestration as the architecture decision, not an afterthought.

What multi-agent orchestration looks like

The architecture is easier to understand through a real process. One of the use cases we walked through at Microsoft Build was insurance claims.

A first notice of loss (FNOL) submission arrives in a shared Outlook mailbox. A UiPath IXP (Intelligent Xtraction & Processing) agent extracts the key claim fields and attachments: policy ID, loss date, claimant, incident type, estimated damage, supporting documents. UiPath Maestro then runs a UiPath claims adjudication agent to apply policy rules, compute payouts, and detect duplicates.

For high-value or anomalous claims, Maestro discovers and calls a risk agent built using LangGraph, running on Microsoft Foundry and exposed as an MCP resource. That agent calculates a risk score based on proprietary algorithms. If the risk level and payout are both below the defined thresholds, the claim is automatically processed and UiPath automations trigger the next steps. If either threshold is exceeded, the claim is flagged for review with the extracted information and analysis from both the UiPath claims adjudication agent and the Foundry risk agent.

For review cases, adjusters work in Microsoft Teams and Copilot Studio. The Copilot Studio agent invokes the same UiPath automations, agents, and Foundry checks used in automated processing. An adjuster can ask the UiPath agent in Teams for a summary of open cases, ask it to pull and summarize the insurance contract, and identify the right approvers—all without leaving Teams. Once the claim is approved, the adjuster asks the UiPath agent to process the invoice, triggering a long-running Maestro workflow.

UiPath, Microsoft Foundry, Copilot Studio, and Teams each perform or help with a task. UiPath Maestro makes them act like one system, dynamically deciding which task should be performed based defined guardrails with process governance, real-time visibility, and audit trail.

The question scaling forces

An agentic pilot that works for claims is one thing. Scaling that architecture across claims, lending, disputes, servicing, and finance operations is a different challenge entirely—and it's the one most enterprises haven't fully reckoned with yet. The risk isn't that agents don't work. It's that every team builds their own agent in a silo, which creates several problems:

1. Nobody owns what happens between agents built on different platforms, which means things fall through the cracks

2. No matter how well Agents are built, missing enterprise context and data limits their performance

3. Access, policies, and guardrails are built inconsistently at an agent level, making management, enforcement, and security a nightmare

4. Agents talking to each other and a host of MCP servers soon starts looking like an unmanageable spider web that is difficult to understand, let alone track

With coding agents in everyone’s hands, clamping down on who can build and deploy AI agents is no longer a viable option. But left ungoverned, they create exactly the kind of fragmented, ungoverned landscape that enterprise IT has spent the last decade trying to clean up.

Standardizing on UiPath Maestro™ as the orchestration layer gives business users, process owners, and automation CoEs one place to manage, monitor, and govern end-to-end processes—with out-of-the-box process apps and dashboards built for the people running the work, not just the people who built it.

A standardized process layer also helps ensure that process data is captured in trusted data platforms such as SharePoint, Microsoft Fabric, and Dataverse. This allows agents to preserve context between handoffs and helps teams create user experiences in Teams, Copilot Studio, and Power Apps without creating new data silos.

Finally, Microsoft Agent 365 gives IT and security teams a unified control plane to observe, govern, and secure both Microsoft and UiPath agents across the enterprise. UiPath agent traces, available in Microsoft Defender and Microsoft Purview, allow IT teams to monitor and secure agent activity.

The architecture question that matters at scale is not “which agents should we deploy?”

It is “how do we govern everything we deploy, across every vendor and every process, without rebuilding the operating model each time?”

Where we go from here

The enterprise AI stack isn't going to consolidate around a single vendor. The organizations that understand this early will have an advantage—not because they have better AI, but because they've solved the harder problem of making all of it work together.

What UiPath and Microsoft put forward at Build isn't a product announcement. It's an answer to the question every enterprise is about to face: when the agents multiply, who governs the whole?

Start building today at www.uipath.com/developers.