Concurrency Dial

Framing

The problem

A multi-agent dashboard surfaces every running agent at once, but a person can only watch a few, so attention saturates silently until they start missing things.

The pattern

Let the user cap how many agents they actively watch at once, and route the rest into a queue that promotes the next agent into a lane the moment one frees up.

Why chat breaks here

Chat shows one stream, then five, then twenty, all competing for the same attention, with no surface to say "I can only watch three of you right now".

Risks

Set the cap too low and work stalls behind the queue; set it too high and you rebuild the saturation the dial was meant to prevent.

Avoid when

Only one or two agents ever run at once, so there is nothing to ration and the dial is pure overhead.

Use when

A dashboard that shows every agent at once makes oversight cost grow with agent count until the user breaks; a concurrency cap holds active attention fixed no matter how many agents are running.

DOPE evaluation

Directability

Slider chooses the concurrency limit; users can pin specific agents to a lane or defer others into the queue manually

Observability

The dial reads back current cognitive load — active lanes, pending queue depth, saturation indicator — so the user sees attention budget in real time

Predictability

The user sets the cap; the system never demands attention from more than N agents simultaneously

Explainability

Promotions out of the queue are named — "agent X promoted because Y completed" — so the user knows why an agent is now front-and-center

Closest neighbours

• PagerDuty · On-call schedules (PagerDuty) — Only one user per schedule is on call at a time; the rotation promotes the next person when a shift ends. The one-at-a-time attention cap the dial generalises — enforced by the system, not by discipline.
• Slack · Huddle participant cap (Slack) — A hard ceiling on simultaneous presence: 50 participants on paid plans, but only 25 with video on at once (the free plan caps at 2). A capacity limit on shared attention — though there is no queue; over the cap, latecomers are simply refused.
• GitHub · Draft pull requests (GitHub) — A draft PR suppresses review requests and notifications until the author flips it to "Ready for review", and cannot merge before then. Work keeps moving without demanding attention — the defer-then-promote half of the dial.
• Businessmap · Per-user WIP limits (Businessmap (Kanbanize)) — Kanban boards enforce a numeric cap on how many cards one person can have in progress; new work queues until a slot frees. The closest shipping version of attention as an enforced budget — in project management, not yet in agent consoles.

FAQ

When should I use the Concurrency Dial pattern?

A dashboard that shows every agent at once makes oversight cost grow with agent count until the user breaks; a concurrency cap holds active attention fixed no matter how many agents are running.

When should I avoid the Concurrency Dial pattern?

Only one or two agents ever run at once, so there is nothing to ration and the dial is pure overhead.

What problem does Concurrency Dial solve?

A multi-agent dashboard surfaces every running agent at once, but a person can only watch a few, so attention saturates silently until they start missing things.

Why is chat the wrong fit for this?

Chat shows one stream, then five, then twenty, all competing for the same attention, with no surface to say "I can only watch three of you right now".

Related patterns

• Extends: Agentic Dashboard — Dashboard shows every running agent at once; Concurrency Dial adds a declared cap that throttles them down to an attention budget and routes the rest into a pending queue.
• Often paired with: Supervisor-Worker — Supervisor-Worker structures the agent hierarchy; Concurrency Dial governs how many workers the supervisor surfaces to the user at any one moment.
• Often paired with: Oversight Rhythm — Concurrency caps how many agents demand attention right now; Rhythm batches when the user actually reviews. Compose them — declared throughput in space and in time.