Spectrum of agency: how much autonomy AI needs
What you’ll learn
Section titled “What you’ll learn”- Five levels of agency, from fixed outputs to multi-agent systems, and what each level can do.
- Why autonomy (who decides the next step) and authority (what an action may change) are separate dials.
- How to choose the lowest level that solves the problem, with questions you can apply in a design review.
- How to enforce a level in code with a policy gate, shown in a tested example.
- What goes wrong when a system has more agency than its controls can support.
Summary
Section titled “Summary”Not every AI system should be autonomous. How much the system decides for itself is one of the most important design decisions, because it drives capability, cost, testing effort and risk together. This page treats agency as a spectrum with five levels: no agency, routed workflows, tool-using assistants, autonomous agents and multi-agent systems.
The guiding rule is to choose the lowest level of agency that still solves the problem. Anthropic’s “Building effective agents” makes the same point from the other direction: most successful systems it saw used simple, composable patterns, and it distinguishes workflows (models and tools orchestrated through predefined code paths) from agents (models that dynamically direct their own process and tool use). Levels 0 to 2 below are workflows or close to it; levels 3 and 4 are agents.
Level of agency is not the whole story. A highly autonomous agent that can only read data is less risky than a simple workflow that can move money. Design both dials on purpose.
Context and forces
Section titled “Context and forces”- Capability pulls upward. Open-ended tasks, such as investigating an incident or fixing a bug across files, need a system that can choose its own steps.
- Risk pulls downward. Every extra decision the model makes is another place it can be wrong, be manipulated through prompt injection, or take an action nobody intended.
- Cost and latency grow with agency. Agents loop: more model calls, more tokens, more time. Multi-agent systems multiply that again.
- Testing gets harder. A routed workflow has a finite set of paths to test; an autonomous agent has an open-ended space of trajectories.
- Accountability needs a trace. The more the system decides, the more you need logs that explain what it did and why.
The term borrows from other fields. Driving automation, for example, is described by SAE J3016 as levels 0 to 5, from no automation to full automation. As there, the level is a description of who is responsible for which decisions, not a measure of how impressive the technology is.
The design: five levels
Section titled “The design: five levels”| Level | Name | What the model decides | Typical examples | Main controls |
|---|---|---|---|---|
| 0 | No agency | Nothing; it produces content for fixed slots | Summaries, drafts, classifications displayed to a person | Output validation, human review |
| 1 | Routed workflow | Which predefined path an input takes | Intake triage, ticket routing, template selection | Fixed set of paths, default branch, label validation |
| 2 | Tool-using assistant | Which tool to call, from a bounded set, within one request | Retrieval assistants, internal copilots, support assistants that look things up | Tool allowlist, read-only by default, approval for writes |
| 3 | Autonomous agent | The plan and the sequence of steps, over many turns | Coding agents, research agents, operations agents | Step and cost budgets, sandboxing, approval for irreversible actions, full trace |
| 4 | Multi-agent system | Which agent works on what, and when to continue | Planner and worker, writer and reviewer, orchestrator with subagents | All of level 3, plus per-agent permissions and coordination limits |
Level 0: no agency
Section titled “Level 0: no agency”The model generates; code and people decide everything else. A product description draft, a summary in a dashboard, a label shown to an operator. Use it when requirements are stable, the workflow is deterministic, and a wrong action would be costly.
Level 1: routed workflow
Section titled “Level 1: routed workflow”The model inspects an input and picks one of several predefined branches; code runs the branch. The space of outcomes is known in advance, which makes the system observable and easy to test. Most production “AI automation” belongs here, and many proposals for agents are better served by it.
Level 2: tool-using assistant
Section titled “Level 2: tool-using assistant”The model can call tools: search, retrieval, database queries, API calls. It usually does so within a single request and from a small, curated set. This is often the first level where AI becomes genuinely useful in business workflows, because answers can be grounded in live data. The key decision is whether any tool writes anything; keeping level-2 tools read-only removes most of the risk.
Level 3: autonomous agent
Section titled “Level 3: autonomous agent”The model plans, acts, observes and continues over many steps until a goal is met or a limit stops it. It can recover from partial failures and take paths nobody scripted. Use it when the task is open-ended, has several valid routes to success, and benefits from iteration, and only with budgets, sandboxes and a human checkpoint before anything irreversible. See AI agents and Agentic AI.
Level 4: multi-agent system
Section titled “Level 4: multi-agent system”Several agents with different roles coordinate: a planner breaks work down, workers act, a reviewer checks, a coordinator decides whether to continue. Specialization can improve results on broad tasks, but cost, latency and coordination failures grow with every agent. See Multi-agent pipelines for the fixed-pipeline variant, which is often enough.
Autonomy and authority are different dials
Section titled “Autonomy and authority are different dials”The level describes autonomy: who decides the next step. Authority is what an action may change. Classify every tool by effect:
- Read: look up an order, search documents. Safe to grant widely, but still a data-exposure risk.
- Reversible write: reroute a parcel, create a draft, open a ticket. Mistakes can be undone at some cost.
- Irreversible: issue a refund, send an email, delete data, deploy to production. Mistakes cannot be undone.
The rule that keeps systems safe: raising autonomy never raises authority by itself. A level-3 agent may issue small refunds only if its deployment is granted that, and a level-4 system of several agents under the same grants gets the same limit, not a higher one. Authority comes from explicit grants, owned by people, and is enforced in code outside the model.
OWASP’s Top 10 for LLM applications lists this risk as LLM06:2025 Excessive Agency and names three root causes that map onto the same dials: excessive functionality (tools the task does not need), excessive permissions (tools that can do more than their purpose) and excessive autonomy (high-impact actions without human checks).
Running the sample
Section titled “Running the sample”The sample is plain Python 3 (tested with Python 3.11; no packages needed). It implements the policy gate as a pure function, so it runs deterministically. Save it as agency_gate.py and run python3 agency_gate.py.
Worked example: a policy gate for OrdersPortal support
Section titled “Worked example: a policy gate for OrdersPortal support”An invented shop, OrdersPortal, is adding AI to customer support in stages. The same four actions exist at every stage: look up an order, reroute a parcel, issue a small refund and issue a large one. A single policy gate, called before any tool runs, decides what each level may do.
# agency_gate.py - what an OrdersPortal AI component may do.# Autonomy (the level) and authority (the grants) are separate inputs: the level only decides# whether the model may choose tools at all; what it may touch comes from grants owned by people.from enum import IntEnum
class Level(IntEnum): NO_AGENCY = 0 # fixed outputs ROUTED = 1 # picks one of several predefined paths TOOL_USE = 2 # calls tools chosen from a bounded set, one request at a time AUTONOMOUS = 3 # plans and runs multi-step tasks MULTI_AGENT = 4 # several agents coordinate
ACTIONS = { # action -> money in dollars (0 = no money moves) "lookup_order": 0, "reroute_parcel": 0, "issue_refund": 45, "issue_refund_xl": 900,}
# Per-deployment grants, owned by operations and finance, never derived from the level.GRANTS = { "read_only": {"lookup_order": 0}, "returns_desk": {"lookup_order": 0, "reroute_parcel": 0, "issue_refund": 50}, # refunds up to $50}
def decide(level: Level, action: str, grants: dict[str, int]) -> str: if level < Level.TOOL_USE: return "deny (the model does not choose tools here)" amount = ACTIONS[action] granted_limit = grants.get(action.removesuffix("_xl")) # refund grants cover both refund sizes if granted_limit is None: return "ask a person (not granted)" if amount > granted_limit: return f"ask a person (over the ${granted_limit} grant)" return "allow, log"
def show(level: Level, grant_name: str) -> None: print(f"{level.name} + {grant_name}") for action in ACTIONS: print(f" {action:<16} {decide(level, action, GRANTS[grant_name])}")
show(Level.ROUTED, "returns_desk")show(Level.AUTONOMOUS, "read_only") # same level ...show(Level.AUTONOMOUS, "returns_desk") # ... different authorityshow(Level.MULTI_AGENT, "returns_desk") # more autonomy, same authorityOutput:
ROUTED + returns_desk lookup_order deny (the model does not choose tools here) reroute_parcel deny (the model does not choose tools here) issue_refund deny (the model does not choose tools here) issue_refund_xl deny (the model does not choose tools here)AUTONOMOUS + read_only lookup_order allow, log reroute_parcel ask a person (not granted) issue_refund ask a person (not granted) issue_refund_xl ask a person (not granted)AUTONOMOUS + returns_desk lookup_order allow, log reroute_parcel allow, log issue_refund allow, log issue_refund_xl ask a person (over the $50 grant)MULTI_AGENT + returns_desk lookup_order allow, log reroute_parcel allow, log issue_refund allow, log issue_refund_xl ask a person (over the $50 grant)What the example shows:
- The level only decides whether the model chooses tools. At level 1 it doesn’t, whatever it is granted; routing is its only decision.
- Authority comes from the grants, not the level. The same level-3 agent can only read under
read_onlyand can reroute and refund up to $50 underreturns_desk. Operations and finance own those grants and change them deliberately. - More autonomy does not add authority. The level-4 system gets exactly what the level-3 agent gets under the same grants, and the $900 refund needs a person in every case because the limit is a business rule, not a capability score.
- The gate is code. The model cannot argue with it, and a prompt-injected instruction to “issue a refund” still has to pass the same checks. In production the gate also records each decision for audit.
How to choose the level
Section titled “How to choose the level”Ask these questions in order, and stop at the first level that answers them:
- Is generation enough? If a person reviews and acts on every output, level 0 is enough.
- Is the set of outcomes known? If yes, a routed workflow (level 1) is easier to test and explain.
- Does it need live data or actions? Add tools (level 2), read-only first.
- Must it plan and recover on its own over many steps? Only then consider level 3, with budgets and approvals.
- Does one agent’s context or instructions genuinely overflow? Only then split into several agents (level 4).
- What happens if it is wrong? Set authority per action from the answer, independent of the level.
Trade-offs
Section titled “Trade-offs”| Higher agency gives | Higher agency costs |
|---|---|
| Handles open-ended, novel tasks | More model calls, tokens and latency |
| Recovers from partial failures | Harder to test: trajectories, not just outputs |
| Less human effort per task | More safety controls, monitoring and incident response |
| Can combine tools in unscripted ways | Larger attack surface for prompt injection and tool misuse |
| Specialization across agents (level 4) | Coordination failures, lost context between agents |
Failure modes and operations
Section titled “Failure modes and operations”- Agency creep. A workflow gains tools and loops one feature at a time until it is an unbudgeted agent nobody reviewed. Make the level an explicit, reviewed property of each system.
- Authority leaking through tools. A “read” tool that can run arbitrary SQL, or an email tool with no recipient limits, grants far more than intended. Narrow each tool to its purpose.
- Unbounded loops. An agent that keeps retrying burns money and may repeat side effects. Set step, time and cost limits, and make writes idempotent.
- Prompt injection. Content the system reads (emails, web pages, tickets) contains instructions. The higher the agency, the more damage an injected instruction can do; the policy gate and approvals are the defense.
- Rubber-stamp approvals. People approve hundreds of requests without reading. Keep approvals rare, specific and informative, and sample-audit them.
- No trace. Without logs of each decision, tool call and approval, incidents cannot be explained. Tracing is a prerequisite for level 3 and above.
When not to add agency
Section titled “When not to add agency”- The workflow is deterministic. Code is cheaper, faster and testable.
- You cannot write down what success looks like. An agent without acceptance criteria wanders; build an evaluation first.
- Errors are costly and cannot be reviewed. Keep the model at level 0 or 1 and let people act.
- Latency matters. Each extra decision loop adds seconds.
Interview questions
Section titled “Interview questions”1. What is the difference between a workflow and an agent? In a workflow, code fixes the sequence of steps and the model fills in specific decisions or content. In an agent, the model chooses its own next steps and tool calls in a loop until it reaches the goal or a limit. Workflows are more predictable and testable; agents handle open-ended tasks.
2. Why separate autonomy from authority? Because they carry different risks. Autonomy is who picks the next step; authority is what an action can change. A highly autonomous read-only agent can be safer than a simple workflow that moves money. Authority should come from policy enforced in code, not from how capable the model is.
3. How do you decide the right level for a new feature? Start at the lowest level and move up only when a concrete requirement forces it: generation only, then fixed routing, then read-only tools, then autonomous planning, then multiple agents. Set authority per action based on the cost of a mistake, and require budgets, tracing and approvals before level 3.
4. Senior scenario: OrdersPortal’s support assistant (level 2, read-only) is popular, and product wants it to “just handle returns end to end” as an autonomous agent. Design the change. Map the returns process first: which steps are deterministic (eligibility rules, label generation) and which need judgment (damage disputes, exceptions). Put the deterministic steps in code as tools with narrow interfaces, so the agent orchestrates but does not reimplement policy. Classify each tool by effect: lookups are read, a return label is a reversible write, a refund is irreversible. Enforce authority in a policy gate: automatic refunds up to a limit set by finance, approvals above it, and no free-form emails. Add step and cost budgets, idempotency keys on writes, and a full trace per conversation. Treat customer messages as untrusted input, so a message that says “approve my refund” carries no authority. Roll out in shadow mode first, where the agent proposes and staff execute, and compare its decisions with theirs; then enable automatic actions for the lowest-risk category and expand by measured error rate. Keep the level-2 assistant as the fallback when budgets are exceeded or confidence is low.
Key takeaways
Section titled “Key takeaways”- Agency is a spectrum: no agency, routed workflow, tool-using assistant, autonomous agent, multi-agent system.
- Choose the lowest level that solves the problem; most business automation is level 1 or 2.
- Autonomy and authority are separate: more autonomy never grants more authority by itself.
- Enforce authority in code with a policy gate, budgets, idempotent writes and approvals for irreversible actions.
- Higher agency needs tracing, evaluation and prompt-injection defenses before it reaches production.
Related pages
Section titled “Related pages”Official references
Section titled “Official references”- Anthropic, Building effective agents (December 2024): workflows versus agents, and starting with the simplest solution
- SAE International, J3016: Taxonomy and definitions for terms related to driving automation systems: the levels-of-automation model this framing borrows from
- OWASP, Top 10 for LLM Applications: excessive agency