ProjekinAja. Agentic AI Stage 3 · Working With Agents Lesson 3.4
● Stage 3 · Lesson 3.4

The Trust Gradient

Trust isn't all-or-nothing. The pros calibrate exactly how much leash to give an agent based on stakes and reversibility — here's how.

⏱ ~14 min read 🎚️ Supervision & control 🛡️ Safety mindset

🎯 By the end you'll understand

Why supervision should match risk, the two axes that set risk (stakes and reversibility), the spectrum from full autonomy to do-it-yourself, the rule of thumb for choosing a level, why you guard the irreversible doors hardest, and how to earn an agent more trust over time without getting burned.

KEY INSIGHTThe one idea to take away

Don't ask "do I trust this agent?" Ask "how much would it cost me if it's wrong here — and can I undo it?"

Trust in an agent is not a personality trait you assign once. It's a setting you dial per task. The skill isn't trusting more or trusting less — it's matching how closely you supervise to how much is at risk. Give a reversible, low-stakes task a long leash. Put a short, hands-on leash on anything you can't take back.

🔑 Hold onto this

Supervision should be proportional to risk. Two questions set the risk: how bad is it if the agent is wrong (stakes), and can you easily undo it (reversibility). High stakes or hard-to-undo → tighten the leash. Low stakes and easy to undo → let it run.

FRAMEWORKThe two axes of risk

People talk about "trusting the AI" as if it's one dial. It isn't. Whether you should hover over an agent or walk away comes down to two independent questions about the action it's about to take — not about the agent's general competence.

📖 Stakes

How bad is the outcome if the agent gets it wrong? This runs from trivial (a clumsy sentence in a draft) through moderate (a wrong number in an internal report) up to catastrophic (wiring money to the wrong account, deleting production data, emailing a client something false).

📖 Reversibility

If it goes wrong, how easily can you put it back? Drafting a document is easily reversible — you just edit or discard it. Posting publicly or merging code is hard to reverse. Sending money, deleting a database, or sending an email to a thousand customers is irreversible — there is no undo button.

These axes are independent, and the combination is what matters. A high-stakes action that's perfectly reversible (say, a large but draft-only financial model) is far safer than a low-stakes action that's irreversible (a tiny, permanent public post). Reversibility is your safety net — when it's gone, every other margin for error goes with it.

It's worth noticing that you can often change an action's place on these axes before you hand it over. Ask the agent to produce a draft instead of publishing, to write to a staging copy instead of the live system, or to stage a transaction for your one-click approval rather than executing it — and a scary, irreversible step becomes a safe, reversible one. Half the craft of supervising agents is quietly redesigning tasks to be more reversible so you can afford to give a longer leash.

This connects straight back to Lesson 1.6, where you learned to judge whether a task is even a good fit for an agent. The trust gradient is the next move: given that you'll use an agent, how much rope do you hand it?

CORE CONCEPTThe supervision spectrum

"How much do I supervise?" isn't yes/no either. There's a spectrum of how much the agent does before it has to pause for you. From loosest to tightest:

✅

Full autonomy — let it run

The agent completes the whole task and reports back. You check the output afterward, not each step. Best for low-stakes, reversible work.

🟡

Checkpoint approvals

It runs freely but pauses at the key moments — the consequential steps — to get your sign-off before continuing. A foreman who calls you before pouring concrete.

🔶

Step-by-step confirmation

It proposes one action at a time and waits for "go" before each. Slow, but you see everything. Good while you're still learning what it does.

🔴

Do it yourself

The action is risky enough that you take the wheel for that step. The agent can draft and advise, but a human performs the irreversible act.

💡 The leash metaphor

Think of it as leash length. Full autonomy is off-leash in a fenced yard. Checkpoints are a long leash you can yank. Step-by-step is a short leash at heel. "Do it yourself" is carrying the dog across the road. The traffic — the risk — decides the leash, not your affection for the dog.

PRACTICALThe rule of thumb

You don't need a spreadsheet for every task. Most decisions collapse to one line:

Low stakes and reversible → let it run. High stakes or irreversible → put a human in the loop before the costly step.

Notice the logic. To earn a long leash, a task must clear both bars — small consequences and an easy undo. But it only takes one red flag to demand supervision. That asymmetry is deliberate: it's cheap to over-supervise a safe task occasionally, and expensive to under-supervise a dangerous one even once.

▸ Human-in-the-loop, precisely

Human-in-the-loop doesn't mean watching everything. It means inserting a required human approval at the specific point where the irreversible or high-stakes action happens — and only there. The agent can do all the reversible prep autonomously; it pauses right before it pushes the button that can't be un-pushed.

▸ Human-on-the-loop, by contrast

Human-on-the-loop is the looser stance at the far end of the spectrum. The agent runs largely autonomously, without pausing for per-action approval; a person monitors the run and can step in, intervene, or hit the stop button if it goes off the rails. It's the "full autonomy — you check the output / keep an eye on it" mode, not the "approve every consequential step" one. In-the-loop gates each costly action; on-the-loop watches and can interrupt.

SEE ITThe Trust Calibrator

Now stand at that door yourself. You supervise the back office of a small online shop for one morning. The agent, a worker at its bench, brings you eight actions one at a time, from reformatting your notes to wiring funds. For each one you set the leash: let it run, ask me first, or I'll do it. One of the eight is quietly wrong, and nothing tells you which. End the morning with no lasting damage and as little of your own time as you can, then play the next morning.

Game · A morning at the outbox door

Asking first costs you 30 seconds. Doing it yourself costs 5 minutes. A mistake that stays in the office costs the time to put it right. One that leaves by the door cannot be taken back.

The back office The back office of a small online shop, seen from above and to one side. The agent, a small robot worker, waits at a line on the floor with an action card in its hands. You stand beside the red outbox door in the far wall. Along the back wall stand a drafts tray and the cabinet that runs the live shop.
Action 1 of 8Reformat my notes
Time · morning 10:00Lasting damage 0
Drag to look around

Morning 1. The worker is at the line with the first action: reformat my notes. Set the leash.

This morning

Notice what happened: choosing between the three leashes was never the hard part. What decided each one was where the action would end up. Work that stays in the office, like the notes and the report, can be put back, so a mistake there costs a minute. Work that leaves by the door, like the comment, the email and the transfer, stays wrong. Asking first on everything is safe and spends your morning. Letting everything run is fast until the one you cannot take back is the wrong one. So the leash is set by two questions about the action, not by how well the worker did on the last one: how bad is it if this is wrong (stakes), and can I undo it (reversibility).

COMPARISONThe full grid, with examples

Here's the same mapping the calibrator uses, laid out so you can see the shape. Read down the irreversible column: the leash only gets shorter.

Stakes ↓ / Reversibility →Easily reversibleHard to reverseIrreversible
Low ✅ Let it run
reformat my notes
✅ Let it run
rename local files
🟡 Checkpoint
post a minor public comment
Medium ✅ Let it run
draft an internal report
🟡 Checkpoint
merge a code change
🔴 Human approval
email a customer
High 🟡 Checkpoint
build a big budget model (draft)
🔴 Human approval
change production config
🔴 Human does it
wire funds · delete prod DB

The bottom-right cell is the one to burn into memory. High stakes plus irreversible is the danger zone — that's where a single confident mistake becomes a disaster you can't walk back. Agents fail in confident, plausible-looking ways (you saw the failure modes in Lesson 2.9), so the cost of being wrong there is the whole point.

▸ The asymmetry that drives everything

A reversible mistake is a learning cost — you notice, you undo, you tweak the brief, you move on. An irreversible mistake can be a disaster — there's nothing to undo. Because the downside is wildly lopsided, you don't optimize for speed at the irreversible doors. You guard them. Make the costly action require a human key.

CORE CONCEPT"Trust but verify" — even when you let it run

Letting an agent run is not the same as ignoring it. "Let it run" governs the steps — you don't approve each one. It says nothing about the result. Even on a long leash, you still verify the output before you rely on it.

Why? Because the dangerous failure isn't the agent stopping — it's the agent finishing and being confidently wrong. It will hand you a clean-looking report with a fabricated figure, or "done!" on a task it half-did. Trust the process to run; verify the result is actually right.

How much verification depends — again — on stakes and reversibility. A reformatted note barely needs a glance; the undo is trivial if it's off. A figure you're about to paste into a board deck earns a real check against the source. The point isn't to re-do the agent's work by hand — that would defeat the purpose — it's to spot-check the parts where being wrong would actually hurt. Light leash, but eyes open at the result.

✗ The classic trap: verifying the words, not the action

An agent says "✅ I've sent the invoices and updated the spreadsheet." It's easy to read that confident summary and check the box in your head. But the summary is just more words from the same model that did the work. Verify the world changed the way it claims — open the spreadsheet, check the outbox — not just that the agent said it did. We go deep on how to verify outputs well in Lesson 3.6.

PRACTICALEarning trust over time

The trust gradient isn't static. You loosen the leash as the agent proves itself — but in a specific, disciplined way.

1

Start tight

New task type? Begin at step-by-step or checkpoints. Watch how it behaves before you give it room.

2

Loosen per task type, not in general

It's earned a long leash for summarizing meetings. That says nothing about whether it can be trusted to touch your calendar. Trust is task-shaped.

3

Never loosen the irreversible doors

Reliability lets you stop watching reversible steps. It never makes "wire the money autonomously" a good idea. The danger-zone cell keeps its human key permanently.

💡 Trust is calibrated, not granted

"It worked five times" raises your estimate of reliability — it doesn't change the stakes or reversibility of the next action. When a task is irreversible and high-stakes, a strong track record is nice, but the leash stays short because the cost of the rare miss hasn't changed at all.

WEAKNESSCommon mistakes to avoid

✗ "It worked once, so I trust it fully."

One success — or even fifty — is evidence of reliability, not a license to autonomy on irreversible actions. The leash length is set by the cost of being wrong, which a winning streak doesn't lower. Loosen reversible steps; keep guarding the irreversible ones.

✗ "I supervise everything equally."

Approving every harmless step (renaming a file, fixing a typo) is exhausting and trains you to rubber-stamp — so you're tired and numb exactly when the dangerous step finally comes. Spend your attention where the risk is. Let safe, reversible work run.

✗ "It said it did it, so it did."

Verifying the agent's words instead of the action is the most common failure of all. The summary is generated by the same fallible model. Check the actual result — the sent email, the changed file, the moved money — not the cheerful report about it.

KEY INSIGHTWhere this connects in your course

  • Task fit (1.6) — before you set a leash, you decided the task was worth handing to an agent at all. Trust gradient is the next dial.
  • Failure modes (2.9) — agents fail confidently. That's exactly why irreversible, high-stakes steps need a human gate.
  • Verifying outputs (3.6) — "trust but verify" in full: how to actually check the result, not the agent's summary of it.
  • Delegation (3.5, next) — once you've set the leash, how do you hand off the task itself well?
  • Cost, Speed & When NOT to Use an Agent (3.11) — when staying in the loop (and the supervision cost it carries) tips the balance toward a simpler tool, without killing the agent's usefulness.
  • Least privilege — Safety, Security & Cost Control (4.10) — the builder's version of guarding irreversible doors: don't even give the agent the keys to actions it shouldn't take alone.

The trust gradient is the mindset; least privilege (4.10) is how you enforce it in the wiring. Supervision is what you do; permissions are what you allow. The best setups use both.

GLOSSARYKey terms introduced

Trust gradient
The idea that supervision should be dialed per task to match its risk, rather than trusting an agent fully or not at all.
Stakes
How bad the outcome is if the agent gets an action wrong — from trivial to catastrophic.
Reversibility
How easily an action can be undone if it goes wrong — easily reversible, hard, or irreversible.
Human-in-the-loop
Requiring a human's approval at the specific point where a high-stakes or irreversible action would occur — the agent pauses for sign-off before each consequential step.
Human-on-the-loop
The agent runs largely autonomously while a person monitors and can intervene or stop it — no per-action approval. The looser, "keep an eye on it" end of the supervision spectrum.
Checkpoint / approval
A pause where the agent gets your sign-off on a key step before continuing, while running the rest freely.
Autonomy
How much the agent does on its own before needing you; full autonomy means it completes the task and reports back.
Trust but verify
Letting an agent run the steps while still independently checking that its final output is actually correct.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1What are the two axes that decide how closely to supervise an agent?›

Stakes (how bad it is if the action is wrong) and reversibility (how easily you can undo it). Together they set the risk, and supervision should be proportional to that risk.

2State the rule of thumb — and why it's asymmetric.›

Low stakes and reversible → let it run; high stakes or irreversible → human-in-the-loop before the costly step. It's asymmetric because a long leash requires clearing both bars, but a single red flag is enough to demand supervision — over-supervising a safe task is cheap, under-supervising a dangerous one is not.

3Why does "trust but verify" still apply when you let an agent run autonomously?›

"Let it run" only means you don't approve each step — it says nothing about the result. Agents finish and are sometimes confidently wrong, so you verify the actual output (and that the world really changed as claimed), not just the agent's cheerful summary.

4An agent has summarized your meetings flawlessly for weeks. Should it now be allowed to delete files in production on its own?›

No. Trust is task-shaped — reliability at summarizing says nothing about a different, irreversible action. The leash on high-stakes, irreversible steps stays short permanently, because a track record lowers the odds of a miss but not its cost. Guard the irreversible doors regardless.

Nice — you can now set the right leash. Next: how to hand off the task itself →