question

My solution is based on the Task Sequences tutorial for Process Flow. If you haven't done that tutorial yet, I would recommend it to get a good idea of the method I used. This method hijacks the Use Transport option on the processor, and wires in your own process flow.

Here is the 3D model I made based on your description:

I colored each set of processors a different color, and each team of operators a different color. I named the dispatchers Team 1, Team 2, and Team 3.

Here is the Sub Flow I made to solve the problem:

For each 3D processor, I set the process time to zero; the Sub Flow handles the process time. Then, like the tutorial, I configured the Use Transport option to use a Sub Flow (which used the Per Instance option):

Notice that the Dispatch object is current, unlike the tutorial, which uses centerobject(current, 1). This means the keyword current will refer to the calling processor. Also notice that I store the item that needs transport, the set that the processor is in, and the destination of the item as labels on the token.

Then, I created a global list for all the operators. I added a field to the list that stores which dispatcher the operators belong to, using connections:

This helps with using list queries later on. Then, I added each operator to the list as initial content (which you can do from the general tab).

Now we move to the Sub Flow, which I named Operator Flow. The first Decide activity uses the "set" label to determine which route to go down. Each "Get Dispatchers" activity creates a label called "dispatchers", which is an array of all the dispatchers that could be used by that set. For example, set 3 can use operators from Dispatchers 2 and 3:

Once the set of possible dispatchers is assigned, we can pull from the list with a query:

This pull from list can be read as follows: Get a single operator whose dispatcher is in the label array of dispatchers. Put that operator on my operator label. The token waits until it can get the right kind of operator.

The remainder of the flow is simple: wait for some amount of time, move the object off the processor, and put the operator back on the list.

I attached the model so you can see how it works.