maestro
latest
false
  • Overview
    • Introduction to UiPath Maestro™
    • Requirements
    • Example scenarios
  • Process modeling
  • Process implementation
  • Process operations
  • Process monitoring
  • Process optimization
  • Reference information
UiPath logo, featuring letters U and I in white

Maestro user guide

Last updated Apr 30, 2025

Process configuration

You can configure an agentic process model with runtime implementation instructions via the canvas integrated within UiPath® Studio Web. Studio Web enables you to implement, test, and deploy Maestro models using advanced developer tools that are tailored to your process needs. This unified developer experience allows you to create processes powered by automations, AI agents, human-in-the-loop tasks and system of record connections, which are then executed on a dedicated process engine.

Start importing a BPMN model, or drawing new one, or using Autopilot™ for Maestro to help you along. See for canvas features details.

Properties panel

A business process is primarily implemented by selecting elements and configuring them through the properties panel. You can access the properties panel by selecting the wrench icon in the upper right-hand corner.

The Properties panel has several sections for configurations depending on the element.

Next to the Properties tab, that you use for configuration, you can find the XML tab, used primarily for support purposes.

The XML tab is there for you if you want to inspect, manipulate, and apply changes, but we do not expect you to need to edit it directly.

If you want to know the supported elements in the BMPN XML, check out BPMN Specification - Business Process Model and Notation.

General

  • Name - the label you see on the canvas
  • ID - the system generated unique ID. This is the value used to reference the element in other properties and expressions
  • Description - additional details for the element

Implementation

Type specific details for the selected element, such as Start and wait for automation or Start and wait for agent for a Service Task element.

Inputs

Inputs for the selected element may include required fields.

Outputs

Outputs for the selected element. These outputs will be available as variables, and you can use them within expressions in other elemets.

Note:

Configuring Start event inputs and End event outputs enables you to populate input arguments when initiating the process from the Orchestrator interface or API. This also allows you to return output to any aforementioned sources.

Variables and Expression editor

Use the tune selector next to a Properties panel input field to switch between text, variables, and expressions.

  • Use variable - select existing variable or element output value
  • Open expression editor - build complex expression
  • Use JSON editor - use JSON editor to create inputs or outputs
  • Use datetime - use date time picker
  • Use Data Fabric - use properties from Data Fabric entity

Use Variables to configure element properties and pass values between your elements, automations, agents, app tasks, and connections. Element outputs are automatically available as variables throughout the process.

Use the Expression editor to write more complex expressions to configure element properties. The Expression editor is available for most element properties and features intelligent code completion for variables, arguments, methods, properties, objects, or keywords. You can write expressions, and use Ctrl + Space to see the list of available options.

Open the Variable selection panel to select a variable, argument, or property. Provide and test values by using the Test button on the top-right of the Validate expression panel. The test input values serve solely for verifying the accuracy of the expression. Their function is to ensure the expression runs correctly and produces the anticipated output in accordance to the provided inputs.

Use the text bar on the bottom of the Expression editor to describe your expression and get instant help from Autopilot™.

Note: Read the DynamicExpresso GitHub documentation for information on authoring expressions.


Tasks

Tasks provide the building blocks for process execution. UiPath Platform™ capabilities are accessed via standard BPMN task types.

Service Task

Used to configure a call to start and wait on execution external to the process engine, typically to another UiPath service, such as automation, agent, or queues.

Workflows

Supports deployed Workflows.

Implementation > Type: Start and wait for RPA workflow.

Agents

Supports deployed agents.

Implementation > Type: Start and wait for RPA workflow.

Supports external agents

Implementation > Type: Start and wait for external agent. Some example external agents are CrewAI, SalesForce, and ServiceNow.

Queues

Supports deployed Queues.

Implementation > Type: Create and wait for queue item.

User Task

Used to configure a step in the process execution that requires a human-in-the-loop to perform. This step can contain details for the assignees, task form, inputs, outputs, and escalations. The process execution pauses at this step until an assignee has completed the task.

Supports deployed Action Center Action apps.

Implementation > Type: Create action app task.

See Action Center - Action apps for more details on building and configuring Action apps for Action Center.

Send Task

Used to configure a call to an external system. Process execution makes the call and completes in synchronous nature.

Supports Integration Services connector activities, including custom connectors.

Implementation > Type: Execute connector activity.

Receive Task

Used to configure a trigger from an external system. Process execution pauses and waits for the configured trigger to occur before continuing with execution.

Supports Integration Services connector triggers, including custom connectors.

Implementation > Type: Wait for connector event.

Business Rule Task (Public Preview)

Used to configure the execution of a Business Rule (DMN). Process executionmakes the call and completes in synchronous nature.

Supports Business Rules in DMN 1.3 stored in Orchestrator.

Implementation > Type: Execute Business Rule.

Markers

Use markers to configure the execution of a certain task type to create multiple executions by iterating over a List variable.

With any task type selected, select Change element and choose one of the marker types.

Parallel multi-instance

The task executes in parallel and waits for all runs to be completed successfully before continuing to execute the rest of the process.

Sequential multi-instance

The task executes each item in the list one by one, waiting for each to be completed successfully before starting the next one. Once all tasks are completed, the rest of the process continues executing.

Gateways

Gateways control the flow of your process. You can configure condition logic to determine which path to take. Once the paths are drawn, you can set the condition logic either via the path line or directly on the gateway.

Exclusive gateway

An exclusive gateway allows only one outgoing path to be followed based on the evaluation of conditions. It checks each condition in order and follows the first one that evaluates to true.
  • If no conditions evaluate to true, and a default path is defined, the process follows the default path.
  • If no conditions are true and no default path is defined, the process execution fails.

Defining a default path

In Maestro, you can mark a path as the default. In XML notation, this is done using the default attribute on the <exclusiveGateway> element.

Merging behavior

An exclusive gateway waits for one incoming execution before continuing. It acts as a decision point, allowing only one of several potential paths to proceed.

Inclusive gateway

An inclusive gateway allows multiple outgoing paths to be followed in parallel, depending on which conditions evaluate to true.
Fork behavior
  • For all outgoing paths where the condition evaluates to true, the process follows each in parallel.
  • One concurrent execution is created for each selected path.
Join behavior
  • The inclusive gateway waits for an execution to arrive from each incoming sequence flow that was activated upstream.
  • Once all expected tokens have arrived, the gateway merges them and the process continues.

Parallel gateway

A parallel gateway is used to either:

  • Fork: Split the process into multiple parallel paths. All outgoing paths are followed, with no conditions required.
  • Join: Merge multiple parallel paths into a single flow. The gateway waits for all incoming executions before proceeding.

Event gateway

An event gateway waits for one of multiple possible events before proceeding. Execution pauses until one of the events is triggered. Each path must begin with an intermediate catch event, such as:

  • Timer event
  • Message event

Events

Events provide the ability to capture when something happens during process execution. There are three main types of events in process diagramming: start, intermediate, and end events. These events are also referred to as either "catching" events, which react to a trigger, or "throwing" events.

The UiPath platform supports the following event types and implementations:

  • Start events behave as catching events. They are triggered by:
    • Message events (waiting for an event trigger from Integration Service)
    • Timer events (time-based triggers)
  • Intermediate catching events behave similarly to start events. They wait for a message, timer, or API trigger during process execution.

  • Boundary events are a special type of intermediate catching event attached to a task. They can be configured as:

    • Interrupting boundary events: When the attached task starts, the boundary event waits for its trigger. If triggered while the task is still executing, it interrupts the task and continues along the boundary event's outgoing path. Interrupting boundary events can be triggered by Timer, or Message events.
    • Non-interrupting boundary events: When triggered, they create a new execution token and continue along a parallel path without interrupting the original task execution. Non-interrupting boundary events can be triggered by Timer and Message events.
  • Intermediate throwing events actively send a trigger. For example:

    • A message intermediate throwing event acts like a Send Task, invoking an Integration Service API execution.
  • End events mark the completion of a process and behave as throwing events. They can be:
    • Error end events, which complete the process instance and fault the Orchestration Runtime (OR) job.
    • Message end events, which send a message as the process concludes.
    • Terminate end event, which cancels all other execution paths/tokens, especially when multiple branches run in parallel.

Subprocesses

A subprocess is a collection of other tasks and subprocesses that helps to split a complex process into more manageable and navigable parts.
Note:
  • Opt for a Call activity when you need to use an additional process either within the same project or from a separate project. Such an agentic process, with an independent value, can be invoked either as a self-contained process or by other processes, triggering the creation of a new instance automatically.
  • Use a subprocess when there's a requirement to encapsulate specific logic, thereby augmenting the parent process's simplicity. As an inherent part of the same instance, the subprocess contributes to streamlining the overall orchestration.

See Process Modeling for additional details on BPMN support.



Multi-instance markers

Subprocesses support multi-instance markers, where each element is executed multiple times. The elements that can be marked as multi-instance are all task types except for subprocesses.

Nested markers

The following string variables string are supported as nested iterators:
CategoryAttributesHow to use/access
OuterSP - Get Contact Information for each user InputCollectionvar.GetUsers
OuterSP - Get Contact Information for each user Iterator Itemiterator.item.gid
InnerSP - Get all emails for each contact InputCollectioniterator[0].item.contactArray
InnerSP - Get all emails for each contact Iterator Itemiterator[1].item.ContactId
Send EmailInputCollectioniterator[1].item.EmailArray
Send EmailIterator Itemiterator[2]item.emailAddress

Was this page helpful?

Get The Help You Need
Learning RPA - Automation Courses
UiPath Community Forum
Uipath Logo White
Trust and Security
© 2005-2025 UiPath. All rights reserved.