BPMN palette

Every element you can drop on the Process Designer canvas, grouped by BPMN category. Each row lists the element, its standard BPMN semantics, and how Superprocess uses it. If you want the conceptual introduction instead, see BPMN basics.

The palette also holds editor tools at the top — hand (pan), lasso (select), space (make room), and global-connect (draw a connection) — which manipulate the canvas rather than add elements.

Start events

Where a process begins. Drawn as thin-bordered circles; the icon inside indicates the trigger.

Element	Icon	Semantics
None	—	Starts via a manual run or an API call
Timer	Clock	Starts on a schedule
Message	Envelope	Starts when an inbound message matches — the way inbound email and webhooks trigger a process
Signal	Triangle	Starts when a named signal fires
Conditional	Lines	Starts when a condition over data becomes true
Error	Lightning	Starts an event sub-process in response to an error
Escalation	Arrow	Starts an event sub-process on an escalation
Compensation	Rewind	Starts an event sub-process to compensate completed work

Intermediate events

Happen partway through a flow. Drawn as thin double-bordered circles. Catch events wait for something; throw events emit something.

Element	Catch / Throw	Semantics
Timer	Catch	Wait for a duration or until a time
Message	Catch / Throw	Wait for a message, or send one
Signal	Catch / Throw	Wait for a named signal, or fire one
Conditional	Catch	Wait until a data condition becomes true
Escalation	Throw	Raise an escalation
Compensation	Throw	Trigger compensation of earlier activities
Link	Catch / Throw	Off-page connector — jump between two points in the same diagram

End events

Terminate a branch. Drawn as thick-bordered circles.

Element	Icon	Semantics
None	—	Ends the branch successfully
Error	Lightning	Ends with a named error
Terminate	Filled circle	Ends the whole process, stopping all parallel branches
Message	Envelope	Sends a message as the branch ends
Signal	Triangle	Fires a signal as the branch ends
Escalation	Arrow	Raises an escalation as the branch ends
Cancel	X	Cancels the enclosing transaction sub-process
Compensation	Rewind	Triggers compensation as the branch ends

Gateways

Decision points. Drawn as diamonds; the icon inside sets the behaviour — don’t mix them up.

Element	Icon	Semantics
Exclusive	X	Take exactly one outgoing branch, based on condition expressions
Parallel	+	Fan out to all branches; a matching merge waits for all to finish
Inclusive	O	Take every branch whose condition is true (one or more)
Event-based	Hexagon	Wait for one of several events; whichever fires first wins
Complex	*	Advanced merge/branch logic that the simpler gateways can’t express

Tasks

Where work happens. Drawn as rounded rectangles; the icon in the top-left indicates the type, and the right-hand panel configures it.

Element	Icon	Semantics	How Superprocess binds it
Task	—	An abstract, undifferentiated step	Placeholder; usually you pick a specific task type instead
Service task	Gear	Automated work	Bind an AI agent or a connector (see below)
Script task	Scroll	Run a script	Bind a published function (Python) and map its inputs
Business rule task	Table	Evaluate a rule set	Bind a DMN Decision table; the result is written back to a variable
User task	Person	Work requiring a person	Bind a form, an assignee group, and an assignment strategy
Manual task	Hand	Work done entirely outside the system	No automation — a documented step a person performs off-platform
Send task	Filled envelope	Send a message to an external party	Target and message
Receive task	Empty envelope	Wait for an inbound message	Message name and correlation
Call activity	Plus	Run another process as a sub-flow	Target process, input/output mapping

Service-task types

On the current execution engine, a service task is one of:

Type	What it does
AI Agent	Execute with a configured AI agent — for cognitive work (extraction, classification, summarisation)
SDK Connector	Call an operation on an installed connector from the catalog — Slack, database, HTTP/API, S3 file storage, Kafka, email, SMS, HubSpot, Google Sheets, and more
Generic	A placeholder service task with no binding yet

Legacy inline integrations

Processes built on the older codegen execution engine could configure integration operations inline on a service task (API call, database, webhook, Slack, Kafka, email, document, file storage, CSV, SMS, HTTP polling, Google Sheets, HubSpot). That path is frozen: existing tasks still run and show a migration notice, but new integrations are authored as catalog connectors instead.

Sub-processes

Group a section of flow into a nested process. Drawn as rounded rectangles with a + marker when collapsed.

Element	Semantics
Embedded sub-process	A block of steps that runs inline within the parent
Event sub-process	A sub-process triggered by an event (error, escalation, compensation) rather than a sequence flow
Transaction	A sub-process with all-or-nothing semantics; a cancel end event rolls it back
Ad-hoc sub-process	Steps inside can run in any order until an end condition is met

Data

Annotate the data a process reads and writes. Presentational — they document intent without changing runtime behaviour.

Element	Semantics
Data object	A piece of data produced or consumed by an activity
Data store	A persistent store the process reads from or writes to

Sequence flows

Arrows connecting elements. Drawn as solid lines with an arrow head.

Element	Semantics	Superprocess properties
Sequence flow (normal)	After source completes, target runs	—
Conditional flow	Out of an exclusive or inclusive gateway, taken if its condition is true	Condition expression
Default flow	Out of an exclusive or inclusive gateway, taken if no other condition matches	Marker on one outgoing arrow

Condition expression syntax: a boolean expression that can reference process variables by name. Example: amount < 10000 && po_matched == true. Operators: comparison (<, >, ==, !=, <=, >=), logical (&&, ||, !), arithmetic (+, -, *, /). String literals in single or double quotes; null check with var != null.

Collaboration & artifacts

Structure and annotate a diagram. These don’t change runtime behaviour but make it readable.

Element	Semantics
Pool / Participant	An outer container representing a participant in the process
Lane	A horizontal band inside a pool, grouping elements by role or system
Group	A free-form dashed rectangle around elements for visual emphasis
Text annotation	A note attached to an element

Markers

Small overlays on activities that change how the activity runs.

Marker	Where it applies	Semantics
Loop (↻)	Activities	Repeat the activity until a condition is met
Multi-instance parallel (‖‖)	Activities	Run N copies of the activity in parallel
Multi-instance sequential (≡)	Activities	Run N copies of the activity one after another
Compensation (←)	Activities	This activity reverses an earlier one when a compensation event fires

What's not in the palette

Standard BPMN includes constructs the platform doesn’t give runtime meaning — choreography and conversation diagrams, and message flows between pools. Pools and lanes are available for structuring a diagram, but the runtime executes a single process; treat cross-pool messaging as documentation, and reach for a sub-process or a separate process when you need real coordination.

Related

BPMN basicsThe conceptual introduction — why BPMN, how to read a diagram.

Build a processA step-by-step recipe using these elements.

How a process runsWhat happens at runtime when each element executes.