- 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
Subprocesses and modularity
Build modular Maestro Orchestrate processes using subprocesses to group related activities, reduce diagram complexity, isolate business logic, and enable reuse across inline and reusable models.
Subprocesses support model clarity by grouping related activities into a single reusable structure. They help reduce diagram complexity, isolate business logic, and encourage reuse.
In BPMN, a subprocess can be modeled either inline (collapsed or expanded within the same diagram) or as a reusable call activity.
In Maestro Orchestrate:
- Inline subprocesses (collapsed or expanded) are supported for grouping and structuring logic within the same diagram.
- Call activities are supported for invoking a separate agentic process (project).
- Calling a different BPMN file from the same project is not supported. For reusable cross-process logic, create a separate agentic process and invoke it using a Call Activity.
- When using a Call Activity, the calling process passes input and receives output via explicitly defined parameters.
Why use call activities?
A call activity references a subprocess defined elsewhere in the project or environment. It behaves like a reusable function. call activities improve process modeling by:
- Reducing duplication across diagrams
- Isolating reusable logic (e.g., approvals, validations, dispatching)
- Keeping the main diagram concise
- Supporting consistent behavior across process variants.
How to model subprocesses
In Maestro Orchestrate, you can model subprocesses in two ways:
- As an inline subprocess (collapsed or expanded within the same diagram)
- As a reusable subprocess using a Call Activity
Model an inline subprocess
Use an inline subprocess when you want to group related steps within the same process instance.
-
Insert a SubProcess element into your BPMN diagram.
-
Choose whether to display it in collapsed or expanded view.
-
Model the internal logic directly inside the subprocess.
-
Use the subprocess to group related steps while keeping the main diagram readable.
Result: The subprocess is inserted and internal logic can be modeled inside it.
Inline subprocesses execute within the same process instance and share the same execution context.
Variables in subprocesses
Variables behave the same way in collapsed and expanded subprocesses. The view only changes how the subprocess is displayed on the canvas.
A variable created inside a subprocess is scoped to that subprocess. Elements after the subprocess can't reference it directly. A value becomes available outside the subprocess only after it's exposed as an output, in one of these ways:
- Adding an output on the subprocess element and mapping it to the inner variable.
- Declaring an output variable on the subprocess end event.
For step-by-step instructions, see Exposing outputs from a subprocess.
If an element outside the subprocess references an inner variable that isn't exposed, Studio Web shows the validation warning Variable '<name>' is not set at this point in the flow.
When you move a node containing outputs into or out of a subprocess, Maestro Orchestrate preserves variable IDs and manages scope transitions automatically. Variable references remain valid across scope boundaries, and orphaned entries are automatically removed.
If you encounter validation errors after moving nodes between scopes, use the Fix variables dialog to identify and update any broken references.
Model a reusable subprocess using a Call Activity
Use a Call Activity when you want to reuse logic across multiple processes.
-
Create a separate Agentic process (project) that contains the reusable logic.
-
In the parent diagram, insert a Call Activity.
-
Select the target Agentic process to invoke.
-
Configure input and output variables to exchange data between the parent process and the called process.
Result: The Call Activity is configured to invoke the separate agentic process with mapped input and output variables.
A Call Activity invokes a separate Agentic process instance. Data must be explicitly mapped between the parent and called processes.
Modeling examples
Use case: An onboarding workflow uses the same Collect Documents subprocess in both employee and vendor onboarding processes. Instead of duplicating steps, a call activity is added in each parent process referencing the same subprocess.
Use case: This subprocess example shows a conditional file download and upload workflow in Maestro Orchestrate. The process begins with a message start event and branches using an exclusive gateway.
Depending on the condition, it either downloads an email attachment or a file from a record field. Both paths converge into an Upload File task, followed by a SubProcess element named Sub-Process1 that encapsulates post-upload actions before the workflow completes.
Naming conventions
Subprocess and call activity names should:
- Use business language, not technical terms
- Describe the outcome (e.g.,
Collect Customer Data, notForm Step 2) - Reflect what the subprocess accomplishes, not how.
- Participant lanes are not supported inside subprocesses.
Not supported
- Calling a separate BPMN file within the same project is not supported.
- For reusable logic across multiple processes, create a separate agentic process (project) and invoke it using a Call Activity.
- Ad-hoc subprocesses are not supported.
- Implicit variable sharing across process boundaries is not supported. Data must be explicitly mapped through input/output bindings.
- Participant lanes are not supported inside subprocesses.
Multi-instance markers
Inline subprocesses support multi-instance execution.
Call Activities also support multi-instance execution when invoking a separate Agentic process.
Ad-hoc subprocesses and event subprocesses are not supported.
For more details about the BPMN elements supported in Maestro Orchestrate, see BPMN support.