Multi-Agent Orchestration and Deployment
A single agent built in Agent Builder can only take you so far. Real business processes usually involve more than one decision, more than one system, and often more than one agent working together with existing robots and people. This page covers how to grow from a single published agent into a coordinated process using Maestro, and what actually changes once an agent is live.
From one tool to several
When you first publish an agent, it's tempting to keep adding tools to it so it can handle more and more of a process by itself. Be careful with this. Every tool you add is another thing the agent has to correctly reason about when deciding what's relevant to a given case, and an agent with a dozen loosely related tools tends to make worse decisions than one with three or four tools it clearly understands. If a process genuinely has several distinct phases, it's usually a better idea to build a few smaller agents, each responsible for one phase, than one large agent trying to do everything.
Why Maestro exists
This is where Maestro comes in. Rather than cramming more capability into a single agent, Maestro lets you define the end-to-end process as a visual, BPMN-based diagram: agent does this, robot does that, human approves this step, then the next agent picks up. Maestro is the layer that gives you a single, unambiguous picture of how a whole business process flows, even when it spans multiple agents, existing RPA robots, and human steps.
This separation matters for a practical reason. An individual agent in Agent Builder is scoped to a specific decision. Maestro is scoped to the whole journey a case takes from start to finish. Keeping these separate makes both easier to reason about: you can improve one agent's judgment without having to understand the entire process, and you can redesign the overall process flow without needing to touch how any individual agent makes its decisions.
Coordinating agents and existing robots
One of the more useful patterns in UiPath's approach is that Maestro can integrate agents built in Agent Builder, existing UiPath Robots, and even external LLM-based agents into the same orchestrated workflow. In practice, this means you don't need to rebuild automation that already works. If a robot already handles data entry into a legacy system reliably, an agent can decide what needs to happen and hand off the mechanical execution to that robot exactly as before. Maestro manages the handoff and the fallback logic if something goes wrong along the way.
Designing good handoff points
When you're mapping a process in Maestro, the handoff points between agents, robots, and humans are usually where things go wrong if they're not designed carefully. A few things worth getting right:
Be explicit about what information passes at each handoff. If an agent hands a case to a human for approval, that human needs enough context to actually make an informed decision, not just a bare notification that something needs review.
Decide what happens on failure at every step, not just the happy path. If a tool call fails or an agent can't reach a confident decision, Maestro needs a defined fallback rather than the process silently stalling.
Keep escalation criteria consistent across the whole process. If two different agents in the same Maestro flow use different thresholds for when to involve a human, the overall process will feel inconsistent to the people relying on it.
Deploying and monitoring through Orchestrator
Individual agents and robots are deployed and managed through Orchestrator, which is also where you monitor real runs once a process is live. This is where you'll track which agent or robot handled each case, how often escalations fired, and where cases are getting stuck. Treat this monitoring as an ongoing responsibility rather than a one-time launch checklist. An agent's real-world performance can drift as the mix of cases it sees changes over time, and Orchestrator's run history is usually the first place that drift becomes visible.
What's next
Once you have a working Maestro process, the natural next step is expanding it carefully: adding a second agent for a related decision, tightening escalation rules based on what you've observed in production, and periodically reviewing whether any of your existing robots could be replaced with more adaptive agent logic now that you have real data on where the fixed-script approach breaks down.