A Control Surface for Agents: Making Concurrent Sessions Visible
AI
When many agent sessions run at once, the failure is losing the one that is waiting. How our team made session visibility an operator surface with explicit contracts.
Published November 2026, dated to the month the work was done.
When a team runs many agent sessions at once, the first problem is not intelligence. It is visibility. Which session is waiting for a decision? Which one finished? Which one is stuck? The stock taskbar was built for a handful of applications. It collapses every session under one icon, so the operator cannot see which one needs a decision.
Our team replaced it on our operator workstations with a small native control surface: one bar per display, live window counts, and a searchable switcher that reaches any session in one keystroke. The tool is incidental. The point is a set of contracts: the operating system shell is never modified, hovering never changes state, and every focus change is bounded and tested. When an operator cannot find the session that needs them, trust fails quietly, and nobody can say exactly why.
The problem is finding, not launching
Starting an agent session is cheap. Finding it again is not. Which terminal holds the migration plan? Which one is waiting for an answer? Which display did that browser land on? A taskbar that shows "Terminal" with a count does not answer the real question: which one needs me now?
We wrote the requirements before any code. One bar per display. Real application icons with live window counts. A panel that lists every open window and can be searched by title, folder path or process. One key to reach the result. And a rollback path to the stock taskbar that works at all times.
Choosing the rendering boundary
We evaluated four approaches against those requirements.
- Modifying the stock taskbar. This failed the first contract. We do not patch the operating system shell or depend on code we do not control running inside it.
- A classic drawn window. It was ours, but it could not meet the scaling and visual requirements.
- A web view inside a bar. It looked right, but it carried a full browser runtime for a bar, and clicks took focus away from the operator's work.
- A small native window drawn on the GPU. This met every requirement.
The native version happens to be written in Rust and drawn with Direct2D. The durable decision was not the language. It was owning rendering, focus, scaling and recovery explicitly, instead of wrapping someone else's engine. One rule held across all four options: hide the stock taskbar, never modify it, and keep a tested one-command restore.
Three failure modes the design now refuses
Each of these was silent. The program kept running, and nothing told the operator what was wrong.
- Lifecycle messages must not be swallowed. An event handler without an explicit message contract can become a catch-all and silently drop window creation. Lifecycle handling must be exhaustive, and on an event path a compiler warning is treated as a defect, not noise.
- Drawing and clicking share one coordinate model. On displays with high scaling, the drawing surface inherited the scale, so icons were drawn in one place and clicks were tested in another. The surface is now pinned to physical pixels, and every size is scaled by each display's real factor. Clicks land exactly on what the operator sees.
- Focus transfer is bounded. The bar never takes focus, like the real taskbar, so clicking it does not disturb the active window. Without an explicit handoff, the platform reclaimed focus from the switcher, and typing leaked into the application behind it. The switcher now takes focus through an explicit foreground handoff, so keystrokes reach the search box and nowhere else.
The switcher is the operational view
The switcher became the primary way the team locates work. It opens next to the bar, at the height of the icon that was clicked, with the cursor already in the search box. On the left is a rail of every application with its live window count. On the right is a grid of cards, one per window, with the title, process and path. A colored chip on each card shows which display the window lives on. A toggle switches between dense rows and live thumbnail tiles. Arrow keys move, Enter jumps, Escape closes.
For agent work, search is what matters. Typing part of a project name or folder path turns dozens of terminals into two.
Behaving the way operators expect
Two behaviors needed a second pass. Before changing code, we traced how Windows 11 handles each one and wrote down the exact sequence.
The first was Alt+Tab. Windows works like this: hold Alt, tap Tab to cycle, release Alt to switch, press Escape to return to where you were. We rebuilt the switcher's keyboard mode to match, with a watchdog so a missed Alt release can never leave it stuck open. A synthetic input test confirmed the three cases: it opens, Escape returns to the original window, and releasing Alt switches to the selected one. A live full-size preview of the selected window followed.
The second was hover preview. Here the review found the design was already right: previews use the system's live window thumbnails, which never touch the real window. We made that a written rule for all later work. Hovering is read-only. Nothing in that code path may minimize, move, restore or focus the real window. Only a real click does that.
What the design guarantees
This is Governance-Driven Contract Design applied to a small surface. Start with the outcome: an operator can identify and reach the session that needs them without guessing. Then state the guarantees that protect that outcome:
- The operating system shell is hidden, never changed, and always one command from restore.
- Reading is read-only. Hover and preview cannot change the state of any window.
- Focus moves only when the operator acts, and it lands where they expect.
- Every unexpected input state, such as a missed key release, has a bounded way out.
Visibility is the first capability a team needs when it works with many agents. Before better prompts or smarter orchestration, the team must see what is running and reach it at once. A taskbar sounds like a small thing. For this way of working, it is the front door, and the front door needs a contract like any other.
Tools are fashion. Trust is the work. Every line holds.