Framework · AI & design · 3 min read
Human-in-the-loop
AI proposes, a named human decides and stays accountable. Use it to set clear review, approval and undo points, both in your team's AI work and in the AI features you design.
-
1 Suggest
- Human
- Decides and acts
- For example
- "These 3 shipments may miss the cut-off"
-
2 Draft
- Human
- Reviews, edits and confirms
- For example
- A pre-filled customs form from a scanned invoice
-
3 Act with approval
- Human
- Approves the plan before it runs
- For example
- "Rebook 12 shipments. Approve?"
-
4 Act and report
- Human
- Sets limits, monitors, can undo
- For example
- Auto-rebooks below a cost limit, daily summary
-
5 Autonomous
- Human
- Sets goals and policies
- For example
- Rarely right for regulated operations
At every level, a named human stays accountable.
Use it when
- Your team uses AI for real deliverables and you need to be clear who signs off on AI-made work.
- A product team wants to add an AI feature or agent to an internal app, such as one that rebooks orders or pre-fills forms.
- Something AI-generated went wrong, and nobody is sure who was responsible.
How to use it
- Name the decision owner. For each AI-supported task or feature, write down the person or role who decides and stays accountable. In your team that is the designer who ships the work; in a product it is the user or role who approves the action. Output: one named owner per task or feature.
- Place it on the autonomy scale. Decide whether the AI should suggest, draft, act with approval, act and report, or act autonomously. Rate the cost of an error, whether it can be reversed and any compliance needs. Start lower than you think. Output: one level per task, with the reason.
- Design the approval points. For risky actions, add an explicit step: preview, then confirm, then undo. Show the plan before a multi-step action ("I will do these 5 steps") and a diff before bulk changes. Output: marked approval points in the flow or the process.
- Make correction easy. Give users a simple way to reject, edit or undo, and capture the reason so corrections feed back. Keep an audit trail of who or what did what, when and based on what. Output: undo, edit and feedback patterns in the design.
- Move up only with evidence. Review acceptance and correction rates and the errors introduced. Raise the level of autonomy only when the data shows it is safe, and lower it again if errors appear. Output: a review date and the measures you will look at.
Worked example
An internal logistics operations tool plans an agent that rebooks shipments when a vessel is delayed. The team uses the autonomy scale to decide, case by case:
| Case | Level | Decision owner | Approval and undo |
|---|---|---|---|
| Flag shipments that may miss the cut-off | Suggest | Operator | Operator decides and acts |
| Rebook up to 12 shipments to the next vessel | Act with approval | Operator | Plan preview: "Rebook 12 shipments. Approve?" Undo for 24 hours |
| Rebook when the cost difference is below a set limit | Act and report | Team lead sets the limit | Daily summary; every action can be undone |
| Change customer contracts | Not automated | Account manager | Out of scope for the agent |
After a month, the correction rate for the "act with approval" case is low and stable, so the team discusses raising the limit for "act and report". They do not automate the contract case, because the cost of an error is too high.
Watch out for
- "The AI decided." If no person is named, nobody is accountable. Every AI action needs an owner who can explain it.
- Approval fatigue. Asking people to confirm every small step trains them to click "Approve" without reading. Put approvals where the risk is, and batch the rest.
- No real undo. A confirm button without undo makes every mistake permanent. Design the recovery path, not only the happy path.
- Autonomy by default. Teams raise autonomy because the model can do it. Move up one level at a time, and only with evidence.
Template
Copy this into your feature spec or your team's AI workflow doc, one row per task or AI action.
AI task / action:
Decision owner (person or role):
Autonomy level: Suggest / Draft / Act with approval / Act and report / Autonomous
Why this level: Cost of error: Reversible?: Compliance:
Approval point: (where, and what the person sees: preview, plan, diff)
Undo: (how, and for how long)
Feedback: (how corrections are captured)
Audit trail: (what is logged)
Measures: acceptance rate · correction rate · errors introduced
Review on: Decision to move up or down:
- Sentient DesignJosh Clark & Veronika KindredBook · 2026 (Amazon)
- Designing Assistant TechnologyChristopher NoesselBook · 2026 (Amazon)
- Guidelines for Human-AI InteractionAmershi et al., CHI 2019 (external site)
- Designing for Agentic AI: Control, Consent, AccountabilitySmashing, 2026 (external site)
"See on Amazon" links are affiliate links. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.