AI Agents & Automation

Autonomous AI Agents: How Much Autonomy to Give Them, Action by Action

By Oliver Grant· Chief Digital Officer·October 4, 2026·14 min read
The headline 'Autonomy action by action' in white on a dark navy background, beside a glowing cyan flow diagram where one input splits into two paths of nodes and decision diamonds

The question we get asked most by teams planning autonomous AI agents is some version of "how much should we let it do on its own?" It is usually asked about the agent as a whole, as though autonomy were a dial on the product, and that framing is the source of most of the failed deployments we see. An agent does not have one level of autonomy. It takes dozens of different actions, and each action deserves its own answer.

This piece sets out how we make that decision in practice, using the best recent evidence on what production deployments actually look like, a simple two-question framework, and three worked scenarios from the kinds of systems we build.

What 150 production agents tell us about autonomy

In September 2026, The Brief Script published an analysis of 150 enterprise AI agents in production, drawn from 392 public records across 119 organisations. It is a secondary analysis of what companies chose to disclose, so it over-represents the confident and the well-documented, and the authors say plainly that it should not be read as market prevalence. Its value is the classification. Every deployment is placed in one of four autonomy tiers:

  • A1, tool-using read agent: chooses tools and queries data, but writes nothing to business systems.
  • A2, human-approved action agent: prepares an action, and a person approves anything consequential.
  • A3, bounded autonomous action: executes predefined actions automatically inside clear rules and escalates exceptions.
  • A4, end-to-end autonomous workflow: plans and executes multi-step work without per-action approval, with people reviewing exceptions and outcomes.
Autonomy tier of 150 enterprise AI agents in production
A1 · Read only
31 deployments
A2 · Human approves
45 deployments
A3 · Bounded autonomy
57 deployments
A4 · End-to-end
17 deployments
Source: The Brief Script, 150 Enterprise AI Agents: What Works in Production (2026), 150 deployments from 119 organisations, evidence cutoff 2 September 2026.

The largest group is A3, and it is also the best evidenced: 91.2% of A3 deployments report a quantified outcome, against 53.3% of A2 deployments. Fully autonomous A4 systems are rare, at 17 of 150. And 118 of the 150 explicitly describe approval steps, exception handling or active human review, which tells you that "autonomous" in production almost always means autonomous inside a fence.

The pattern holds up in independent work. Stanford's Digital Economy Lab studied 51 successful enterprise AI deployments and found that escalation-based designs, where AI handles 80% or more of the work and people take the exceptions, delivered a 71% median productivity gain against 30% for designs where a person approves each action. The authors are careful to add that this partly reflects the kind of task each design is used for, since escalation models are applied to high-volume, recoverable work and approval models to regulated or high-stakes work.

That caveat is the most useful sentence in the study. The deployments that perform best did not win because someone was brave enough to switch human review off. They won because the team matched the level of autonomy to the nature of each task, and that matching is a design skill that can be learned.

Why "how autonomous is the agent?" is the wrong question

Consider a support agent with five tools: look up an order, tag a ticket, send a reply, issue a refund and close an account. Asking how autonomous this agent should be forces one answer onto five very different risks. Tagging a ticket wrongly costs nothing, while closing the wrong account is a serious incident. If you set the whole agent to the level the riskiest action needs, you have built an expensive suggestion engine, and if you set it to the level the safest action allows, you have built a liability.

Researchers at the University of Washington made a similar point in their paper on levels of autonomy for AI agents, arguing that autonomy is a design decision, separate from what the model is capable of. We take that one step further, so that the unit of design is the individual action rather than the agent.

Two questions that decide autonomy for each action

For every action an agent can take, we ask two questions.

How cheaply can a wrong action be undone? Re-tagging a ticket is free. A refund can be clawed back, at some cost in goodwill. An email to a prospect cannot be unsent, though one mediocre email rarely does lasting harm. A payment to a fraudulent bank account may never come back, and neither will a customer whose account was closed by mistake.

Can the system of record confirm the outcome without a person reading anything? This is the question most teams skip, and it is the one that makes autonomy safe. If the agent says it issued a refund, can your code check the ledger and confirm a refund row exists with the right amount? If it says it booked a meeting, is there a calendar event with the right attendees? Where the answer is yes, you can let the agent act and verify every single action automatically. Where the answer is no, any autonomy you grant is trust without evidence, which is exactly the gap we described in the difference between resolved and reported in AI customer care.

Set autonomy per action, not per agent
VERIFIABLE BY SYSTEM?yesnoA2 · HUMAN APPROVESPropose, then approvePay an invoice above thresholdSend a contract or quoteEscalate after evidenceA3–A4 · AUTONOMOUSAct on its ownEnrich a CRM recordReset a passwordRefund under a set limitA1 · READ ONLYRead and recommendChange supplier bank detailsMake a credit decisionAnything regulatedA3 · ACT, THEN SAMPLEAct, audit a sampleRoutine follow-up emailTicket triage and taggingMeeting notes to CRMpromote with evidencehard to undocheap to undoCOST OF A WRONG ACTION
Each action an agent can take is placed by two questions: how expensive a wrong action is to undo, and whether the system of record can verify the outcome automatically. The quadrant sets the autonomy tier; actions move toward the autonomous quadrant only when the evidence supports it.

Put the two answers together and the tier follows. Cheap-to-undo, verifiable actions run autonomously, which is A3 and occasionally A4. Cheap-to-undo actions you cannot verify automatically also run autonomously, but a sample of them gets audited by a person every week. Expensive-to-undo actions that can be verified are prepared by the agent and approved by a person, which is A2, and these are the candidates for promotion. Expensive-to-undo actions that cannot be verified stay read-only, with the agent recommending and a person deciding.

That last quadrant is where regulated decisions live, and the production data reflects it. In The Brief Script's dataset, only 5.3% of payments and treasury deployments ran at A3 or A4, against 71.4% of customer-service deployments. Payments teams have not failed to keep up. They have correctly placed most of their actions in the expensive, hard-to-verify corner.

Autonomy should be earned, with evidence, and it can be lost

The matrix gives you a starting tier, but an action's position is not fixed. Verification can be added, limits can be tightened, and a track record can be built. We run every new action through the same promotion path.

It starts in shadow mode, where the agent decides what it would do and logs it while a person does the real work, so you can compare the two at no risk. It then moves to approval, where the agent prepares the action and a person clicks approve, and every edit or rejection is recorded as a labelled example. It moves to bounded autonomy once the approval data shows the person is rubber-stamping, which we define as a high agreement rate over a meaningful volume measured against the system of record rather than the transcript. Finally, the action stays under monitored autonomy, with automatic verification on every action and human sampling on a fixed schedule.

Demotion has to be just as automatic. If verification failures rise above a threshold, if a new product, policy or regulation changes the context, or if the underlying model is upgraded, the action drops back a stage until the evidence is rebuilt. Anthropic's own research on agent autonomy in practice found that users grant more auto-approval as they gain experience, rising from about 20% of sessions for new users to over 40% for experienced ones, and that is the healthy pattern, with trust following evidence. What you want to avoid is trust that was granted once, at launch, and never re-examined.

How to implement this in a real system

The framework only works if it is enforced in the architecture rather than in the prompt. Telling a model "never issue refunds over $200" is a request. Giving it a refund tool that rejects any amount over $200, and routes the request to an approval queue instead, is a control.

In the agents we build, that translates into four concrete pieces. The first is an action register, a list of every tool the agent can call with its tier, limits, verification check and owner, kept in version control and reviewed like code. The second is permissioned tools, where each tool enforces its own limits and tier, so the model cannot talk its way past them. The third is a verification layer that checks the system of record after every write and flags any mismatch between what the agent said and what actually changed. The fourth is an audit trail and kill switch, which records every action with its inputs and lets an operator demote or suspend any single action without taking the whole agent down.

This is also where most of the cost and timeline of an agent project actually sits. The model is the easy part, and the infrastructure around it decides whether the agent can be trusted with anything that matters. Gartner predicted in June 2025 that over 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value and inadequate risk controls, and in our experience the third reason usually causes the first two.

Three scenarios, and how we would set autonomy in each

These are composites of systems we design, not individual client case studies.

Scenario one: an inbound lead qualification agent for a B2B services firm

The agent receives every enquiry from the website, enriches it with company data, scores it, routes it and starts the conversation. Enrichment and scoring are cheap to redo and verifiable, since the CRM record either has the fields or it does not, so they run fully autonomously from day one. Routing to the right sales owner is also autonomous, with a weekly sample review to catch drift in the rules. The first reply to the prospect cannot be unsent and its quality cannot be verified automatically, so it starts in approval, with a sales rep approving drafts for the first few hundred enquiries. Once the rep is approving the large majority unedited, replies within approved templates are promoted to autonomous, and anything that mentions pricing, discounts or contract terms stays with a person permanently. A system built this way is what we describe on our lead qualification agents page, and it addresses the same problem as PayPal's sales-agent rollout, where thousands of leads were sitting uncalled.

Scenario two: an accounts payable agent for a mid-sized distributor

The agent reads supplier invoices, matches them to purchase orders and goods receipts, and prepares payments. Extraction and three-way matching are verifiable against the ERP and cost nothing to redo, so they run autonomously. Approving payment on a perfectly matched invoice under a set value is verifiable and recoverable, so after a period of approval mode it moves to bounded autonomy, with matched invoices above the threshold staying in approval. A change to a supplier's bank details sits firmly in the read-only corner. It is the classic vector for payment fraud, it is very hard to reverse once money has moved, and no system of record can tell a legitimate change from a well-crafted fake. The agent flags it, gathers context and hands it to a person who confirms the change through a separate channel. This is the same split the production data shows for payments work, where the most consequential actions stay with people.

Scenario three: a customer support agent that can issue refunds

The agent answers order questions, processes returns and issues refunds. Lookups and replies to routine questions run autonomously, with sampled review. Refunds under a set value run autonomously only because the verification layer checks the payments ledger after every refund and confirms the right amount reached the right order, and any mismatch reopens the ticket for a person. Refunds above the limit, and anything involving account closure or a complaint about a person, go to a human queue with the case already summarised. Every conversation also offers a clear route to a person, which is the lesson Klarna drew after its CEO told Fortune in 2025 that cost had been "a too predominant evaluation factor" in its AI support rollout and that customers must know "there will be always a human if you want." The design patterns for this kind of agent are on our customer support agents page.

Where to start

If you are planning an agent now, write the action register before you choose a model or a vendor. List every action the agent would take, answer the two questions for each one honestly, and you will have a design that can go live safely in weeks rather than a pilot that waits months for a risk sign-off that never comes. McKinsey's 2026 State of AI survey found that 40% of large organisations now report scaling AI agents, up from 27% a year earlier, and that the high performers lean on human-in-the-loop design and impact measurement. The teams that get there fastest have not been bolder with autonomy. They are the ones who decided, action by action, where it was safe.

If you would like a second opinion on an agent design or an action register, that is the kind of work our AI agents team does every week, and we explain how agentic systems differ from rules-based automation in our guide to agentic AI versus traditional automation.

Frequently asked questions

Related services

How we work in this space

Continue reading

More articles

Sources & references

← All postsGet a proposal →