The Principle of Least Agency

There is a quiet reflex in this industry to reach for the most autonomous system a problem could conceivably justify. A ticket needs triaging, so we sketch a multi-agent swarm. A form needs validating, so we hand the keys to a planner that can call six tools. It feels like ambition. Usually it's the opposite — it's skipping the harder question of how little autonomy would actually do the job.

Borrow a page from security engineering. The principle of least privilege says a process should be granted only the permissions it needs to function — no standing access to anything it doesn't provably require. Nobody argues that giving every service root access is "more powerful." It's just more dangerous, for no benefit. Agency deserves the same discipline.

The Principle of Least Agency: a solution should be granted the minimum agency required to satisfy its requirements — and no more.

Agency, here, is where a system sits on the spectrum below: from a deterministic rule that does exactly the same thing every time, all the way to a self-directed agent that sets its own subgoals. Each step to the right buys adaptability. Each step also spends something real.

Level 0

Rules & Automation

Level 1

Assisted

Level 2

Orchestrated

Level 3

Supervised Agent

Level 4

Fully Agentic

Human controlAutonomy · cost · non-determinism →

01More agency is a cost, not a feature

The seductive framing is that autonomy is a capability you either have or don't — a bigger number on the spec sheet. It isn't. Every degree of agency you add is a trade you are making, whether or not you noticed you made it. Four things get worse as the flame climbs.

It over-engineers the solution

A system with more moving parts than the problem requires is not more sophisticated — it is more of a liability to build, test, and keep alive. An orchestrated workflow you could have written as fifty lines of deterministic code now needs prompt tuning, tool schemas, retries, evaluation harnesses, and a plan for what happens when the model improvises. You didn't solve a harder problem. You created one, and now you own it.

It bloats the cost — and the cost keeps running

Autonomy has a meter. Where a rule executes for effectively nothing, an agent reasons across multiple model calls, re-reads context, second-guesses, and calls tools that call models of their own. The bill is not a one-time build cost you can amortize; it recurs on every single invocation, and it scales with your success. The more the system gets used, the more that unnecessary agency compounds against you.

It injects non-determinism where you never needed any

This is the one that hurts in production. A deterministic step is testable: same input, same output, forever. The moment you introduce a model's judgment, you introduce variance — the same request can now resolve five subtly different ways. Sometimes that variance is exactly what you're paying for. But when the task had one correct answer all along, you have traded a component you could certify for one you can only monitor. You've added a new and interesting way to fail, for a flexibility the requirement never asked for.

It hands decisions to a model's biases

A model carries the biases of its training data and its own opaque priors into every judgment it makes. Where you've genuinely delegated a judgment call, that's a tradeoff you accept and guard against. But where you let a model decide something that a clear rule, a policy, or a person should have owned, you have quietly outsourced a value-laden decision to a black box — and you'll wear the consequences when it drifts in a direction nobody chose.

02Keep humans on the decisions that can't be undone

Non-determinism is manageable when mistakes are cheap and reversible. It becomes a genuine hazard when the system can take actions that are expensive, public, or permanent — issuing a refund, sending a legal notice, changing a medication record, moving money. These are exactly the decisions where variance is least acceptable and a wrong autonomous call does the most damage.

So the rule pairs naturally with a second one: the higher the stakes and the harder a decision is to reverse, the more it belongs to a human — or at minimum behind an explicit approval gate. Least Agency doesn't mean a person touches everything. It means autonomy is spent on the reversible, high-volume, low-drama parts of the work, and the critical, one-way-door decisions stay under human control by design. That's not timidity. It's putting the flame where it earns its keep and keeping it away from where it can only burn you.

03How to apply it

The principle turns into a practice by inverting the usual default. Instead of starting from the most capable architecture and trimming, start from the least and climb only when a requirement forces you to.

1. Start at the bottom of the spectrum. Assume rules and automation until proven otherwise. If a deterministic solution meets the requirement, you are done — ship it and don't apologise for it.
2. Make agency earn each step up. Move one level to the right only when you can name the specific requirement that the current level cannot satisfy. "It might be nice" is not a requirement. "The input is open-ended natural language we can't enumerate" is.
3. Gate the irreversible. Wherever the system can do something costly or permanent, put a human approval or a hard guardrail in front of it — regardless of how much agency the rest of the flow has earned.
4. Re-check at every review. Agency tends to creep upward as features accrete. Periodically ask whether any part of the system is now more autonomous than its requirements still justify, and turn the flame back down where it isn't paying for itself.

The single question that carries the whole principle is small enough to keep in your head: what requirement, exactly, forces more agency here? If you can answer it crisply, climb — you've earned the step. If you can't, you have your answer, and it's the cheaper, calmer, more certifiable one.

Turn the flame up only as far as the problem earns. Everything above that line is cost you pay and control you give away — for nothing.