# Build a Maestro BPMN with a coding agent (preview)

> Coding agent workflow for planning, building, and deploying a Maestro BPMN process from a prompt, process map, PDD, or existing BPMN model.

| | Maestro BPMN | Maestro Case |
|---|---|---|
| Content applies to | ✅ | ❌ |

:::note
Building a Maestro BPMN process with a coding agent is in **Public Preview**.
:::

## Overview

Coding agents are a primary way to build on UiPath. Point one at a Maestro BPMN process and it takes you from idea to production — planning, building, debugging, and deploying the process — compressing what once took weeks or months into hours or days.

Maestro BPMN models structured, repeatable business processes as visual, executable Business Process Model and Notation (BPMN) 2.0 diagrams: events, tasks, gateways, sequence flows, and the participants (pools and lanes) who carry out each step. 

Building one diagram by hand means laying out the diagram, wiring the implementation behind each task, and configuring the gateway logic and error handling that keep the process correct. 

A coding agent does that work with you: you describe the process you want, it proposes a plan, and once you approve, it builds, debugs, and deploys the process in your solution. You use the coding agent of your choice, and you stay in control at every step.

## What you can build

A coding agent takes a Maestro BPMN process from an idea to a runnable model. Today it can author and build:

- **Process models** — the events, tasks, gateways, and sequence flows that make up the diagram, and the participants (pools and lanes) that own each step. This includes the full event set — start events (manual, message, timer, or queue-triggered), intermediate and boundary events (message, timer, or error-based, interrupting or non-interrupting), and end events.
- **Task implementations** — the agent can reference any task type from projects already in your tenant, and can build these directly as part of the same solution:
  - **Service tasks** — invoking automations or APIs.
  - **User tasks** — human-in-the-loop steps, with assignees, task forms, inputs and outputs, and escalations.
  - **Send tasks** — a synchronous outbound call to an external system through an Integration Service connector activity.
  - **Receive tasks** — pausing execution to wait for an inbound trigger from an external system through a connector event.
  - **Script tasks** — decision expressions and flow logic.
- **Gateways and flow logic** — exclusive, parallel, inclusive, and event-based gateway conditions that route the process.
- **Error handling and recovery** — boundary events for task-level exceptions, and event subprocesses for centralized, process-scoped or subprocess-scoped error and message handling. Error subprocesses always interrupt the enclosing scope, and ad-hoc subprocesses are not supported.
- **Modularity** — inline subprocesses for grouping logic within a diagram, and Call Activities for invoking a separate, reusable agentic process. Maestro doesn't support calling a different BPMN file within the same project.
- **Multi-instance patterns** — the multi-instance marker, which repeats a task sequentially or in parallel over a collection. This is the one marker Maestro interprets at runtime — other markers are for diagram clarity only.

## How it works: plan, approve, build

The build follows a deliberate, review-gated flow:

1. **You give it a starting point** — a prompt, a process map diagram, an existing process definition document (PDD), or a rough BPMN model.
2. **The agent drafts a plan** — it reads your input and proposes the events, tasks, gateways, sequence flows, and participants it intends to build, and shows it to you.
3. **You approve** — the agent stops and waits for your review before it builds anything. You refine the plan in conversation until it's right.
4. **The agent builds** — it authors the process model and the task implementations, validates and simulates them, and reports back. You can publish, run, and test from the same conversation.

Because the agent pauses for your approval before building, incorrect assumptions are caught at the plan stage, rather than after a process has been built and deployed.

:::note
Data objects, data stores, and text annotations are diagram-only in Maestro. They document how data moves for readability, but don't affect execution. The agent wires runtime data through task inputs and outputs and the Variables and Expression editor, the same way a person building the process by hand would.
:::

### Start from what you already have

A coding agent meets your process where it is. Any of these is a valid starting point:

- **A prompt** — describe the process in plain language.
- **A process map diagram** — a flow or swimlane diagram of how the work runs today.
- **An existing PDD** — the document your business analyst already wrote.
- **An existing BPMN model** — a diagram you or someone else has already started.

The agent turns any of these into a proposed plan first, then builds on your approval.

## Works with any major coding agent

Maestro BPMN works with the coding agent your team already uses:

| Coding agent | Form factor |
|---|---|
| Claude Code | Terminal and IDE |
| Codex | Terminal and IDE |
| GitHub Copilot | IDE |
| Cursor | IDE |
| Jules | Agentic development platform |

The Maestro BPMN authoring capability is delivered as a UiPath skill the coding agent uses — you're not locked into a single proprietary tool.

## Related resources

- [Understanding Maestro BPMN modeling](understanding-process-modeling.md) — what BPMN 2.0 modeling is and where it fits in Maestro.
- [BPMN primer](bpmn.md) — the core BPMN concepts this capability builds on: events, tasks, gateways, and sequence flows.
- [Events in BPMN](events-in-bpmn-modeling-perspective.md) — start, intermediate, boundary, and end event types.
- [Tasks in BPMN modeling](tasks-in-bpmn-modeling.md) — the task types a coding agent can build.
- [Gateways and flow logic](gateways-flow-logic.md) and [Markers](markers.md) — routing logic and the multi-instance marker.
- [Subprocesses and modularity](subprocesses-and-modularity.md) — inline subprocesses and Call Activities.
- [Implementing a simple process](how-to-simple-process.md) and [Implementing a complex process](how-to-complex-process.md) — building the same kind of process by hand.
- [Simulating](simulate.md) and [Debugging](debugging.md) — validating a process before and after deployment.