Prioritizing robots

Help Robot
1

How to implement robot based priority instead of process based priority?
I have a specific scenario regarding robot prioritization within the same folder. Currently, 4–5 robots are assigned to a folder, and they all run multiple processes.

Instead of standard load balancing (where Orchestrator dynamically allocates the job to whichever robot becomes available first) or setting a High-Priority to the process itself (which triggers any available robot across folders), I want to achieve Robot-Based Prioritization.

My Goal: When a job is triggered, I want it to follow a specific hierarchy/sequence of robots:

  1. It should always try to assign the job to Robot A first.
  2. If Robot A is busy or disconnected, the job should fall back to Robot B.
  3. If Robot B is also busy, it should route to Robot C, and so on.

Since there is no native “Robot Priority Sequence” setting in Orchestrator’s execution targets, what is the best workaround or architectural approach to achieve this? Should I handle this via Orchestrator API (checking robot statuses via a Dispatcher) or is there an easier built-in feature I might be missing?

Thanks in advance for your help!

2

@fidan.abishova.std welcome to community!

You can use orchestrator API from dispatcher, with those API you can check with Robot is connected or running or disconnected based on that you can call that which robot that needs to run using start job.

And make sure disabling the Queue based trigger if already assigned.

Let me know if this works.
Happy Automation!

3

no it does not work because how to run api

4

Hi @fidan.abishova.std,

For your requirement, the most robust approach is:

  • Keep the robots in the same folder.
  • Implement a lightweight process (any robot can pick this or you can define any specific robot which has least priority) which,
    • Queries robot and job status through the Orchestrator API.
    • Selects the first available robot according to your predefined order.
    • Starts the job by explicitly targeting that robot.
    • Retries or waits if no preferred robot is available.

This preserves the benefits of a shared folder while enforcing your desired execution order (A → B → C).

Cheers!

5

Hi @fidan.abishova.std

As per my knowledge UiPath does not provide native robot priority sequencing, so the best approach is to implement a dispatcher using Orchestrator APIs to check robot status and start jobs in a defined priority order, while trigger-based targeting can be used as a simpler workaround.

Happy Automation

6

@fidan.abishova.std

you are asking how to run or saying that doesn’t work.

It can work use Orchestrator API, For those use Swagger website to get the API’s and to run the API’s use orchestrator Http Activities. OR HTTP Activities

To know how to use go through below video,

7

Yeah you are right that there is no native robot priority sequence in Orchestrator, so a small dispatcher is the way to go. The part that feels hard is the raw API, but you can skip most of that pain

Instead of plain HTTP request, you can use the Orchestrator HTTP request activity. It reuses the robot connection that is already authenticated, so you do not have to generate tokens or handle any login, you just call the endpoint. Use it to read the robot or session status and see which ones come back as Available, Busy or Disconnected

From there loop through your order A, B, C, take the first one that is Available, and start the job on that specific robot using the Start Job activity, where you can target a specific account and machine instead of dynamic allocation. If none of them are free, wait a bit and check again… So the only thing you actually query through the API is the robot status. The starting part can stay inside the normal Start Job activity, which keeps it far simpler than doing everything through Swagger

8

i think you need to build a something like a priority based round robin algorithm to explicitly handle robot allocation for a given process.

  1. assign all ‘n’ robots to a single modern folder.
  2. do not use any kind of triggers.
  3. have a robot configuration file for determining the priority of each of the robots.
    eg :
  4. Robot A - P4
  5. Robot B - P1
  6. Robot C - p3
  7. Robot D - p2
    and so on..
  8. build a separate process that does this allocation.. basically for starting the jobs, this new process would trigger and decided which job is to be run for each of the processes deployed in the folder..

Allocation Process steps.

  1. Read robot configuration file.
  2. – Get the key of the process to start :

GET ‘https://{yourDomain}/odata/Releases$filter=%20Name%20eq%20’{ProcessName}’

*Pass {ProcessName} dynamically.
3. use Orch API to check which robot is free based on the priority sequence.
4. get the state of the robot A as(filter by top priority and loop through each robot to check the one that is available.) Eg : Robot B has 1st priority so check if it is available then Robot D and so on…

GET https://{yourDomain}/odata/Sessions?$top=10&$filter=Robot/Name eq ‘{RobotName}’&$select=State

*Pass RobotName Dynamically from the looping mechanism of datatable read from the robot config file.

5.now, if (RobotState == “Available”)

{
–call the API to start the job on this robot :

POST https://{yourDomain}/odata/Jobs/UiPath.Server.Configuration.OData.StartJobs

{
“startInfo”: {
“ReleaseKey”: “{ProcessKey}”,
“RobotIds”: [{robot id/s}],
“JobsCount”: 0,
“Strategy”: “Specific”
}
}

  • pass array : {robot id/s} and string {ProcessKey} dynamically from the earlier API calls.

capture whatever details are needed from the new job response…
}

  1. check for the availability of next robot based on priority and repeat the above steps to start the job on it.

SG.