When should AI act on its own — and when shouldn’t it?
“Can the AI just do this on its own?” is the wrong question — it can do more than you’re comfortable with. The right question is should it, and who’s accountable when it does.
“Can AI do this on its own?” is the wrong question — the tech can already do more than most people are comfortable with. The right question is “should it, and who’s accountable?” Autonomy isn’t a switch you flip once; it’s a dial you set per decision against four tests — reversibility, stakes, frequency and ambiguity — with the boundary made explicit, auditable and yours.
The question I get asked most is some version of “can the AI just do this on its own?” It’s the wrong question. The technology can do far more on its own than most organizations are comfortable with. The real question is never can it — it’s should it, and who’s accountable when it does.
Autonomy isn’t a property you grant a system once and forget. It’s a setting you choose, decision by decision, with your eyes open. Get it right and the system earns trust by being useful and predictable. Get it wrong in either direction — too timid or too bold — and it either wastes everyone’s time or quietly creates risk nobody signed up for.
Autonomy is a dial, not a switch
The car industry worked this out a decade ago. Nobody serious talks about “self-driving” as a yes/no; they use the SAE levels, 0 through 5 — hands-on assistance, hands-off in conditions, eyes-off in a defined domain, and so on. The whole point is that autonomy is graded, scoped, and conditional. Agentic systems are no different, and yet most people still reach for the binary: either a human does the task or the machine does.
In practice there’s a whole spectrum between those poles, and almost all the good design lives in the middle. An agent can draft and a human can approve. It can act and notify, so a person can catch and reverse. It can act freely within hard limits and escalate anything outside them. It can run fully autonomously on the boring 85% and route the ambiguous 15% to a human with all the context attached. Each is a different setting on the same dial.
You don’t make a system autonomous. You make each decision inside it as autonomous as it has earned the right to be.
The two costs you’re trading
Every point on the dial trades two costs against each other. Turn autonomy up and you save time but raise the cost of a mistake going uncaught. Turn it down and you catch more mistakes but pay for a human’s attention on every single case — including the thousands that never needed it.
The mistake most teams make is setting one global level for the whole system out of nervousness — usually too low — and then wondering why the AI didn’t save them much. They’ve paid for a human to babysit ten thousand routine cases just to catch the handful that mattered. The leverage was never in reviewing everything. It was in reviewing the right things.
Spend human judgment where it changes the outcome — on the rare, high-stakes, ambiguous calls. Let the system own the rest.
Where we draw the line
When we design an agentic system, we set the autonomy of each decision against four questions. They’re simple, and together they’re surprisingly decisive.
How reversible is it?
An action you can undo cheaply can run with far more autonomy than one you can’t. Drafting a reply is reversible; wiring a payment is not. The cost of being wrong, not the difficulty of the task, sets the ceiling.
How high are the stakes?
A wrong call on a routine internal task is an annoyance. A wrong call on something a customer sees, or that carries legal or financial weight, is a different category. Stakes pull the dial down regardless of how confident the model is.
How often does it happen?
High-frequency, low-stakes decisions are exactly where autonomy pays off — there are too many to review and each one barely matters. Rare, heavy decisions are where a human belongs, because there are few enough to attend to and each one counts.
How ambiguous is it?
When the right answer is clear and the inputs are clean, let it run. When the situation is genuinely novel or the signals conflict, that’s precisely the moment to hand it to a person — with everything the system already gathered.
Make the boundary explicit — and auditable
Wherever the line lands, it has to be visible. A system whose autonomy lives in someone’s head, or buried in a prompt nobody revisits, is one you can’t trust and can’t govern. So we make the boundary an artifact: written down, owned by a named person, and logged every time it’s exercised.
Every autonomous action leaves a trail — what it did, why, on what inputs — and every escalation records why the system chose to ask instead of act. Over time that log becomes the most valuable thing you own. It’s how you tune the dial up safely as the system proves itself, and how you answer the only question that ultimately matters: when the machine acted on its own, can you explain exactly why?
That’s the standard we hold. Not maximum autonomy, not minimum — the right amount, made explicit, and always yours to change.
Where a business is quietly losing money
The leak is never where the org chart says. How we find it and measure it before building.
Read article
The Agentic Survival Blueprint for Media Agencies
When a machine plans in 10 minutes what a team does in 2 days, you haven’t gained speed — you’ve lost pricing power.
Read article