- Introduction
- Getting started
- Build on any canvas
- Build with Case
- Reference
- Defining case keys (system vs. external)
- Establishing task I/O and write-back contracts
- Modeling primary and secondary stages
- Triggering a case from Data Fabric
- Implementing stage-level personas and permissions
- Setting SLAs and automated escalation rules
- Configuring a rework loop (re-entry)
- Configuring and testing the Case Manager Agent (preview)
- Build with Flow
- Build with BPMN
- Operating
- Monitoring
- Optimizing
- Reference information
Choosing a canvas
Choose between the Case, Flow, and BPMN canvases of Maestro Orchestrate, based on how your team prefers to model and on how well each canvas fits the process.
Case, Flow, and BPMN are the three canvases of Maestro Orchestrate. They run on the same engine, use the same platform services, such as agents, Integration Service, RPA, Action Center, and Data Fabric, and show their instances in the same Instance Management.
A business process can be built on any of the three canvases. The choice depends on how your team prefers to model, and on which canvas fits the shape of the process best. If your workflows finish within 24 hours, check first whether Maestro Automate fits better: Maestro Orchestrate or Maestro Automate? compares the two products.
Start from how your team works
Each canvas suits a way of working.
Case fits when:
- Your team thinks of the work as stages that a case moves through, with rules that decide when it moves.
- Business users need a ready-made workspace, the Case App, to work on cases and track them.
Flow fits when:
- You prefer a visual experience aimed at automation developers.
- You want to build with coding agents such as Claude or Codex, which Flow supports in general availability.
BPMN fits when:
- Your team already uses Business Process Model and Notation (BPMN) as the common language for design and implementation.
- Your team must follow the BPMN standard for compliance or governance reasons.
- You are extending an existing BPMN process.
BPMN also supports building with coding agents, in Public Preview. Ways to build describes the options for every canvas.
Consider the shape of the process
The same process can run on any canvas. Some canvases model a given shape more directly:
- When the steps and branches are known at design time, Flow and BPMN model the path directly, even when individual steps, such as agents, reason non-deterministically.
- When the next step depends on what just happened, with rework, stage-level service-level agreements (SLAs), and a workspace for case workers, Case models the work directly, through stages and rules.
Duration doesn't distinguish the canvases. A Flow or BPMN process can run as long as a case. The difference is whether the path through that time is set at design time or decided at runtime.
Processes such as purchase-to-pay, loan origination, insurance claims, supplier onboarding, and Know Your Customer (KYC) checks can be built on any of the three canvases.
Compare the canvases
| Case | Flow | BPMN | |
|---|---|---|---|
| Structure | Stages with dynamic, rule-driven transitions | Sequence of nodes with branching and loops | Directed, sequence-based diagram |
| Path | Determined at runtime by rules and Case Manager agent decisions | Defined at design time | Defined at design time |
| Exception handling | Re-entry rules, secondary stages, ad-hoc tasks | Branching and error handlers | Branching and error handlers |
| Rework | Built-in re-entry with selective task re-execution | Modeled as explicit loops | Modeled as explicit loops |
| Data model | Case variables scoped to the instance, and a persistent case entity [Coming Soon] shared by all stages | Process variables scoped to the instance | Process variables scoped to the instance |
| SLA tracking | Case-level and stage-level SLAs with escalation rules | Not stage-aware | Not stage-aware |
| Lifecycle controls | Pause, resume, reopen, migrate | Start, cancel | Start, cancel |
| Human collaboration | Role-based access scoped to stages (Case Workers, Case Managers) | Task assignment within the flow | Task assignment within the process |
| AI agent role | Runs as tasks, and orchestrates the whole case lifecycle as the Case Manager agent | Runs as tasks within the flow | Runs as tasks within the process |
| Business user experience | Case App with case lists, detail views, task inboxes, and dashboards | Monitoring dashboard | Monitoring dashboard |
| Audit trail | Full case history: every stage transition, task outcome, decision, and entity change | Process instance log | Process instance log |
| Decisioning | Rules (Decision Model and Notation, DMN), agent, or both | Decision and Switch nodes | Gateways and DMN |
| Project format | Case plan | .flow | .bpmn |
| Typical builder | Case designer, operations lead | Developer | Process architect, Business Process Management (BPM) practitioner |
Combine canvases
The canvases work together. A case task can call a BPMN process through the Agentic process task type: the BPMN process runs with its own logic and returns a result to the case. This suits a stage that contains a well-defined, linear subprocess, such as a multi-step audit. A BPMN process can also call a case as one of its task types.
A case can also start a Child Case, another case definition with its own lifecycle, stages, and tasks, linked to the parent case through its case ID. For example, a claim can start an investigation that progresses independently.
All three canvases deploy to Orchestrator, so processes built on any canvas can call each other, within the same organization.
Related pages
- Introduction to Case: the Case Manager agent, stages, rules, and the other Case concepts.
- What is Flow?: an overview of Flow.
- Understanding BPMN modeling: an overview of BPMN modeling.