- Introduction
- Démarrage
- Créer avec Maestro BPMN
- Compréhension de la modélisation BPMN de Maestro
- Ouverture du canevas de modélisation
- Modéliser votre processus
- Alignement et connexion des éléments BPMN
- Autopilot pour Maestro (aperçu)
- Référentiel de processus
- Implémenter un processus BPMN simple
- Implémenter un processus BPMN complexe
- Débogage
- Simulation
- Scénarios de mise en œuvre courants
- Building with Maestro Case
- Présentation de Maestro Case
- Maestro BPMN vs. Maestro Case : quand utiliser la gestion des incidents
- Le cycle de vie de Maestro Case : du déclencheur d'événement à l'expérience de l'application
- Créer votre premier incident avec Maestro Case
- Build a Maestro Case with a coding agent (preview)
- Définition des clés de cas (système vs. externe)
- Établissement des contrats d'E/S et de réécriture de la tâche
- Règles de sortie et fin de l’étape précoce
- Modélisation des étapes primaires et secondaires
- Déclencher un cas à partir de Data Fabric
- Implémentation des personas et des autorisations au niveau de l'étape
- Définition des SLA et des règles d'escalade automatisées
- Configuration d'une boucle de retraitement (renouvellement)
- Configuring and testing the Case Manager Agent (preview)
- Contrat d’entrée et de sortie du gestionnaire de cas
- Dictionnaire des composants de Maestro Case
- Créer avec Maestro Flow
- Intégrations
- Opérations
- Surveillance
- Optimisation
- Informations de référence
Use a coding agent such as Claude Code, Codex, or GitHub Copilot to plan, build, and deploy a Maestro Case from a prompt, BPMN model, process map, or PDD.
| Cas Maestro | BPMN Maestro | |
|---|---|---|
| Le contenu s'applique à | ✅ | ❌ |
Building a Maestro Case with a coding agent is in Public Preview.
Vue d'ensemble (Overview)
Coding agents are a primary way to build on UiPath. Point one at a Maestro Case and it takes you from idea to production — planning, building, debugging, and deploying the case — compressing what once took weeks or months into hours or days.
Maestro Case orchestrates long-lived, goal-driven work about a specific situation — a claim, a dispute, a loan application. Building one by hand means laying out stages, wiring the tasks inside them, and encoding the policy that moves a case forward. A coding agent does that work with you: you describe the case you want, it proposes a plan, and once you approve, it builds, debugs, and deploys the case in your solution. You use the coding agent of your choice, and you stay in control at every step.
Ce que vous pouvez créer
A coding agent takes a Maestro Case from an idea to a runnable plan. Today it can author and build:
- Case plans — the stages a case moves through, the tasks inside each stage, and the edges between them.
- Case and stage SLAs with escalation rules — a duration a case or stage is allowed to run, and what happens when it's breached (for example, escalate to a supervisor after two business days).
- Case transition rules — the WHEN / IF / THEN rules that govern entry, completion, exit, and re-entry, written from your business policy and SOPs so the case routes the way your operation actually works.
- Tasks — the agent can reference any task type from projects already in your tenant, and can build three types as net-new projects directly in the same solution:
- API Workflows — system-to-system and integration steps.
- Agents — reasoning-based work handled by a UiPath or external agent.
- Human-in-the-loop — forms, approvals, and clarifications assigned to a person.
How it works: plan, approve, build
The build follows a deliberate, review-gated flow:
- You give it a starting point — a prompt, a BPMN model, a process map diagram, or an existing PDD.
- The agent drafts a plan — it reads your input and proposes the stages, tasks, rules, SLAs, and escalations it intends to build, and shows it to you.
- You approve — the agent stops and waits for your review before it builds anything. You refine the plan in conversation until it's right.
- The agent builds — it authors the case plan and the task implementations, validates 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 case has been built and deployed.
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 case in plain language.
- A BPMN model — hand over an existing process model and the agent maps it to stages and tasks.
- A process map diagram — a flow or swimlane diagram of how the work runs today.
- An existing PDD — the process definition document your BA already wrote.
The agent turns any of these into a proposed plan first, then builds on your approval.
Fonctionne avec tous les principaux agents de codage
Maestro Case works with the coding agent your team already uses:
| Agent de codage | Facteur de formulaire |
|---|---|
| Claude Code | Terminal et IDE |
| Codex | Terminal et IDE |
| Copilot de GitHub | IDE |
| Curseur | IDE |
| Jules | Plateforme de développement agentique |
The Maestro Case authoring capability is delivered as a UiPath skill the coding agent uses — you're not locked into a single proprietary tool.
Ressources connexes
- Introduction to Maestro Case — concepts, use cases, and the toolset behind Maestro Case.
- Build your first Maestro Case project — a step-by-step tutorial for creating, deploying, and testing a case by hand.
- Configuring and testing the Case Manager Agent (preview) — the runtime AI orchestrator for a deployed case, distinct from this build-time coding-agent workflow.