Oversee: autonomy you can supervise
Scope it. Preview it. Interrupt it. Undo it.
Chatbots talk. Agents act: they send the money, change the records, email the customer. An agent that can act can do damage, and "are you sure?" pop-ups don't scale to work that runs for minutes across dozens of steps. Oversee explores the control surface that does scale. Autonomy is a setting, not a default. A dry run shows effects before anything happens. Interruption is a first-class action. And reversibility is the property that makes any of it safe.
Fully interactive. Change the permission scope, run a dry run, start the run, then hit Interrupt now mid-task and try resume, redirect, or rollback. Built on the Minia design system. Opens in desktop by default; use the toggle for mobile. Data is synthetic.
The problem: a system that can act can also do harm
Agentic AI moved the risk. The failure is no longer a bad sentence. It's a bad action, already taken.
A chatbot that hallucinates wastes your time. An agent that hallucinates pays the wrong vendor, deletes the wrong records, or emails the wrong list, and by the time you read the summary it's done. The instinctive fix, a confirmation dialog on every step, fails both ways: nobody clicks carefully through a fifty-step job, and approving on autopilot feels safe without being safe. Autonomy has shipped as an on/off switch. It needs to be a surface: one that bounds what an agent may do, shows what it's about to do, lets you stop it mid-run, and lets you take actions back.
The choice Oversee makes, rendered live in the Minia design system, the same theme as the prototype above.
The thesis: autonomy is a setting, not a default
Supervision shouldn't depend on an operator being fast enough to catch a mistake. It should be built into what the agent is structurally able to do.
Everything starts from one move: give every action a state, and let that state decide what may run on its own and what must wait. Reversible work proceeds. The dry run only previews. Consequential steps pause at a gate. The irreversible never runs unattended. Four states, one vocabulary, and colour is never the only signal.
The four-state model, rendered live in the Minia design system, the same theme as the prototype above.
Show the effects before the act
A dry run executes the plan against a sandboxed copy and reports what would happen before anything real moves.
The most dangerous moment with an agent is the gap between "it decided" and "you found out." The dry run closes it. It surfaces the same matches, flags, and totals the real run would produce, so you see consequences while they're still cheap to change. Nothing is sent. The number on screen is a forecast, and it says so.
A dry-run forecast, rendered live in the Minia design system, the same theme as the prototype above.
Interruption is a first-class action, not an escape hatch
"Stop" can't be buried three menus deep. It's present in every running state, and pressing it gives an honest account of partial work.
Interrupt a run and Oversee freezes and tells you exactly where things stand: what's done, what's in flight, what's still queued. From there you resume, redirect with new instructions, or roll back. Stopping is never a leap into the dark. Try it in the prototype above: start the run, then hit Interrupt now mid-task.
What you see the moment you interrupt, rendered live in the Minia design system, the same theme as the prototype above.
Reversibility is the real safety property
Confidence to delegate comes from being able to take it back. What can't be taken back is gated up front, and the gate shows the stakes, not a generic "confirm."
Most of an agent's work is reversible, so most of it can run freely and be rolled back if you change your mind. The rare irreversible step, releasing a payment or emailing a customer, must never run unattended. Oversee pauses there, names the act, quantifies it, and says plainly that it can't be undone. "No" is the most important word on the screen.
The approval gate, rendered live in the Minia design system, the same theme as the prototype above.
How it got here: v1 → v7
The control surface wasn't designed all at once. Each version added one capability and earned the next, sharpening one thesis instead of stacking features.
It started as a plan the agent would simply execute. Every version after that closed a gap between what the agent could do and what an operator could see, stop, and undo, ending at the one rule that makes the whole thing safe: the irreversible step never runs unattended.
-
1
Plan, then execute
The agent proposed a plan and ran it. Legible, but no way to see effects in advance.
-
2
+ Dry run
Added a sandboxed preview so effects (matches, flags, totals) were visible before anything moved.
-
3
+ Permission scope
Made autonomy editable: each capability a toggle, money movement gated no matter what.
-
4
+ Step-by-step execution
Replaced the spinner with a visible, state-tagged run you can follow.
-
5
+ First-class interrupt
Put "stop" in every running state, with an honest summary of done, in-flight, and queued work.
-
6
+ Rollback (reversible only)
Added undo, scoped to what can be taken back. It never promises to unsend money.
-
7
+ Approval gate · current
Closed the loop: the one irreversible step pauses and shows the exact stakes before you commit.
Explore more work
More explorations from the AI Product Design Lab, each a different facet of making AI products people can direct, verify, supervise, and trust.
Steer, intent before generation
Turn an under-specified prompt into a negotiated brief: the model surfaces what it inferred and flags ambiguity before it commits.
View exploration
Ground, verify what AI claims
Every claim traceable to a source with confidence and freshness; unsupported claims flagged; source conflicts shown, not smoothed over.
View exploration
Recall, legible AI memory
A memory layer you can see, attribute, edit, scope, and revoke. Personalization as a negotiated, inspectable thing, not a black box.
View exploration