Contribution. Product Designer, UX & UI, product design & design system.
Tools. Sketch, Figma, JavaScript, HTML & CSS, VS Code, Claude Code.
Status. In progress.
Note. Under NDA. The original design was done in Sketch. The visuals here are schematics recreated in Figma with sample data, not the shipped interface. Design file on Figma.
Where it started. Each AI agent ran as its own tool. Runs came in on schedules, from engineers using the CLI or the API, and from webhooks sent by other pipelines. The agents were doing the work. Nobody outside the terminal could see it.
Developers dug through CLI output and repo logs to follow a run, managers couldn't see runs at all, and tracing one across agents took everyone a long time.
There was also a cost question. Agents aren't free, and leadership wanted to know whether agent triage was worth it compared with people doing the same job.
The problem. You could follow one agent at a time, and acting on one meant opening a shell. Version 1 showed agent work as an activity feed. That held up for a handful of runs, but when I tested it with simulated data at thousands of executions, there was no way to get an overview from it.
The brief. Make the agent work visible, make it possible to act on, and make it trackable. In practice that meant one view of the whole system that shows how runs move between agents, where they loop back, and where they pile up, with every agent one click away. Any change to a run had to wait for a person and be recorded.
The product is built to measure time to triage, how often people correct each agent, and the cost of a triaged run compared with human triage.
Who sees what. Sign-in happens through single sign-on, and there's no workspace picker. You only see the workspaces you belong to, and the app opens the one you used last. The workspace decides what you see and which controls you get, and your position changes things again inside it.
This demo uses two workspaces. Triage is for engineers, QA, managers and PMs: full run content, approving key decisions, pausing and re-running, and scheduling runs. Admin adds restarting agents and configuring agents, schedules and bindings. Workspaces can also be teams, so most people belong to several.
Execution counts follow the same rules, so two people can see different totals for the same week. Position sets the landing view, the default filters and which metrics show first: on-call QA opens on runs that need action, and managers and PMs open on Metrics.
If a workspace can never do something, the control isn't there, because a greyed-out Restart button would only raise the question of why it can't be pressed. A control only shows as disabled when the person could use it but the run's current state won't allow it, and the tooltip says what's blocking it.
Links to runs end up in tickets, chat and CLI output. If you open one you can't see, the page says the run may not exist or you may not have access, and it says the same thing in both cases. A more specific message would tell people outside a project which runs exist.
Designing the overview. I modeled the overview on the Tokyo subway map. Agents are the stations, and runs travel the lines between them. Sources sit on the left and outcomes on the right, since those are the two main ways to filter runs.
I tried Sankey diagrams first, but with simulated data at scale the loops between agents were too hard to follow. The map is a little unfamiliar the first time, so the key is always one click away. Each agent shows its health as a label and an outline, so status never depends on color alone.
The overview is built around finding runs that didn't finish. Pick a source, an outcome, or both. The map highlights the path those runs took, agent health shows whether the agent or the test is at fault, and the side panel lists every affected test to rerun. Runs that failed for the same reason are grouped, so someone can deal with the cause once.
Where people step in. The agents do the triage. People step in for two things: approving key decisions and re-running when something breaks. Clicking an agent opens its panel, with the drafts waiting for approval, the reasons runs stopped there, and a button to re-run the stopped ones. Agents propose and people approve, because an agent that files the wrong thing on its own does more damage than a short wait for someone to check it.
When a step fails, the run stops there and waits. The error and the agent's suggested fix sit next to each other, and the later steps don't run until someone picks what to do.
Each run also has a dashboard, opened from its detail page, with the triage results for every test case. It groups cases by which verdict might be wrong: the label, the review, or the agent's. People record their own call on each case and can append those calls to the results.
When things go wrong. I designed a screen for each way this can break. If a session expires while someone is making a decision, they're signed back in and their choices are still selected. If someone else decides first, nothing changes and the message says who made the call.
Metrics. QAs and QEs track their own output: runs triaged, time to triage, and how often people correct each agent. Management sees what agent triage is worth: cost per run, hours saved, and tickets sent back for a rewrite, compared with human triage.
Design system. I built a shared design system before redesigning any screens, so every status color means the same thing across the agent tools.
Tokens come in layers. The raw palette is hidden so it can’t be picked directly, and components use role-based colors like “needs action” or “panel background” instead. Dark and light mode were designed together from the start, as two sets of values for the same roles. Names copy straight into code: color/status/needs-action in Figma is var(--color-status-needs-action) in CSS.
Status colors mean the same thing everywhere, and category colors are never used for status. Status always comes with a word, and usually a shape or border style too, so it still reads for people who are color-blind.
Components are built in layers too. Buttons and tags combine into agent nodes and step cards, and those make up panels like the run title or the agent panel. Adding an agent or a workspace means adding data. The components stay the same.
Process. Figma couldn’t show thousands of runs moving at once, so I built 13 prototypes in code with Claude Code and combined the parts that worked. AI agents ran user tests first to catch the obvious bottlenecks, and they checked every build against WCAG AA.
The full design file, with the flows, tokens, components and every screen state, is on Figma.
Say hello!