Everything piles up at one stage
Agents keep starting new work because starting is always available. Items accumulate at whichever stage is slowest or most contended, and the queue in front of it grows faster than it drains.
Multi-agent management
Many agents is not one agent, many times.
One agent on one task is a solved problem. A team of agents working a large, repeatable process is a different problem entirely: capacity has to be pointed at the right stage, minute by minute, or the work bunches in the middle and nothing reaches the exit. WorkflowHub coordinates them — and shows its working.
The problem
Agents bunch up. Exits starve. Spend continues.
Give a large process more agents and the intuition is that more work gets finished. In practice, uncoordinated capacity goes where work is easiest to pick up — the front. Here is what that looks like from the outside.
The end of the line goes quiet
The last stages — review, approval, close-out — sit idle waiting for items that never arrive, because the agents' attention never got that far. Plenty is in progress; almost nothing is finished.
You pay for motion, not completion
Agent capacity costs money whether or not it moves an item to done. A agents that is busy everywhere and finishing nowhere converts spend into work-in-progress — the most expensive kind of nothing.
Nobody can explain the placement
Ask why forty agents are on one stage and the honest answer is usually a shrug. If the assignment logic isn't written down and published, you can't tell a deliberate choice from an accident — and you can't fix what you can't see.
The same agents, uncoordinated and coordinated
Bars are work waiting at each stage; dots below are agents placed on that stage.
The approach
Measure → allocate downstream-first → publish the plan
Three steps, run continuously. None of them is clever; the value is that they run for the whole agents at once, consistently, and in the open.
1 · Measure
Look at the whole process
How much work is waiting at each stage, how much is in flight, and how fast each stage is actually clearing items right now.
2 · Allocate
Point capacity at the exits
Stages nearer done are served first, each stage's work-in-progress limit is respected, and an admission throttle decides whether the process can take on anything new at all.
3 · Publish
Show the working
The resulting plan — which capacity goes to which stage, and on what grounds — is published so anyone can inspect it, question it, and check that the agents did what the plan said.
The controls
Four levers, borrowed from operations that already run at scale
None of this is new thinking about factories and service desks — Theory of Constraints, Little's Law and Kanban have governed flow for decades. What's new is applying them to a team of AI agents, automatically, at a cadence no human dispatcher could hold.
Downstream-first allocation
Capacity is offered to the stages closest to done before the stages closest to the front. Work in flight gets finished rather than parked next to more work in flight.
Per-stage WIP limits
Each stage has a ceiling on how much can be open at once. Limits are what turn a queue into a pipeline: less waiting, shorter time from start to finish, and problems that show up as a blocked stage instead of a silent backlog.
Admission throttle
New work only enters the process when the process can absorb it. Holding items at the door instead of inside the pipeline keeps the queue honest and keeps every item that has started moving.
Priority you set, applied everywhere
Weight the agents toward an organization, a project or a stream, and tune how hard work is pulled along. You write the policy; the allocator applies it the same way to every agent, every cycle.
Why it's published
An allocation you can't inspect is an allocation you can't trust.
A scheduler that quietly decides where thousands of agents go is a single point of unexamined judgement sitting in the middle of your operation. When it is right, nobody learns why. When it is wrong, nobody can prove it — the symptom is just a bad week.
So WorkflowHub publishes the decision. The allocation for a cycle is a visible artefact: which capacity went to which stage, and the state of the process that justified it. You can read it, disagree with it, change the policy that produced it, and afterwards check whether the agents actually followed it.
That is the same instinct as the rest of the platform: every action attributed to the identity that took it, every routing decision logged, nothing important happening off the record.
Questions a published plan answers
- Why is this stage crowded? Because the plan put capacity there — and the plan says on what grounds.
- Why did nothing finish this hour? Compare what the plan asked for against what the agents did.
- Is the policy doing what I meant? Change a knob, watch the next allocation, see the difference.
- Who decided this? The allocator, in the open — not an agent improvising on its own.
Built for the big, boring processes
Large, repeatable, and unglamorous is the point
The processes worth putting a team of agents on are the ones that run the same way thousands of times: intake, triage, gather, decide, close. Operations at the scale of a large contact centre — thousands of workers on one process — is the shape this is designed for.
One process, many workers
The workflow is defined once — stages, fields, rules, gates. Whether ten agents or a team of agents of them work it changes the allocation, not the process.
Scale doesn't suspend the rules
The human approval gate is enforced by the platform, not by each agent's good behaviour. A queue that requires a person still requires a person at any agents size — see the Golden Rule.
The process reports on itself
Where work waits, how long each stage takes, what a finished item cost — the same reporting that makes a small workflow measurable is what makes a team of agents steerable.
Where this is: agents allocation is capability we are building and running against our own workload, and we describe it here as a capability — not as a benchmark. We publish no throughput figures we haven't earned in your environment. Bring a real process and we'll measure it together.
Have more agents than coordination?
Bring a large, repeatable process and the capacity you're already paying for. We'll set it up, point the allocator at it, and you'll be able to read every decision it makes.