Technical Tuesday: How UiPath Maestro and REFramework work better together

Robotic process automation (RPA) started with a clear goal: automate repetitive tasks. But early robots were fragile, isolated scripts that couldn’t scale or adapt. The introduction of the Robotic Enterprise Framework (REFramework) in the UiPath Platform™ changed that by giving developers a robust, standardized architecture to build reliable, maintainable automations, especially in high-volume, UI-driven work.

As organizations matured in their automation journeys, their ambitions evolved: they no longer wanted to automate individual tasks, but end-to-end processes. And with the emergence of agentic automation, where AI agents act with autonomy and reasoning alongside robots and people, a new orchestration layer has become essential. That’s where UiPath Maestro™ enters the picture.

What is REFramework (and why does it matter)?

In response to a growing need for structure, reliability, and scalability in automation deployments, UiPath introduced REFramework. More than just a project template, REFramework represented a foundational blueprint, designed to instill best practices and enable the development of enterprise-grade automation solutions. Its arrival marked a significant step in maturing the automation landscape, providing developers with a standardized, robust, and scalable architecture.

The core purpose of REFramework was to address the common, recurring needs of virtually any business process automation. It introduced critical capabilities like:

• Configuration and application management

• Built-in exception handling

• Retry logic

• Logging and monitoring

• Queue-based processing (via UiPath Orchestrator)

REFramework has become the gold standard for automating high-volume, resilient, repeatable tasks, such as invoice processing, order validation, and customer relationship management (CRM) updates, especially when paired with the dispatcher/performer pattern. In this model:

• A dispatcher process is responsible for gathering work items (e.g., reading emails, querying a database, processing a master file) and adding them as individual ‘QueueItem’ objects to an Orchestrator Queue.

• One or more performer processes, built using the REFramework template, are usually triggered in batches, every day or when a certain number of items are queued. Each Performer retrieves a ‘QueueItem’ via the Get Transaction Data state, processes it using the logic defined in ‘Process.xaml’, and updates its status using ‘SetTransactionStatus’.

The ReFramework/Queue pattern effectively addressed the critical challenges of scalability and resilience for a significant class of automation problems: high-volume, homogenous, transactional processes, especially those heavily reliant on UI interactions. By treating each transaction (represented by a ’QueueItem‘) as an independent unit of work managed centrally by UiPath Orchestrator, this approach allowed businesses to automate tasks at a scale and with a level of reliability previously difficult to achieve.

Why we needed more than REFramework

While REFramework excels at handling transactional tasks, it was never designed to orchestrate dynamic, adaptive workflows. In today’s agentic era, where AI agents work alongside robots and people and utilize a complex ecosystem of tools and systems, business processes are rarely linear or isolated.

You often need to:

• Coordinate decision making between agents, robots, and people

• Maintain state across long-running, multi-step workflows

• Retry or skip specific steps—without starting over

• Monitor and govern the full lifecycle of a process

REFramework excels at processing independent transactions sequentially or in parallel via queues. Adapting it effectively for processes with inherent sequential dependencies, long-running steps, human interventions, or integration with AI components often required significant customization or workarounds. For instance, consider a process with three dependent steps: Input Order, Allocate Order, Separate Order. If an error occurs during Allocation (Step 2), simply retrying Step 2 might be insufficient; the state might require re-running Step 1.

The standard REFramework retry mechanism, focused on the current transaction, doesn't inherently manage such cross-step dependencies. Developers devised strategies like custom progress tracking within transaction data or splitting the process across multiple interconnected queues, essentially building bespoke orchestration logic on top of the basic framework.

Furthermore, modern business processes rarely consist solely of unattended robotic tasks. They often involve human decision making, approvals, exception handling, or collaboration with AI services for tasks like document classification or sentiment analysis. Orchestrating these diverse elements—coordinating the handoffs between a REFramework bot processing data, a human approving an exception in UiPath Action Center, and an AI model providing an analysis—lacked a native, unified layer within the traditional UiPath architecture.

The absence of a dedicated process orchestration layer meant that the complexity didn't disappear; it merely shifted. Instead of struggling with reliable task execution (largely solved by REFramework), developers now faced the challenge of inter-task coordination. They were forced to construct custom mechanisms (chains of queues, state management databases, intricate conditional logic etc.) to manage the end-to-end flow. This increased development time, introduced potential new points of failure, and lacked standardization.

Enter UiPath Maestro: built for agentic orchestration

Recognizing the growing need for true, process-level orchestration, UiPath introduced Maestro. This capability is engineered to model, implement, manage, monitor, and optimize complex, potentially long-running business processes that weave together the capabilities of AI agents, people (via Action Center), and traditional robots, including those built using REFramework.

Maestro represents a significant expansion of the UiPath Platform's capabilities, supporting the entire lifecycle of sophisticated business processes. It introduces several key features designed to address the orchestration challenges previously discussed:

• BPMN 2.0 modeling: a visual, industry-standard way to design rich, branching workflows

• Multi-actor coordination: trigger robots, invoke AI agents, assign human tasks, all from one model

• Real-time control: monitor instances, adjust variables, and intervene at any step

• Governance and trust: enforce enterprise controls and track performance from start to finish

The fundamental goal of Maestro is to transform collections of disparate automated tasks into cohesive, manageable, end-to-end business processes. This effectively ends the era of "start-and-stop" automation where gaps exist between automated segments. It provides the necessary framework to orchestrate long-running workflows that might span hours, days, or even months, involving multiple handoffs and system interactions.

Maestro + REFramework: better together

UiPath Maestro doesn’t replace REFramework—it enhances it. REFramework retains its position as the gold standard for building robust, reliable, and standardized transactional automation components, particularly for UI-intensive tasks managed via queues. Maestro acts as the conductor, orchestrating these well-built performers alongside human tasks, AI agents, and other system interactions according to the defined business process flow.

Their complementary roles become clear when examining how they interact:

• Invocation: Maestro can be a Dispatcher for a ReFramework-style RPA Performer as specific steps within a larger process model, typically using a "Service Task" configured to either start a job or create a queue item. This allows Maestro to trigger a Performer Robot to process a specific item or batch based on the process context.

• State management: Maestro manages the overall state of the end-to-end business process, handling the transitions between different steps. For example, Maestro might trigger a REFramework bot to extract data, wait for its completion, evaluate the result using DMN rules, and then either assign a validation task to a human via UiPath Action Center or trigger another bot for further processing.

• Error handling levels: they offer different levels of error handling and recovery. REFramework provides robust transaction-level retries for system exceptions within its execution scope. Maestro adds process-level control, allowing operators to manually intervene on failed instances, retry specific steps (potentially including the invocation of a REFramework bot), skip problematic steps, or rewind the process state.

• Data flow: Maestro manages the flow of data between different steps in the process, passing necessary inputs to invoked REFramework bots and receiving outputs to inform subsequent steps.

This synergy allows organizations to leverage their existing investments and expertise in REFramework. Well-tested, reliable REFramework performers built for specific tasks don't need to be discarded; instead, they can become reusable components within more sophisticated, Maestro-orchestrated processes. Maestro provides the overarching structure, context, and coordination layer—the "glue"—that was previously missing or had to be custom-built.

Enterprises can use REFramework to:

• Build reliable performers for transactional UI tasks

• Leverage queue-based processing with built-in retry, logging, and error handling

Meanwhile, the role of Maestro is to:

• Design and orchestrate the entire business process

• Manage dependencies, human steps, and AI interactions

• Coordinate multiple REFramework robots within broader agentic flows

Together, they enable agentic automation at scale, combining the reliability of REFramework with the flexibility and visibility of Maestro.

Common scenarios where REFramework and Maestro shine together include:

• UI automation is needed but must fit into a broader, multi-step journey

• Processes where no APIs are available, so robots extract data to trigger an agentic process

• Human-in-the-loop tasks like approvals, exceptions, or reviews

• Scenarios where AI agents can enhance the process (classifying documents, summarizing emails, making decisions, etc.)

Looking ahead

REFramework gave us the structure for task automation. Maestro gives us the structure for end-to-end process automation. Together, they represent the evolution of UiPath from an automation platform to a true agentic automation platform—one where AI agents, robots, and people collaborate to create transformational value in orchestrated, intelligent workflows.

As automation expands beyond individual robots to intelligent, end-to-end processes driven by agentic AI, Maestro provides the orchestration layer to manage complexity, while REFramework continues to deliver reliable execution at the task level.

The future of enterprise automation on the UiPath Platform involves leveraging both:

• REFramework for building efficient, maintainable, and resilient execution units, especially for queue-based UI automation performers, adhering to established best practices for logging and error handling

• Maestro for modeling, orchestrating, monitoring, and optimizing the complex, long-running business processes that connect these performers with employers and AI agents, providing visibility and control over the entire value chain

This combined approach allows organizations to protect their existing investments in REFramework-based automations while embracing the power to automate more complex, strategic, and impactful business processes. As the trend towards agentic automation accelerates, where AI agents take on more sophisticated planning and execution roles, the need for a robust orchestration layer like Maestro becomes even more critical to ensure controlled, governed, and efficient end-to-end automation. The path forward lies in combining structured, reliable performers with intelligent, flexible process orchestration.

To learn more about how UiPath orchestrates AI agents in governed, end-to-end processes with robots and people, read "The definitive guide to agentic orchestration."

Never miss a Technical Tuesday blog post! Subscribe to the blog and we'll email the latest blog posts to you every Friday.