Watch every stream at once

Tags: parallel, monitoring, agents

Reading and supervising are different jobs. Reading needs one thing at a time. Supervising means catching the one that went wrong, which means seeing all of them — and a tab shows exactly one by construction, so an operator given tabs is switching rather than supervising.

The failure is always the one you were not looking at

That sentence is the whole argument, and it is close to tautological once stated. A tab strip over eight concurrent runs means seven are invisible at any moment. The probability that the interesting one is the visible one is one in eight, and interesting things do not wait for their turn.

Lists have the same defect in a different shape: everything is present, nothing is legible at a glance, and the operator scrolls — which is switching with extra steps.

Simultaneity costs resolution, and that is the actual design problem

You can see eight things at once only if each is small. So the question is not how do we show everything but how little can each stream show and still reveal that it needs attention?

The answer is usually far less than expected:

• A state colour. Running, blocked, failed, done.
• A progress shape — a bar, a sparkline, a count of steps completed.
• The last line of output, truncated. Often this alone is enough, because the last line of a run in trouble usually looks like trouble.

What you are building is not eight small versions of the detail view. It is eight tells, each designed to be read peripherally, with the detail view one click away.

Let the anomaly promote itself

A grid where all eight cells have identical visual weight has not solved the problem — it has made the operator scan instead of switch. Peripheral vision is drawn by difference, so the one in trouble has to look different: larger, outlined, moved to the front, coloured against the rest.

Two rules that follow:

• Expanding one must not hide the others. A modal over the grid reintroduces tabs. Inline expansion, a side pane, or a cell that grows in place — anything that keeps the rest in peripheral view.
• There has to be an aggregate as well as the grid. "Seven running, one failed" is information the grid makes you count. At eight streams counting is fine; at forty it is the only thing that works.

Past the point of readability

The bottom-right branch matters because the grid does not scale indefinitely, and a product that keeps adding tiles eventually produces something nobody reads at all. Past a few dozen, the grid stops being peripheral vision and becomes texture — and what you need is a number plus a list of the ones that are not fine.

Grounded in

User Study puts every angle live on one screen during a session: the phone screen, the workspace, and the voice assistant under test, all visible at once while the moderator runs the session.

The grounding detail worth keeping is what it replaced. The alternative was physically glancing between devices — a phone in one hand, a laptop, the assistant on the desk — and losing the moment you were not looking at. The fix was not a faster way to switch between them, and it could not have been; it was putting them in one field of view. That is the pattern in its most literal form, and the reason it generalises to parallel agents is that the operator's problem is identical.

Anti-patterns

• Tabs for concurrent streams. One visible, seven not.
• Equal visual weight regardless of state. The failing one looks like the seven that are fine, so the grid has to be read rather than glanced at.
• Expansion that occludes. A modal over the grid is a tab with a nicer animation.
• No aggregate. Making the operator count is making them do arithmetic under time pressure.
• A wall of tiles past readability. Two hundred cells is a texture, not a view.
• Streams that stop reporting when they fail. A cell frozen on its last good state is worse than an empty one, because it reads as fine. See show the machine listening — the same requirement, that a live thing has to keep proving it is live.

The smallest version worth building

A grid. One colour per state. The last line of output in each cell. The failed ones first.

That is an afternoon, and it is the difference between noticing a stuck run in ten seconds and noticing it when somebody asks why the job never finished.

Related patterns

• Runs need a shelf — the same material after the fact, where the question is which was best rather than which needs help.
• Show the agent working — what each cell expands into, and why stopping has to be reachable from the grid.
• Design the failure state first — in a grid of eight, some cell is always in a failure state, so it is the state the grid is really designed around.