Multi-Bot architecture help

[Steven_ds_55 (Steven)]

Hi forum,

I need help to understand multi bot architecture in UiPath. What is it and when are we using this?

[ashokkarale]

@Steven_ds_55,

Refer this answer

What is multibot architecture in UiPath?

@Sanket_Shinde1 Yes, we do use in almost every bot we build. Here is a quick explanation on this. It’s generated by LLM but validated by me. Multi-Bot Architecture in UiPath: The Multi-Bot Architecture in UiPath typically involves the use of multiple robots (bots) to handle different parts of a larger process. This architecture is designed to optimize workload distribution and process efficiency. Here’s a detailed look into the Multi-Bot Architecture focused around the Dispatcher and Perform…

@Steven_ds_55

when are we using this

As there are not much changes we need to make to the RE Framework, we build almost every `bot’s this way. Normally wherever you will have transactional process and can be processed independently, you can use multi bot architecture.

The idea is you can assign multiple bot’s to process single queue items to speed up the work.

[Manisha_Ravindra]

@Steven_ds_55
Multi-bot architecture means using multiple bots to work together on a process. Instead of one bot doing all the work, multiple bots share the workload, making automation faster and more efficient.
Also, If one bot fails, others can continue the work.
hope it helps!!

[rkelchuri (ER.Krishna)]

@Steven_ds_55

Thin Client Robots in UiPath, which typically means multiple robots working on different aspects of a process rather than performing the exact same task.

Key Points:

1. Work Sharing but Not the Same Task:

• One bot might handle backend processing (e.g., fetching data from a database, performing calculations, or sending emails).
• Another bot might handle frontend processing (e.g., interacting with a web application, filling out forms, or navigating UI elements).

2. Separate Licensing:

• The Unattended Robot license is used for backend automation (runs in the background without human intervention).
• The Attended Robot license is used for frontend automation (requires some level of human interaction).
• In a Hybrid Automation Setup, both types of bots collaborate but have different roles.

3. Use Case Example:

• Suppose you need to process invoices:
  • Backend Bot: Reads invoices from emails, extracts data using OCR, and updates a database.
  • Frontend Bot: Logs into an ERP system and enters the extracted invoice data manually.

4. Difference from Parallel Execution:

• The bots do not work on the same task at the same time. Instead, they divide responsibilities to improve efficiency.
• This setup is different from multi-bot execution, where multiple robots work on the same queue items simultaneously.

Please find following explanation on how to implement such a setup in UiPath?

Implementing Thin Client Robots in UiPath

To implement a Thin Client Robot setup where one bot handles backend processing and another bot handles frontend automation, follow these steps:

---

Identify the Process and Task Segmentation

• Analyze the workflow and split the tasks into:
  • Backend Tasks (Unattended Robot)
    • Database operations (SQL, Excel, API calls)
    • Email processing (reading and extracting attachments)
    • Data extraction (OCR, document parsing)
  • Frontend Tasks (Attended Robot)
    • Logging into web/desktop applications
    • Filling out forms
    • Navigating UI elements

---

Develop the Backend Bot (Unattended Robot)

This bot will handle data processing without interacting with the UI.

Steps to Implement:

1. Create a new Unattended Process in UiPath Studio.
2. Use background automation activities, such as:

• Database Activities (Execute Query, Insert Data, Update Data)
• Mail Activities (Outlook, IMAP, SMTP for email processing)
• File Handling Activities (read/write CSV, Excel, JSON, etc.)

3. Store the processed data in a shared location:

• Queue (Orchestrator)
• Database
• Shared folder or Excel file

4. Publish the automation to UiPath Orchestrator.

---

Develop the Frontend Bot (Attended Robot)

This bot will interact with UI elements and applications.

Steps to Implement:

1. Create a new Attended Process in UiPath Studio.
2. Retrieve data from:

• Orchestrator Queues (Get Queue Items)
• Shared Database (SQL)
• Excel Files / APIs

3. Use UI automation activities like:

• Click, Type Into, Get Text (for web and desktop apps)
• Image-Based Automation (for Citrix/Remote Desktop)
• Computer Vision Activities (for inaccessible UI elements)

4. Process each data entry and complete the task.

---

Orchestrate the Workflow in UiPath Orchestrator

• Deploy both bots via Orchestrator:
  • Assign the backend bot to a machine where it can run unattended.
  • Assign the frontend bot to a user’s machine for attended execution.
• Use Queues to pass data between the bots.

Example:

1. Backend Bot:

• Reads emails, extracts invoice details, and adds them to a queue.

2. Frontend Bot:

• Picks up the invoice details from the queue and enters them into the ERP system.

---

Monitor and Optimize

• Use Logs and UiPath Insights to track performance.
• If the backend process has high volume, scale with multiple unattended robots.
• Optimize frontend automation using hotkeys, selectors, and retry mechanisms.

---

Benefits of This Approach

Parallel Processing – Faster execution by handling tasks in separate bots.
Better Resource Utilization – Unattended bots handle data-heavy tasks, while attended bots focus on UI tasks.
Scalability – Easily add more robots as needed.
Resilience – If one bot fails, the other can retry or escalate the issue.

[Jon_Smith]

@ashokkarale

As there are not much changes we need to make to the RE Framework, we build almost every `bot’s this way. Normally wherever you will have transactional process and can be processed independently, you can use multi bot architecture.

The main change in my opinion is making sure the Framework can utilize the Output property of a queue item. Annoying the default activities from UiPath to update a queue item don’t support this in a flexible manner so it requires some hard coding of dictionary keys and outputs.