The Decision Boundary Is the Real Automation Boundary

Teams often measure automation by asking how much work the agent completed. That is useful, but it misses the harder question: which decisions did the system allow the agent to make? An agent may search, draft, test, revise, and package a result while a person still chooses the goal, judges the tradeoffs, and decides whether the evidence is enough.

The distinction matters because activity looks like control from a distance. A long autonomous run can feel as if the machine owns the process. Look closer and you may find that the consequential choices remain concentrated in a few moments: selecting the problem, defining acceptable failure, changing direction, and authorizing release. Everything between those moments can be automated without surrendering them.

Our position is that this is the useful way to design a software factory. Do not divide the system into work for people and work for agents based on old job descriptions. Divide it by authority. Give repeatable execution to machines. Keep human judgment where the consequences require an accountable choice, then make that choice legible enough for the factory to carry forward.

Most processes contain fewer real decisions than their meetings suggest. Status updates, handoffs, document formatting, searches, test setup, and routine revisions consume time, but they do not necessarily change the destination. They are often the transport layer around a decision that nobody has named clearly.

Start by finding the moments where a different answer changes the acceptable outcome. What are we trying to prove? Which risk are we willing to take? What evidence would stop the release? When should the system spend more money, request another review, or abandon the attempt? Those are decision boundaries. The surrounding work is a candidate for automation.

This exercise is uncomfortable because it exposes roles built around moving information rather than making accountable choices. That work will not remain protected because it once required coordination. Agents can preserve context, execute the routine steps, and route exceptions without waiting for another calendar opening. The jobs that survive will move toward defining boundaries and owning consequences, not supervising every mechanical step inside them.

Saying that a human stays in the loop is not a design. Which human? At what point? Looking at what evidence? With authority to do what? If those answers live in habit, the person becomes a vague dependency the factory cannot plan around. Every run pauses differently, and every decision arrives with a fresh reconstruction of context.

Turn judgment into an explicit interface. Present the decision, the available options, the evidence collected, the consequence of each route, and the default if nobody acts. Record the answer in a form the next stage can execute. A good interface does not ask a person to redo the agent's work. It asks for the smallest irreducible choice and makes the effect of that choice immediate.

Some boundaries should disappear as the factory earns trust. If a route produces reliable evidence, stays inside a limited blast radius, and can recover cheaply, the human decision may become a standing policy. Other boundaries should remain hard because the consequence cannot be delegated casually. The point is not maximum autonomy. It is deliberate authority.

A dramatic autonomous run tells you that an agent can remain busy. It does not tell you whether the operating model scales. Measure how often work reaches a decision boundary with complete evidence, how long the decision waits, how often people send it back, and whether the recorded choice changes future runs. Those signals reveal whether judgment is scarce, poorly framed, or being spent on work a rule could handle.

Also measure unauthorized decisions. If an agent can quietly redefine success, choose weaker proof, widen scope, or route around an approval, then the apparent human boundary is theater. Authority must be enforced by permissions, gates, and separate evidence. A sentence in a prompt is not enough when the system has another path available.

The factory gets stronger when it learns which choices truly need people and which only needed a person because the process was never encoded. That is how autonomy expands without becoming a trust exercise. Each removed checkpoint becomes policy and proof, not optimism.

The comforting version of automation says agents handle the dull tasks while everyone keeps the same role and spends more time being creative. That is not how an operating system changes. When repeatable execution moves into machinery, coordination roles shrink, decision rights become visible, and fewer people can direct more production.

Human judgment remains essential, but essential does not mean frequent. A person may make a handful of decisions that shape thousands of agent actions. That leverage is the point. It also means organizations will need fewer people doing the surrounding work, while expecting the people at the boundary to make clearer and more consequential calls.

Build for that reality. Separate execution from authority. Encode routine choices as policy. Bring people complete evidence when judgment is genuinely required. Then let the agents run. The winning factory will not be the one with the most impressive autonomous demo. It will be the one that knows exactly where autonomy ends, why it ends there, and what must be true before that boundary moves again.