Lesson 1.3: Levels of autonomy and when not to use an agent
Learn how much freedom to give an agent, how to compare designs by expected value per task, and when a simpler system or a person is the better choice.
By the end of this lesson you will be able to describe five levels of agent autonomy, choose a level for a given task, compare designs by their expected value per task, find the success rate an agent must reach before it is worth using, and recognise the situations in which an agent is the wrong tool. You will work through a refund-handling example in which a fully automatic agent is worth ₹72 per task, the same agent with a cheap human review is worth ₹76, and a weaker workflow loses ₹8, and you will find that the review lowers the success rate needed to break even from 72.9 per cent to 47.8 per cent. You should have read Lessons 1.1 and 1.2, which define agents and explain how errors compound in a loop. The mathematics is a weighted average and one rearranged equation.
The first two lessons showed what an agent is and how its loop works. A more important question for anyone who builds or buys one is whether to use an agent at all, and if so, how much freedom to give it. Teams get this wrong in both directions. Some build elaborate autonomous systems for jobs that a spreadsheet formula would do. Others keep a person on every step of work that a well-tested agent could safely do alone, and then wonder why the project saves no time. This lesson gives you a way to decide, with numbers.
Five levels of autonomy
Autonomy is not an on or off switch. It is a dial, and it is useful to name the positions on it. The levels below are a practical scale, not an industry standard, and different writers draw the lines differently.
Level · Name · Who acts · The human's role · Example0 · No AI · A person · Does the work · A clerk reads each refund request and decides
1 · Suggest · A person · Reads the suggestion, then acts · The AI drafts a reply, the clerk edits and sends it
2 · Act with approval · The agent proposes actions, a person approves each · Approves or rejects every action · The agent prepares a refund, the clerk clicks approve
3 · Act with review · The agent acts, a person checks afterwards · Reviews a sample, or only the cases the agent flags · The agent refunds small amounts itself, the clerk reviews 10 per cent and every flagged case
4 · Act within limits · The agent acts alone inside strict limits · Sets the limits, reads reports, handles escalations · The agent handles all refunds under ₹2,000 and escalates anything outside its rules
A fifth level, an agent that sets its own goals and acts without any limits, appears in discussion, but almost no business should want it, and nothing in this course asks you to build it. The levels that matter in practice are 1 to 4, and the skill is picking the right one for each task, then moving up the scale as evidence builds.
Two ideas help in choosing.
Autonomy is earned, not granted. A new agent should start at a low level, where a person sees everything, and move up only when its record justifies it. A team that starts an agent at level 2 collects data on how often people approve its proposals. If people approve 97 per cent of them unchanged for three months, that is strong evidence to move the routine ones to level 3. If they reject 30 per cent, the agent is not ready.
Autonomy can differ by action. An agent need not sit at a single level. The same support agent might look up information freely (level 4), draft replies for a person to send (level 1) and issue refunds only up to a small limit with review (level 3). The more harmful or irreversible an action, the lower the level should be. Reading a record is harmless and reversible. Sending a message to a customer cannot be undone. Moving money is serious. Deleting data may be permanent.
Deciding with expected value
Instead of choosing a level by feel, you can compare designs with a short calculation. It requires four estimates for a task.
V, the value of a correctly completed task. For a time-saving agent this is the cost of the work it replaces.
C, the cost of running the agent on one task, including model calls and any tools.
p, the probability that the agent completes the task correctly without a mistake that matters.
F, the cost of a mistake that goes undetected: a wrong refund, an angry customer, a compliance problem, or the work to put it right.
The expected value of one task is
EV = p × V − C − (1 − p) × F
In words: the chance of success times the value of success, less the cost of running, less the chance of failure times the cost of failure.
Take the refund example. A correct automatic refund decision saves ₹120 of staff time (V). Running the agent costs about ₹6 per task in model calls and system fees (C). The agent gets it right 90 per cent of the time (p). A wrong refund costs ₹300 to find and reverse, plus goodwill (F). Then
EV = 0.90 × 120 − 6 − 0.10 × 300 = 108 − 6 − 30 = ₹72 per task.
That is a positive number, so the agent is worth running. But the figure is only as good as its inputs. Replace the 90 per cent with 70 per cent and the answer is 0.70 × 120 − 6 − 0.30 × 300 = 84 − 6 − 90 = −₹12. The agent now loses money on every task.
Predict first: the agent is right 90 per cent of the time and the cost of an undetected mistake is ₹300. Someone suggests adding a human reviewer who costs ₹20 per task and catches 80 per cent of the agent's mistakes. Will expected value per task go up, go down or stay about the same? Decide before reading on.
It goes up, to ₹76. With review, 80 per cent of failures are caught before they cause harm, so only 0.10 × 0.20 = 2 per cent of tasks fail undetected. The calculation is
EV = 0.90 × 120 − 6 − 20 − 0.02 × 300 = 108 − 6 − 20 − 6 = ₹76 per task.
The reviewer costs ₹20 but removes ₹24 of expected harm (0.10 × 300 = 30 down to 6), a net gain of ₹4 per task. The review barely changes the money in this example, but it changes the risk. The worst outcomes become rarer, and, as the next section shows, it widens the range of situations in which the agent is worth using at all.
How good must the agent be?
The same equation answers a question teams ask early: what success rate does the agent need before it pays? Set EV to zero and solve for p:
p = (C + F) ÷ (V + F), for a fully automatic agent.
With C = 6, F = 300 and V = 120, the break-even success rate is 306 ÷ 420 = 72.9 per cent. Below that the agent loses money.
Notice how much the cost of failure matters. If an undetected mistake cost only ₹30, the break-even rate would be 36 ÷ 150 = 24 per cent, and an unreliable agent would still be worth running. If it cost ₹3,000, the break-even rate would be 3,006 ÷ 3,120 = 96.3 per cent, and only a nearly perfect agent would do.
With a review that catches a share k of the mistakes, costing R per task, the general formula is
p = (C + R + (1 − k) × F) ÷ (V + (1 − k) × F).
Using R = 20 and k = 0.8, the break-even rate is (6 + 20 + 60) ÷ (120 + 60) = 86 ÷ 180 = 47.8 per cent. The review lowers the success rate the agent needs from 72.9 to 47.8 per cent. That is the real value of human oversight in an early agent: it makes it safe to use a system that is still imperfect while it learns, and it generates data for improving it.
When not to use an agent
The expected-value method gives numbers. A set of warning signs gives a quicker first filter. An agent is probably the wrong choice when several of the following are true.
Warning sign · Why it matters · Better optionThe steps are known and always the same · Nothing needs deciding · A workflow, or ordinary code
A mistake is costly or cannot be undone · High F makes the break-even rate close to 100 per cent · A person, or a low autonomy level with approval
You need exactly the same output each time · Models vary between runs · Code with fixed rules
The decision must be explained in detail to a regulator or customer · An agent's path can be hard to justify · A rule-based model with documented logic
Speed matters in milliseconds · Each step takes time, and an agent takes many · A single fast call or code
The task happens a few times a month · Building and testing costs more than the time saved · Do it by hand
There is no way to check whether the result is right · You cannot measure p or catch errors · Build the check first
The data or tools the agent would need are missing or poor · An agent cannot fix broken systems · Fix the data first
A simpler design already works well enough · Complexity has a running cost · Keep the simple design
Two of these deserve a closer look. The first is checkability. An agent is easiest to use well where its work can be verified: a calculation can be recomputed, a code change can be tested, a record can be compared with a source. It is hardest where nobody can quickly say whether the answer is right, such as an open-ended recommendation. If you cannot check, you cannot estimate p, you cannot catch failures, and the whole expected-value calculation rests on faith. The second is reversibility. An agent that drafts a reply is easy to correct. An agent that sends it is not. When you must choose between the two, ask what the cost is if the agent is wrong once, in front of the worst customer.
There is also a softer test, which is to imagine hiring a person for the job. Would you give a new employee the ability to do this on day one, with no supervision? If not, do not give it to a new agent. Start where a new employee would start, with supervision, and widen the permissions as they prove themselves.
Matching autonomy to the task
Putting the ideas together gives a simple rule of thumb for each action an agent might take.
1. Rate the harm of a mistake: low, medium or high, in terms of money, customers and law.
2. Rate the reversibility: easy to undo, hard to undo, or impossible.
3. Estimate the success rate from a test set, as Module 7 will teach, and compare it with the break-even rate.
4. Choose the level: low harm, easily undone and above break-even can go to level 4. Medium harm or hard to undo points to level 3 with review. High harm or impossible to undo means level 1 or 2 with approval.
5. Plan the path upward: write what evidence would justify a higher level, such as 500 reviewed cases with fewer than 2 in 100 changed.
Here is the result for a support agent.
Action · Harm · Reversible? · LevelLook up an order · Low · Yes · 4: act freely
Draft a reply to a customer · Low · Yes, before sending · 1: suggest
Send a routine reply · Medium · No · 3: act with review
Refund up to ₹500 · Medium · Partly · 3: act with review
Refund above ₹500 · High · Partly · 2: act with approval
Close an account · High · No · 2: act with approval, or a person only
This table is also a design document. It tells the engineers which actions need an approval step built in, tells the reviewers what to expect, and tells managers how the system will change as it earns trust.
A decision helper in code
The calculation is simple enough to keep in a short function so the team can try different assumptions in a meeting.
python
def agentvalue(p, v, c, f, reviewcost=0.0, catch=0.0):
"""Expected value per task: success, less run cost, review cost and undetected failures."""
undetected = (1 - p) (1 - catch)
return p v - c - reviewcost - undetected f
def breakeven(v, c, f, reviewcost=0.0, catch=0.0):
"""The success rate at which expected value is zero."""
residual = (1 - catch) f
return (c + reviewcost + residual) / (v + residual)
print(round(agentvalue(0.90, 120, 6, 300), 1)) # fully automatic
print(round(agentvalue(0.90, 120, 6, 300, 20, 0.80), 1)) # with review
print(round(agentvalue(0.70, 120, 2, 300), 1)) # weaker workflow
print(round(breakeven(120, 6, 300), 3), round(breakeven(120, 6, 300, 20, 0.80), 3))
how the break-even rate moves with the cost of a mistake
for f in (30, 300, 3000):
print(f, round(breakeven(120, 6, f), 3))
Run it and change the numbers. The most useful habit is to ask which estimate you are least sure of, and then to go and measure it.
Common mistakes
Choosing the level by enthusiasm. Estimate harm, reversibility and success rate, then decide.
Starting at full autonomy. Begin with approval or review, and move up as evidence builds.
One level for the whole agent. Set the level action by action. Reading is not the same as paying.
Ignoring the cost of mistakes. A modest error rate is acceptable when mistakes are cheap, and ruinous when they are not.
Not measuring the success rate. Without a test set and a checkable outcome, p is a guess.
Reviewing everything forever. Review that never ends, or an approval nobody reads, adds cost and no safety. Sample, and use data to reduce it.
Using an agent because it is fashionable. If the steps are fixed, a workflow is cheaper and safer.
Forgetting the exit. Every level needs a way for a person to take over.
Key takeaways
Autonomy runs from no AI, through suggest, act with approval and act with review, to act within limits. Choose a level for each action, and earn higher levels with evidence.
Compare designs by expected value per task: EV = p × V − C − (1 − p) × F, adding review cost and a catch rate when a person checks the work.
The break-even success rate is (C + F) ÷ (V + F). In the example it is 72.9 per cent, and a review that catches 80 per cent of mistakes lowers it to 47.8 per cent.
The cost of an undetected mistake drives everything. At ₹30 the break-even rate is 24 per cent, at ₹3,000 it is 96.3 per cent.
Avoid agents when the steps are fixed, mistakes are costly or irreversible, results must be identical, the task is rare or results cannot be checked.
Write the path upward: what evidence would justify more freedom.
Check yourself
1. An agent succeeds 85 per cent of the time. A correct task is worth ₹200, running costs ₹10, and an undetected mistake costs ₹400. With no review, what is the expected value per task?
0.85 × 200 − 10 − 0.15 × 400 = 170 − 10 − 60 = ₹100.
2. What is the break-even success rate in question 1?
(10 + 400) ÷ (200 + 400) = 410 ÷ 600 = 68.3 per cent.
3. In the refund example, why does adding a review that catches 80 per cent of mistakes lower the break-even rate?
Only 20 per cent of mistakes are left to cause harm, so the effective cost of a mistake falls. The agent no longer has to be as accurate to pay.
4. Name two situations where an agent is probably the wrong tool.
For example, when the steps are always the same, so a workflow would do, or when a mistake is costly and cannot be undone.
5. An agent can read a customer's record, send emails and close accounts. Which levels would you set?
Reading: level 4. Sending routine emails: level 3, with review. Closing accounts: level 2 with approval, or a person only.
Try this
Set aside forty-five minutes.
1. Choose a task you might hand to an agent. Write the actions it would take.
2. For each action, rate the harm of a mistake and whether it can be undone, and set a level from 1 to 4.
3. Estimate V, C and F for the main task in rupees or your own currency. Say how you obtained each number.
4. Use the expected-value simulator to find the break-even success rate with no review, and with a review you think is realistic.
5. Estimate your best guess for p. Is it above break-even? Which input are you least sure about?
6. Write what evidence, such as the number of reviewed cases and an acceptable rate of changes, would move the task up one level.
7. List the warning signs from the table that apply. If three or more do, write what you would build instead.
A good result is a table of actions with levels, a break-even success rate, an honest estimate of the real one and a plan for earning more autonomy. The next lesson takes the first step toward building: the four parts every agent is made of, and how they fit together.
Tags: Agentic AI Agent autonomy Human in the loop Decision making AI strategy