Lesson 6 · Module 4: Agentic Systems: Manager and Worker Agents
Human in the loop: approvals, limits and logs for safe autonomy
Video coming soon
Learn it with your tutor on the live board
Key points from the video
The night the agent got generous
- A support agent runs overnight for a small online shop
- One complaint: a cracked jar
- By morning: 40 refunds sent, not 1
- The agent did what it was allowed to do
What you will learn
- Decide which agent actions need a human approval
- Set hard limits that agents cannot cross
- Keep a log so every action can be traced and undone
The autonomy dial
- Level 1, Suggest: the agent drafts, you do it
- Level 2, Approve: the agent acts after your yes
- Level 3, Auto: the agent acts and logs it
- Each action gets its own setting
Which actions need approval?
- Money above your limit: always ask
- Can it be undone easily? If not, ask
- Cheap and reversible: auto, but log it
layout: side
direction: down
tree:
Agent action:
"[moves money] Above the limit?":
"[yes] Ask owner":
"[no] Auto, logged":
"[no money] Reversible?":
"[yes] Auto + log":
"[no] Owner approves":
steps:
- at: "start with any action"
grow: Agent action
- at: "ask a second question"
grow: "Reversible?"
- at: "moving a booking"
path: "Auto + log" The approval step in a workflow
- The agent prepares, then pauses
- The owner sees one clear request
- Yes: the action runs. No: back with a reason
Limits the agent cannot cross
- Amount cap: refunds above 100 dollars wait
- Count cap: at most 5 refunds per day
- Scope cap: only this shop's customers
- Limits live in the workflow, not the prompt
Logs: a diary for your agents
- One row per action, every time
- When, which agent, what, how much, decision
- Lets you find mistakes and undo them
cells:
A1: Time
B1: Agent
C1: Action
D1: Amount
E1: Decision
A2: "09:02"
B2: Support
C2: Refund
D2: 40
E2: Auto
A3: "09:15"
B3: Billing
C3: Invoice
D3: 900
E3: Rejected
A4: "10:30"
B4: Support
C4: Refund
D4: 250
E4: Approved
A5: "11:05"
B5: Booking
C5: Reschedule
D5: 0
E5: Auto
C6: Refunded
format: {D: currency}
steps:
- at: "last column"
select: E2:E5
- at: "total refunded today"
type: {D6: "=D2+D4"}
highlight: D6 The whole gate at a glance
- Refund 40, limit 100: auto
- Refund 250, no answer yet: waiting
- Refund 250, owner says yes: approved
- Invoice 900, owner says no: rejected
Real example: the booking agent
- Move Friday to Saturday: reversible, Auto + log
- Cancel deposit: above the limit, owner approves
- Owner taps yes between clients
Common mistake: approval fatigue
- Asking approval for everything
- The owner clicks "yes" without reading
- Approvals become a rubber stamp
- Fix: approve only risky actions, auto the rest
Recap
- Set an autonomy level for each action, not for the agent
- Put hard limits in the workflow, never only in the prompt
- Log every action: when, who, what, how much, decision
Your exercise
- List 8 actions your agent team could take
- Give each one a level: Suggest, Approve or Auto
- Set one amount limit and one daily count limit
- Build a log sheet with five columns
Transcript
The night the agent got generous. Picture this. You run a small online shop selling handmade candles. Last night your support agent answered customer messages while you slept. One customer complained about a cracked jar, and the agent, trying to be helpful, decided the whole batch was faulty. It refunded forty orders. Now you're sitting at the laptop at dawn, looking at a stack of refunds you never approved. The agent wasn't broken. It did exactly what it was allowed to do, and nobody had drawn a line. This lesson is about drawing that line, so your agent team can work on its own without any surprises.
What you will learn. By the end of this lesson you'll have three tools for safe autonomy. Autonomy just means the agent acts on its own, without asking first. The first tool is approvals: you'll learn to sort actions into ones the agent does alone and ones that wait for you. The second is limits: hard caps, like a maximum refund amount, that the agent can't cross even when it's sure it's right. The third is logs, a written record of every action, so you can see what happened and fix it. Together these are called human in the loop.
The autonomy dial. Think of autonomy as a dial, like the volume on a radio. At Suggest, the agent only drafts: it writes a reply to a customer, and you press send yourself. At Approve, the agent prepares the action and waits for your yes. At Auto, it acts on its own and writes down what it did. Here's the key idea. You don't set one dial for the whole agent. You set one for each kind of action. Answering "what are your opening hours" can sit at Auto, while sending an invoice might sit at Approve.
Which actions need approval?. Here's a simple rule. Start with any action and ask: does it move money? Refunds, discounts and payments above your limit always go to the owner. Small amounts under the limit run on Auto and get logged. If no money moves, ask a second question: can it be undone easily? Moving a booking from Tuesday to Wednesday can be undone with one message, so it runs on Auto and gets logged. Deleting a customer record, or emailing your whole mailing list, can't be taken back, so the owner approves. Write these two questions on a sticky note, and you've got your first safety policy.
The approval step in a workflow. Let's walk through a worked example. A client books a three-month coaching package, and your billing agent drafts a nine hundred dollar invoice. Instead of sending it, the workflow pauses and puts the draft in an approval queue, a list of requests waiting for you. You get one clear message: client name, amount, and what's being billed. If you say yes, the invoice goes out. If you say no, it goes back to the agent with your note, for example "apply the ten percent returning client discount." In no-code tools, this is usually a wait step or a form.
Limits the agent cannot cross. Approvals catch big decisions. Limits catch runaway behaviour. A limit is a hard rule: refunds above a hundred dollars wait for you, no more than five refunds a day, and the agent only touches your own customer list. Think of the gate across the path: the agent can push as hard as it wants, and the cart still stops. Put limits in the workflow itself, as a filter or condition step. Never rely only on the prompt saying "please don't refund too much." A language model can misread a prompt. A condition step can't.
Logs: a diary for your agents. A log is a diary for your agents. Every action becomes one row: the time, which agent acted, what it did, the amount, and who decided. Here's a morning across your agent team. Look at the last column, which shows who decided: the agent alone, or you. Now you can answer real questions in seconds. What's the total refunded today? Two hundred ninety dollars. And if that overnight disaster ever happens again, the log tells you exactly which forty orders to fix. A simple Google Sheet or Airtable table works perfectly as a log.
The whole gate at a glance. Here's the whole gate as one flow. Every workflow tool does exactly this, with no code needed. Each action has a limit. If the amount is at or under the limit, it runs on auto. If it's over and nobody has answered yet, it waits for the owner. Then it becomes approved or rejected. And whatever happens, one row goes into the log. Look at the four examples: the forty dollar refund ran alone, the two hundred fifty dollar one paused until you said yes, and the nine hundred dollar invoice was rejected. Four actions, four rows in the log.
Real example: the booking agent. Let's see all three tools in one small salon. A customer texts: "Can I move my Friday haircut to Saturday?" The booking agent checks the calendar, finds a free slot, and moves it. That's reversible, so it runs on Auto and writes a log row. Then she adds: "And cancel my deposit, please." Money is moving now, and the deposit is above the limit the owner set, so the agent pauses and sends the owner one message with the details. The owner taps approve on her phone between two clients. The customer gets a fast answer, and the owner made the only decision that really needed her.
Common mistake: approval fatigue. The most common mistake is the opposite of the opening story: setting everything to Approve. It feels safe. But after the fiftieth "may I reply to this message?" the owner starts pressing the button without reading. That's called approval fatigue, and it's worse than no approvals at all, because you think you're in control when you aren't. The fix is to be picky. Ask for approval only where money above your limit moves or a mistake can't be undone. Let the safe, reversible actions run on Auto, and trust your log to catch the rest.
Recap. Let's recap. First, autonomy is a dial you set per action: suggest, approve, or auto, with money above your limit and anything you can't undo going to a human. Second, limits are hard rules built into the workflow, like a refund cap or a daily count, so the agent physically can't cross them. Third, every action leaves a row in a log, so you can trace mistakes and undo them. With these three in place, your owner can drink her coffee while the agents work, knowing nothing big happens without her.
Your exercise. Now it's your turn. Pick a small business you know, maybe your own or a client's. Write a list of eight actions an agent team could take there, such as replying to a message, booking a call, sending an invoice or issuing a refund. Give each one a level: Suggest, Approve, or Auto, using the two questions about money and undoing. Then set one amount limit and one daily count limit. Finally, create a log sheet with five columns: time, agent, action, amount and decision. You'll use it in the project lesson next.
Explore the animations
The animations from the video, exact and live: play them, pause, drag the slider or jump to a step at your own pace.
Loading the animation...
Loading the animation...
Lesson summary
- Video watched
- Set an autonomy level for each action, not for the agent
- Put hard limits in the workflow, never only in the prompt
- Log every action: when, who, what, how much, decision