Study guide
17.2 Action Center & Human-in-the-Loop Orchestration
UiPath Automation Developer Professional UiPath-ADPv1
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & Blueprint Map
1.1 About the UiPath-ADPv1 Exam: Format, Fees & Policies 1.2 The Exam Topics Mapped to This Guide & a Study Plan
2 Chapter 2: REFramework Architecture & State Dynamics
2.1 State Machine Architecture & The Four Core States 2.2 Configuration Management: Settings, Constants, and Assets 2.3 Transaction Types & The Dispatcher vs. Performer Architecture 2.4 Adapting REFramework: Tabular Data, Collections & Linear Processes
3 Chapter 3: REFramework Exception Handling & Recovery
3.1 BusinessRuleException vs. System.Exception Handling Patterns 3.2 Retry Mechanisms: Queue Retries vs. REFramework MaxRetryNumber 3.3 Consecutive System Exceptions & Graceful Process Termination
4 Chapter 4: State Machines, Custom Log Fields & REFramework Testing
4.1 Building State Machine Projects in Studio 4.2 Logging Levels, Robot Logs & Custom Log Fields in REFramework 4.3 Testing a REFramework Project With and Without Orchestrator Queues
5 Chapter 5: LINQ Queries & DataTable Operations
5.1 LINQ Essentials for Collections & Filtering 5.2 Advanced DataTable Querying with LINQ 5.3 In-Memory DataTable Transformations & Column Operations
6 Chapter 6: Regex, DateTime, JSON & Invoke Activities
6.1 Regular Expressions & Text Parsing for Automation 6.2 DateTime Formatting, Timezone Conversions & TimeSpan Calculations 6.3 JSON Parsing, JSONPath & Serialization with Newtonsoft.Json 6.4 Invoke Method & Invoke Code Activities 6.5 Data Referencing in Invokes: DataTable, List & Dictionary Arguments
7 Chapter 7: Modern UI Automation & Unified Targeting
7.1 Modern Design Experience & The Unified Target Concept 7.2 Anchors, Relative Elements & UI Automation Activities 7.3 Dynamic Selectors, Variables & Wildcards in Selectors
8 Chapter 8: Object Repository, Computer Vision & Remote Runtime
8.1 Object Repository & UI Descriptor Libraries 8.2 AI Computer Vision for Unattended & Remote Interfaces 8.3 Automation in Virtual Environments & UiPath Remote Runtime
9 Chapter 9: Advanced UI Automation: Browser Modes, Agentic UI & macOS
9.1 Browser Automation with the WebDriver Protocol 9.2 Agentic UI Automation: ScreenPlay, Semantic Activities & Healing Agent 9.3 macOS Automation: Native Apps, Office Apps & AppleScript
10 Chapter 10: Advanced Control Flow & Exception Architecture
10.1 Flowcharts, Sequences & Parallel Control Flow Patterns 10.2 Global Exception Handler Architecture & ErrorAction Directives 10.3 TryCatch, Retry Scope & Custom Exception Architectures
11 Chapter 11: Orchestrator Queues & Transaction Management
11.1 Queue Architecture, SpecificContent & Transaction Lifecycles 11.2 Queue Items SLA, Postpone, Deadlines & Priority Scheduling 11.3 Bulk Operations, Transaction Status Updates & Queue Triggers
12 Chapter 12: Orchestrator Tenant & Folder Entities
12.1 Asset Types, Per-Robot Assets & External Credential Stores 12.2 Modern Folder Hierarchy, User/Robot Assignment & Permissions 12.3 Storage Buckets, Webhooks & Environment Promotion 12.4 Orchestrator Tags: Labels, Properties & Governance
13 Chapter 13: Unattended Execution, API Triggers & Cloud Robots
13.1 Unattended Job Execution: Folders, Priorities, Background vs. Foreground & Runtimes 13.2 API Triggers: Starting Jobs from External Systems over HTTP 13.3 Serverless and Cloud VM Robots: Cloud-Hosted Execution Options
14 Chapter 14: Monitoring, Recording & Solutions Management
14.1 Orchestrator Monitoring, Trigger Alerts & Job Health 14.2 Job and Transaction Recording: Troubleshooting Faulted Unattended Jobs 14.3 Solutions Management: Packaging and Deploying Automations with Their Resources
15 Chapter 15: Debugging, Remote Debugging & Profiling
15.1 Studio Debugging Tools: Breakpoints, Panels & Execution Control 15.2 Remote Debugging: Remote Machine and Unattended Robot Connections 15.3 Profile Execution: Finding Performance Bottlenecks in Studio
16 Chapter 16: RPA Testing & Test Suite
16.1 UiPath Test Suite Overview, Test Cases & Given-When-Then Structure 16.2 Data-Driven Testing, Test Verification Activities & Mock Activities 16.3 CI/CD Pipelines with uipcli & Test Manager Traceability
17 Chapter 17: Long-Running Workflows, Action Center & Apps
17.1 Long-Running Workflows: Persistence, Suspend and Resume 17.2 Action Center & Human-in-the-Loop Orchestration 17.3 UiPath Apps: Action Apps, Automations & Integration Service
18 Chapter 18: Trigger-Based Attended Automation & Callouts
18.1 Trigger-Based Attended Automation: Forms, Triggers & Global Variables 18.2 Running Local Triggers & the Event Inspection Tool 18.3 Callouts & Forms for Attended Guidance
19 Chapter 19: UiPath Assistant & Robot Sessions
19.1 UiPath Assistant: Automations, Reminders, Widgets & Configuration 19.2 Robot Session (Picture in Picture): Child Session vs. Virtual Desktop
20 Chapter 20: Autopilot for Developers & Autopilot for Everyone
20.1 Autopilot for Developers: AI Assistance in Studio and Studio Web 20.2 Autopilot for Everyone: Chat, Automations & Clipboard AI
21 Chapter 21: API Automation & Integration Service
21.1 Integration Service: Connectors, Connections & Connector Activities 21.2 API Workflows in Studio Web 21.3 HTTP Requests: Web APIs, the Orchestrator API & Connector Requests 21.4 Connector Builder: Custom Integration Service Connectors 21.5 Integration Service Event Triggers: Connected and Disconnected 21.6 GenAI Activities: Generative AI Inside Workflows
22 Chapter 22: Data Service, Context Grounding & Coded Workflows
22.1 Data Fabric (Data Service) Entities: Modeling Business Data 22.2 Data Fabric Activities and the Platform Connector 22.3 Context Grounding: Retrieval-Augmented Generation with Company Data 22.4 Coded Automations: Structure, Arguments & Invoking Workflows 22.5 Coded Automation Services: Orchestrator, UI Automation, Microsoft 365 & Custom Services
23 Chapter 23: Integrated Scenario Practice
23.1 Integrated Scenario Practice: Designing an End-to-End Solution
17.2 Action Center & Human-in-the-Loop Orchestration
Key Takeaways Explain This Topic AI
Action Center tasks let an unattended job suspend, free its robot, and resume on any available robot after a person completes the task.
Long-running projects use the Long Running Automation template or the Supports Persistence setting, plus the UiPath.Persistence.Activities package.
Form tasks, app tasks, and external tasks each pair a Create activity with a Wait ... and Resume activity; separating them allows several tasks to be created before waiting.
Tasks are Unassigned, Pending once assigned, and Completed; access follows the action catalog and folder permissions for Actions.
Everything in scope across a wait must be serializable, local files must not be relied on after resumption, and Delay or Retry Scope in the Main workflow need Resume After Delay or a No Persist Scope.
Last updated: September 2026
17.2 Action Center & Human-in-the-Loop Orchestration
Core Concept: UiPath Action Center delivers enterprise Human-in-the-Loop (HITL) orchestration by decoupling human validation, approvals, and exception handling from robotic execution. Through the Persistence Activities framework, an unattended robot encountering a decision gate suspends execution, serializes its runtime state into Orchestrator, and terminates its host OS process—instantly releasing its runtime license and VM capacity. Once a human completes the assigned action in Action Center, Orchestrator reallocates an available robot to reconstitute the execution context and seamlessly resume processing.
In conventional unattended automation architectures, processes are designed to execute from start to finish without human intervention. However, complex enterprise processes frequently require subjective human decision-making: approving high-value invoices exceeding corporate thresholds (e.g., $50,000), verifying ambiguous data extracted from degraded scanned documents, or resolving complex business exceptions. Historically, developers attempted to handle these scenarios using modal popups, message boxes, or active polling loops ( Thread.Sleep or continuous database checks). In unattended production environments, holding an active robot session while waiting for a human approver who may take hours or days to respond introduces critical architectural flaws: it paralyzes costly unattended robot licenses, monopolizes virtual machine memory and CPU resources, blocks pending queue transactions, and inevitably fails if the host VM reboots or times out.
UiPath Action Center resolves this architectural challenge through native persistence and asynchronous workflow suspension.
1. Action Center & Persistence Architecture
The Action Center architecture is built upon the UiPath Persistence Framework ( UiPath.Persistence.Activities ). This framework transforms standard transient workflows into Long-Running Workflows capable of pausing execution across arbitrary spans of time—ranging from seconds to weeks—without consuming infrastructure resources while idle. +-----------------------------------------------------------------------------------+
- | ACTION CENTER HITL ARCHITECTURE |
- | |
- | +--------------------+ |
- | | Unattended Robot | |
- | | (Host VM #1) | |
- | +---------┬----------+ |
- | │ 1. Executes automated data extraction & business logic |
- | │ 2. Invokes 'Create Form Task' & 'Wait for Form Task and Resume' |
- | ▼ |
- | +-----------------------------------------------------------------------------+ |
- | | UiPath Orchestrator | |
- | | |
- | | [Job State: RUNNING] ──► [Serializes Context to DB] ──► [Job: SUSPENDED] |
- | | │ |
- | | * Robot #1 process terminates; runtime license released! │ |
- | | * License immediately available for other queue jobs. │ |
- | +----------------------------------------------------------------┼------------+ |
- | │ |
- | ▼ |
- | +-----------------------------------------------------------------------------+ |
- | | UiPath Action Center Portal | |
- | | - Task routed to Action Catalog: 'Finance Approvals' |
- | | - Human reviewer claims task ('Assign to Me'), edits data, and Submits |
- | +----------------------------------------------------------------┬------------+ |
- | │ |
- | ┌──────────────────────────────────────────────────────┘ |
- | ▼ |
- | +-----------------------------------------------------------------------------+ |
- | | UiPath Orchestrator | |
- | | |
- | | [Task Completed Event] ──► [Job: RESUMED] ──► [Dispatches to Queue Pool] |
- | +----------------------------------------------------------------┬------------+ |
- | │ |
- | ┌──────────────────────────────────────────────────────┘ |
- | ▼ |
- | +--------------------+ |
- | | Unattended Robot | 3. Downloads serialized execution state snapshot |
- | | (Host VM #2) | 4. Reconstitutes variables & resumes post-Wait activity |
- | +--------------------+ 5. Finalizes ERP transaction & commits status |
- +-----------------------------------------------------------------------------------+
- The Suspension and Resumption Mechanics
When a long-running workflow executes a persistence wait activity (such as Wait for Form Task and Resume ), the execution lifecycle transitions through five distinct phases:
Task Generation: The robot runs Create Form Task with the task title, priority, action catalog, and form data. Orchestrator creates the task and returns a task object that identifies it.
State Serialization: When entering the Wait for Form Task and Resume activity, the UiPath workflow runtime inspects the current execution environment. It captures the entire call stack, execution pointers, active activity bookmarks, and all in-scope workflow variables, serializing this state into a secure binary/JSON payload.
Job Suspension: The robot uploads the serialized state payload to the Orchestrator database. Orchestrator transitions the job state from Running to Suspended . The robot executor process ( UiPath.Executor.exe ) gracefully shuts down and terminates its Windows session. The unattended robot runtime license is immediately returned to the tenant's shared license pool, allowing other queued automations to utilize the machine.
Human Action: The task appears in Action Center (and in the Tasks tab of UiPath Assistant). Authorized users belonging to the target Action Catalog inspect the business data, correct OCR discrepancies or modify fields, and click an action button (e.g., "Approve", "Reject", "Submit"). The action payload and user comments are saved back to Orchestrator, marking the task as Completed .
Job Resumption: Orchestrator evaluates the completed task and identifies its associated suspended job. Orchestrator updates the job state from Suspended to Resumed (placing it into the execution queue). The next available unattended robot in the folder—which does not need to be the same physical machine or VM that started the job—claims the execution, downloads the serialized state payload, reconstitutes the workflow variables into memory, and resumes execution at the exact step immediately following the wait activity.
2. Configuring Long-Running Orchestration Projects
Not every standard UiPath Studio project supports Action Center suspension. Attempting to use persistence activities inside a standard process results in compile-time or runtime errors.
Project Configuration Requirements
To enable persistence and Action Center integration in UiPath Studio, developers must satisfy three strict requirements:
Project Template / Settings: Start from the Long Running Automation template (formerly called Orchestration Process), or turn on Supports Persistence in Project Settings. In project.json the setting appears under runtimeOptions : {
- "name": "InvoiceProcessing_LongRunning",
- "main": "Main.xaml",
- "runtimeOptions": {
- "supportsPersistence": true,
- "requiresUserInteraction": false
- }
- }
Package Dependency: The project must import the UiPath.Persistence.Activities package. This package provides core activities including Create Form Task , Wait for Form Task and Resume , Create External Task , Wait for External Task and Resume , and Resume After Delay .
Main Workflow Rules: UiPath notes that the Delay and Retry Scope activities are not supported in the Main workflow of an orchestration (long-running) process; use Resume After Delay instead, or place them inside a No Persist Scope . Design the Main workflow so that everything held across a wait can be persisted.
3. Form Tasks vs. External Tasks
UiPath Action Center supports two foundational task paradigms: Form Tasks (internal, visual UI forms rendered directly in Action Center) and External Tasks (external approval workflows orchestrated across third-party enterprise platforms). +-----------------------------------------------------------------------------------+
- | FORM TASKS vs. EXTERNAL TASKS |
- | |
- | +-------------------------------------+ +------------------------------------+ |
- | | FORM TASKS | | EXTERNAL TASKS | |
- | | (UiPath Action Center Native) | | (Third-Party SaaS Orchestration) | |
- | | | | | |
- | | - Designed in Studio Form Designer | | - Managed in Salesforce, ServiceNow| |
- | | - Rendered natively in Action Center| | Jira, SAP, or Workday | |
- | | - Rich dynamic controls, validation | | - External system manages the UI | |
- | | - Bi-directional JSON data binding | | - Resumption triggered via | |
- | | - Human acts directly in UiPath web | | Orchestrator REST API webhook | |
- | +-------------------------------------+ +------------------------------------+ |
- +-----------------------------------------------------------------------------------+
- Form Tasks & UiPath Form Designer
Form Tasks are custom, responsive interactive forms authored directly inside UiPath Studio using the drag-and-drop Form Designer (powered by the Form.io component engine). Form Designer enables developers to build complex, enterprise-ready user interfaces without front-end web development.
Supported Controls: Text fields, text areas, number inputs, currency inputs, date/time pickers, dropdown selects, multi-select checkboxes, radio buttons, data grids, file upload controls, and custom HTML/CSS content blocks.
Client-Side Validation: Enforces mandatory fields, regex patterns, minimum/maximum numeric ranges, and dynamic conditional logic (e.g., displaying an "Approval Justification" text area only when the "Manager Approval" radio button is toggled to "Rejected").
Data Binding Architecture: Data exchange between the robot workflow and the Form Task is governed by Form Data Arguments configured in the Create Form Task activity:
In Direction ( In_ ): Supplies read-only data from the robot to pre-populate form fields for the human reviewer (e.g., in_InvoiceNumber , in_VendorName , in_TotalAmount ).
Out Direction ( Out_ ): Captures user input, reviewer comments, or modified fields back into the robot workflow upon task submission (e.g., out_ApproverNotes , out_ApprovedDiscountRate ).
InOut Direction ( InOut_ ): Seeds a form field with robot-extracted values while permitting the human user to override or correct the value (e.g., inout_TaxAmount , inout_LineItemsTable ).
External Tasks
An External Task is utilized when an enterprise mandates that human reviews and approvals take place strictly inside an existing third-party enterprise system—such as ServiceNow ticket approvals, Salesforce Opportunity stage sign-offs, Jira issue transitions, or SAP workflow items.
Workflow Execution: The robot executes business logic, gathers case data, and calls Create External Task . Orchestrator creates a task reference with an external task identifier.
Suspension: The robot invokes Wait for External Task and Resume , serializing its state and suspending the job in Orchestrator.
External System Integration: Simultaneously, the robot or an integration service trigger creates the corresponding record or approval ticket in the external system (e.g., Salesforce).
Resumption: When the reviewer decides in the external system, that system (or an automation using the Complete Task activity) completes the external task through Orchestrator, passing the result data. Orchestrator then resumes the suspended job, which reads the result from the task object.
4. Key Persistence Activities & Execution Patterns
The UiPath.Persistence.Activities package provides distinct activities designed to separate task instantiation from job suspension, enabling sophisticated parallel and asynchronous workflow patterns.
Activity Name Primary Function Workflow Role
Create Form Task Submits form definition, arguments, catalog, and priority to Orchestrator. Non-suspending; generates task record and outputs TaskData object ( TaskObject ).
Wait for Form Task and Resume Suspends workflow execution until the specified TaskObject reaches Completed status. Suspending; serializes state to DB, shuts down robot executor, reconstitutes upon completion.
Create External Task Instantiates an external task reference in Orchestrator. Non-suspending; outputs external TaskData object.
Wait for External Task and Resume Suspends workflow execution until an external API call completes the task. Suspending; awaits external webhook / REST API trigger.
Resume After Delay Suspends workflow execution for a defined TimeSpan duration (e.g., 2 hours). Suspending; releases robot license during time-delayed waits instead of using Delay .
Create App Task / Wait for App Task and Resume Create a task that uses a UiPath App as its form, and wait for it. Non-suspending / suspending pair, like form tasks.
Assign Tasks , Complete Task , Forward Task , Get Form Tasks , Get App Tasks Manage existing tasks from a workflow. Non-suspending task management.
The Batching & Parallel Dispatch Pattern
Every human task uses a separate Create activity and Wait activity. Keeping them apart lets one workflow create several tasks first and then wait for all of them. ' Enterprise Pattern: Multi-Departmental Parallel Task Dispatch
- ' Step 1: Create Legal Review Task (Does NOT suspend execution)
- CreateFormTask(
- TaskTitle := "Legal Review: Contract #" + strContractID,
- TaskCatalog := "Legal_Catalog",
- TaskPriority := TaskPriority.High,
- FormData := legalInputData,
- out_TaskObject := taskLegal
- )
- ' Step 2: Create Finance Review Task (Does NOT suspend execution)
- CreateFormTask(
- TaskTitle := "Finance Review: Contract #" + strContractID,
- TaskCatalog := "Finance_Catalog",
- TaskPriority := TaskPriority.High,
- FormData := financeInputData,
- out_TaskObject := taskFinance
- )
- ' Step 3: Suspend and wait for both reviews to complete in parallel
- ' Using a Parallel activity hosting two 'Wait for Form Task and Resume' activities
- Parallel(
- Branch1: WaitForFormTaskAndResume(TaskInput := taskLegal, TaskOutput := taskLegalResult),
- Branch2: WaitForFormTaskAndResume(TaskInput := taskFinance, TaskOutput := taskFinanceResult)
- )
' Execution resumes ONLY when both legal and finance reviewers submit their forms!
By separating Create from Wait , the robot dispatches dozens of approval requests across multiple enterprise departments within milliseconds before executing a single suspension, maximizing throughput and operational efficiency.
5. Action Catalogs, Task Assignment & Lifecycle Governance
In enterprise deployments with hundreds of human reviewers across disparate corporate divisions, governance and access control are managed through Action Catalogs . +-----------------------------------------------------------------------------------+
- | ACTION CATALOG RBAC & LIFECYCLE |
- | |
- | [Action Catalog: Accounts_Payable] [Action Catalog: HR_Executive] |
- | - Authorized Group: AP_Specialists - Authorized Group: HR_Directors |
- | - Retention Policy: 90 Days - Retention Policy: 365 Days |
- | |
- | Task Lifecycle States: |
- | |
- | +-------------+ User clicks 'Assign to Me' +-------------+ |
- | | Unassigned | ─────────────────────────────────────► | Pending | |
- | | | ◄───────────────────────────────────── | (assigned) | |
- | +-------------+ User Reassigns or Releases +------┬------+ |
- | │ |
- | │ User Submits Form|
- | ▼ |
- | +-------------+ |
- | | Completed | |
- | | (Resumes) | |
- | +-------------+ |
- +-----------------------------------------------------------------------------------+
- Action Catalogs
An Action Catalog is a folder-scoped container configured in Orchestrator that groups related tasks:
Security Boundaries: Access is governed by Orchestrator folder permissions for Actions , Action Catalogs , and Action Assignment , together with the catalog's user assignments, so the Accounts_Payable team does not see tasks in the HR_Executive catalog.
Audit & Retention: Catalogs track operational metrics (average time to complete, task throughput per user) and govern automated task archiving schedules.
Task Lifecycle and Locking Semantics
Every Action Center task progresses through a strict state machine:
Unassigned: A task created without an assignee waits in its catalog. Authorized users can see it and assign it.
Pending (assigned): To work on a task, a user selects Assign to Me , or a manager assigns it. While it is assigned:
Other users see the task greyed out or hidden from their active work queue.
Concurrent form submission collisions are completely prevented.
The assignee can enter partial data and click Save to preserve work-in-progress without completing the task or resuming the robot.
Reassignment: If an assigned user is unavailable or escalates the case, the task can be reassigned to another specific user or released back to the general Unassigned pool.
Completed: The assignee verifies all data and clicks the completion action button (e.g., Submit ). Orchestrator validates required fields, locks the form against further modifications, immutably records the completion timestamp and user identity in the audit log, and notifies the scheduler to resume the paused job.
6. Architectural Constraints & Serialization Rules
Because long-running workflows suspend execution by serializing memory to the Orchestrator SQL database, they operate under strict technical constraints that do not apply to transient, single-run unattended automations.
The Mandatory Serialization Rule
Caution
Non-Serializable Objects Cause Fatal Runtime Failures: Every variable and object that remains in scope across a persistence boundary ( Wait for Form Task and Resume , Resume After Delay ) must be .NET serializable . If an in-scope variable cannot be serialized by the runtime serialization engine, the workflow throws a fatal System.Runtime.Serialization.SerializationException at the moment of suspension, crashing the job without creating a valid checkpoint!
Variable Category Allowed Across Suspension? Architectural Guidance
Primitive Data Types ( String , Int32 , Boolean , DateTime , Double ) YES Native primitives serialize cleanly into JSON/binary streams.
DataTables & Collections ( DataTable , List<T> , Dictionary<K,V> ) YES Standard collections serialize provided all inner types T , K , V are serializable.
Active UI Automation Handles ( UiElement , Target , BrowserWindow ) NO Windows OS memory pointers and active DOM handles cannot be serialized to disk. Scope all UI activities inside isolated child sequences that complete and dispose variables before reaching wait activities.
Open System Streams ( FileStream , StreamReader , BinaryWriter ) NO Active file system file locks and streams cannot cross network database boundaries. Close and dispose all streams prior to suspension.
Database Connections ( SqlConnection , DatabaseConnection ) NO Active TCP sockets and open database transactions cannot be serialized. Disconnect cleanly; re-open connections post-resumption.
State Locality and Machine Independence
In an elastic, multi-machine cloud robot pool, Job Resumption is Machine-Agnostic :
A job may execute Phase 1 on VM Node-Prod-01 in Data Center East, suspend for four days while awaiting director approval, and resume Phase 2 on VM Node-Prod-08 in Data Center West.
The Local File Anti-Pattern: Never save state-dependent files to local machine scratch paths (e.g., C:\Temp\Invoice104.pdf ). When the job resumes on a different physical VM, local disk files will not exist, resulting in fatal FileNotFoundException errors.
Enterprise Solution: Store persistent binary files, documents, and intermediate artifacts in UiPath Storage Buckets , enterprise cloud storage (Azure Blob, AWS S3), or centralized network UNC shares ( \\nas01\rpa_share\ ), referencing only the file identifier or URI within workflow variables.
7. Timeout Management, SLAs & Escalation Architecture
What happens when a human approver fails to act on a task? Without proactive timeout handling, suspended jobs can linger in Orchestrator indefinitely, violating enterprise Service Level Agreements (SLAs) and stalling business operations.
The Parallel Timeout & Escalation Pattern
Enterprise orchestration processes implement Parallel Control Flow to enforce strict SLAs: +-----------------------------------------------------------------------------------+
- | PARALLEL SLA ESCALATION PATTERN |
- | |
- | [Parallel Activity] |
- | (Condition: boolTaskCompleted = True) |
- | │ |
- | ┌─────────────────────────────┴─────────────────────────────┐ |
- | ▼ ▼ |
- | [Primary Approval Branch] [SLA Escalation Branch] |
- | │ │ |
- | WaitForFormTaskAndResume ResumeAfterDelay |
- | (TaskInput: taskApproval) (Duration: 48 Hours)|
- | │ │ |
- | Assign: boolTaskCompleted = True Assign: boolTimedOut = True |
- | │ │ |
- | │ Send Reminder Email |
- | │ Or Reassign Task |
- | ▼ via Orchestrator API |
- | [Normal ERP Processing] ▼ |
- | [Auto-Reject / Escalate] |
- +-----------------------------------------------------------------------------------+
Implementation Mechanics: A Parallel activity is configured with two concurrent execution branches:
Branch 1 (Human Action): Hosts Wait for Form Task and Resume . Upon completion, sets a flag boolTaskCompleted = True .
Branch 2 (SLA Timer): Hosts a Resume After Delay activity configured for the SLA duration (e.g., TimeSpan.FromHours(48) ). When the timer expires, the branch executes escalation logic: sending an automated warning email via Microsoft 365, calling the Orchestrator API to reassign the task to a senior director, or auto-rejecting the transaction.
CompletionCondition: Setting the Parallel activity's CompletionCondition to boolTaskCompleted Or boolTimedOut cancels the other branch as soon as either flag is set.
8. Architectural Summary: Long-Running vs Standard Workflows
- Architectural Attribute Standard Unattended Workflow Long-Running Orchestration Workflow
- Project Setting supportsPersistence: false supportsPersistence: true
- Runtime Activity Package UiPath.System.Activities UiPath.Persistence.Activities
- Execution Model Continuous, synchronous execution Asynchronous, suspendable execution
- Idle License Consumption Consumes 100% of robot license while waiting 0% license consumption while suspended
- Variable Scope Restrictions Any valid .NET object in memory All persistent variables must be serializable
Execution Host Affinity Runs entirely on a single machine session Can suspend on Machine A and resume on Machine B
Human Interaction Channel Attended message boxes / UI popups (local) Action Center web portal & mobile app (centralized)
Maximum Practical Wait Duration Minutes (bounded by OS timeout & license cost) Days, weeks, or months (unbounded database state)