Sort by stakes and reversibility
Skip to content

Decide where human judgment stays

TL;DR: Decide which parts of a workflow need a person and which an agent can own, and make the line explicit.

  • Sort each step by stakes and reversibility: people hold the high-stakes, hard-to-reverse work; agents take the bounded, checkable, low-cost work.
  • Keep a single named person accountable for the result, not a team or a role.
  • A visible line earns trust, which is what keeps people actually using an agent.
  • Revisit the sort on a set cadence, because capability moves faster than most review cycles.


With a workflow reshaped, the central decision is which parts of the work need a person and which an agent can own. Getting this right is what makes the rest of working with agents possible: it tells you where to place oversight, where autonomy can grow, and who stays answerable when something goes wrong. This page covers how to sort the work, how to keep accountability clear, and why the sort isn’t permanent.

Sort by stakes and reversibility

The central question is which parts of the work need a person and which an agent can own. A useful way to sort is by stakes and reversibility:

  • Keep a human in charge where a decision is hard to reverse, carries real consequences, requires accountability, or depends on context, values, or judgment an agent does not have.
  • Let an agent run where the work is bounded, the output is checkable, and a mistake is low-cost and easy to undo.

Keep a named human accountable

An agent can hold capability, but not accountability. A single named person, not a team or a role, stays accountable for the result, and that stays true, and becomes more important, as an agent takes on more of the work.1 Where a decision affects people directly, such as hiring, performance, or access, a person keeps the decision, with the agent informing or drafting rather than deciding.1

A clear line earns trust

Drawing a clear line between people and agents — documenting which work stays with a person and which an agent can own — does more than get the work to the right owner. It’s also what gives people justified confidence to rely on an agent. When AI is available but its output still needs heavy review and correction before anyone can act on it, its perceived value drops quickly, and people quietly stop using it even when adoption looks high on paper. Being explicit about where an agent is reliable and where a person’s judgment is still required is what keeps that confidence intact: people know which outputs they can lean on and which they still need to check. Sustained use follows trust, and trust follows a line people can see.

Revisit on a cadence as capability changes

For items that you decide require human judgment today, that might not be the case six months from now, so consider reviewing on a set cadence (e.g., quarterly) to ensure that human judgment is still required. Capability moves faster than most review cycles, so the sort is a living decision rather than a one-time call. Choosing and revisiting workflow autonomy in GitLab Well Architected covers how to decide which work agents carry through, which work keeps a person involved, and how to adjust that split as your team learns.

In practice: Deciding a system’s authority before it acts

When a spacecraft separates from its rocket, there’s a stretch before it can reach the ground where it is on its own, and its flight software senses and responds to its environment without help, adjusting its position and handling faults until it can make contact with a ground station. That autonomy is safe for a specific reason: long before launch, engineers decide which choices the craft may make on its own and which must wait for a human on the ground, so the boundary of authority, including where control passes from machine to person, is set in advance rather than in the moment.2

Before you let an agent act on its own, map its authority the same way: what it may decide alone, where its judgment is likely to be brittle, and the point at which control returns to a person. Deciding that up front is the difference between autonomy you designed and autonomy you discovered after something went wrong.

Try this. Take one workflow an agent runs and sort its steps by stakes and reversibility. For each step you’d let the agent own, write the point at which it should stop and hand back to a person. For the whole workflow, name the single person accountable for the result.

// References

  1. Eslick, Ian, and Collin Fox, Amanda Graham, Suzette Johnson, Chuck Lafferty, Tom Kilcommons, Rosalind Radcliffe, Cat Swetel, Annie Vella, Sam Yeats, and Robin Yeman. "The Sociotechnical Architecture of AI-Enabled Enterprises: Principles, Patterns, and Practices for Human-Governed AI." Enterprise Technology Leadership Journal 3, no. 2 (Fall 2026). https://itrevolution.com/product/sociotechnical-architecture-of-ai-enabled-enterprises/.
  2. Cockcroft, Adrian, and Jeremy Eder, Joseph Enochs, Jenn Spykerman, and Brian Wald. "When Agents Decide: Continuous Decision Intelligence and the Substrate Beneath It." Enterprise Technology Leadership Journal 3, no. 2 (Fall 2026). https://itrevolution.com/product/when-agents-decide/.

/ Go deeper on this topic

Working with agents