- Get started
- Best practices
- Capabilities
- Skills
- CLI
- Examples
- Examples overview
- Recipe: build an agent
- Recipe: automate with RPA
- Recipe: enter data into a web app
- Recipe: extract data from a desktop app
- Recipe: refactor and test a workflow
- Recipe: a queue-based process with REFramework
- Recipe: build a Maestro Flow
- Recipe: build a Maestro Case
- Recipe: coded app and API workflow
- Recipe: build a coded function
- Recipe: verify a release with Test Manager
- Recipe: extract data from documents with IXP
- Advanced
- Help
Case Management applications for long-running, exception-heavy work about a specific situation, such as a claim, a dispute, or a loan application, built with phased validation and human review gates.
A Maestro Case orchestrates long-running, exception-heavy work about a specific situation — a claim, a dispute, a loan application — through stages, tasks, and business rules until it resolves. With a coding agent, you describe the case, review a decision-first design packet, and the agent builds a runnable caseplan.json, then helps you validate, publish, and run it.
What you build
A Maestro Case moves a single case instance through stages, each holding the tasks that need to happen while the case is in it. It suits work that is unpredictable and long-running rather than a fixed sequence: a dispute that might escalate, pause, or reopen; a claim that needs different reviewers depending on its value.
What a case is built from
- Stages and tasks — the tasks inside each stage, referencing existing tenant resources or built as new API workflows, agents, or human-in-the-loop steps in the same solution.
- Transition rules — the conditions that move a case forward: entry, completion, exit, and re-entry rules written from your business policy.
- SLAs and escalations — a duration a case or stage is allowed to run, and what happens when it's breached, such as escalating to a supervisor.
The full lifecycle
| Stage | What your coding agent does | Example prompt |
|---|---|---|
| Design | Proposes the case's stages, tasks, rules, and SLAs from your description, and shows you one decision-first review before building anything. | Set up a dispute-resolution case with stages and milestones. |
| Build | Authors and validates the case definition (caseplan.json) from the approved design. | Build it — pause at the mid-build preview so I can check it in Studio Web. |
| Publish | Publishes to Studio Web for a visual preview, and to Orchestrator when you're ready to run it live. | Publish this case to Studio Web. |
| Debug | Runs the case for real against live connections, on your explicit approval. | Run a debug session for this case with a sample claim. |
The skill behind it
This work is powered by the uipath-maestro-case skill, which authors Case Management applications with phased validation. It hands the design step to the uipath-planner skill when no design document exists yet, then builds, validates, and publishes the case once you approve the design. You can see it in the Skills catalog.
A typical starting prompt
A first request might look like this:
"Set up a dispute-resolution case with stages and milestones: intake, investigation, and resolution, with an escalation to a supervisor if investigation runs longer than three business days."
The agent proposes the full design — stages, tasks, rules, and SLAs — for your review before it builds anything.
More prompts to try
- Build a loan-application case with stages for intake, credit check, underwriting, and decision, routing to manual underwriting when the automated credit check is inconclusive.
- Add an escalation rule so a case notifies a supervisor if it's in the investigation stage for more than two business days.
- Publish this case to Studio Web so I can preview it before it goes live.
Go deeper
For the full picture of Case Management, see Build a Maestro Case with a coding agent.