Lesson 4 - Teaching a Loop to Ask

Welcome to Teaching a Loop to Ask#

So far the exits you’ve designed end the loop: success, budget, error, give-up. This lesson adds a different kind of exit — one that pauses the loop so it can ask you a question, then continues with your answer. This is escalation, and it’s one of the most valuable things you can build into a hands-off loop. A loop that knows when to stop and ask, rather than confidently guessing, is the difference between an agent you can trust with real work and one that will occasionally do something irreversible and wrong at full speed.

By the end of this lesson, you will be able to:

• Explain what escalation is and why it beats guessing
• Recognize the three triggers that should make a loop ask
• Write escalation rules into a loop’s brief
• Reframe “asking” as the loop being honest, not failing

Let’s start with why a loop should ever ask.

Asking Beats Guessing#

An autonomous loop is always making decisions — what to do next, how to interpret an ambiguous instruction, whether an action is safe. Most of those it should just make; that’s the point of autonomy. But some decisions are ones it shouldn’t make alone, and for those, the right move isn’t a confident guess — it’s a question. Escalation is the loop recognizing “this is above my pay grade” and pausing to ask you, instead of barreling ahead.

The reframe that makes this click: a loop that asks is being honest about its limits, not failing. We tend to want AI to “just handle it,” so a loop that stops to ask can feel like it fell short. It’s the opposite. A loop that confidently deletes the wrong folder, or emails a customer something wrong, because it didn’t ask, is the real failure — it was certain when it should have been uncertain. A well-designed loop is calibrated: confident on the routine, and quick to ask on the risky, the stuck, and the genuinely unclear.

The Three Triggers#

There are three situations where a loop should stop and ask. Build these into how you brief any hands-off loop.

• An irreversible or high-risk action. Anything hard or impossible to undo, or with real consequences: deleting files, sending an email, spending money, publishing something public, overwriting data. Before an action like this, a hands-off loop should pause and confirm — the cost of asking is a moment of your time; the cost of guessing wrong is a deleted folder or a mistaken message to a customer. This is the highest-value trigger, because it’s where a wrong guess does lasting damage.
• Repeated failure. When the loop has tried and failed several times — hit the give-up threshold from Lesson 1 — it should stop and ask rather than keep flailing. Repeated failure usually means something the loop can’t see is wrong: a bad assumption, a missing piece of context, a task that’s not what it seemed. Another ten rounds won’t fix that; a question to you might.
• Genuine ambiguity. When the loop hits a real fork it can’t resolve from what it knows — not a small guessable detail, but a decision that changes the outcome and could reasonably go two ways — it should ask which you meant. Guessing on genuine ambiguity is how a loop confidently produces something that’s polished, complete, and not at all what you wanted.

Write Escalation Into the Brief#

Escalation doesn’t happen by default — you design it in, the same way you design the other exits. In the loop’s brief or its project memory (Module 5), state the escalation rules explicitly:

• “Before deleting, sending, or overwriting anything, stop and ask me first.”
• “If you can’t satisfy the check after three rounds, stop and tell me what’s blocking you.”
• “If it’s unclear whether a file belongs in category A or B in a way that matters, ask rather than guessing.”

These turn escalation from a hope into a designed behavior. Notice how they pair with permissions from Module 5: an ask permission on risky actions enforces the pause (the tool won’t let the action through without your yes), while the brief’s escalation instructions guide the loop to ask a good question. As always, use enforcement for the hard safety boundaries and guidance for the rest — a permission ask on “delete” is your real protection; the briefed “ask me before deleting” makes the loop ask well.

A Harborlight Example#

The owner sets up an agent to clear out the shared folder, including deleting obvious junk. Without escalation, “delete obvious junk” is a loaded instruction — the agent’s idea of junk might include a scanned receipt that looked like clutter. So they build in escalation on all three triggers. Irreversible: a permission ask on delete, plus a brief instruction “before deleting anything, list what you’d delete and ask me to confirm.” Repeated failure: “if you can’t classify a file after a couple of tries, don’t guess — set it aside and ask.” Ambiguity: “if a file could be either a personal note or a business record, ask which.”

On the run, the agent sorts confidently through the clear cases, then pauses three times: once to confirm a batch of genuine junk (the owner approves, minus one file that was actually a receipt), once on a file it couldn’t classify, and once on an ambiguous document. Each pause is a ten-second question. The result: the junk is gone, nothing important was deleted, and the two tricky files went where the owner actually wanted. A loop without escalation would have guessed on all three — and probably deleted the receipt with full confidence.

Practice Exercises#

Exercise 1: Should it ask?#

For each, should the loop proceed or escalate: (a) renaming a file to match its date; (b) permanently deleting a folder of “old” files; (c) it’s failed to parse the same file five times; (d) choosing between two synonyms in a sentence?

Exercise 2: Write the escalation rule#

Write an escalation instruction for a loop that sends follow-up emails to customers.

Exercise 3: Guidance or enforcement for “don’t delete”?#

You want a loop to ask before deleting. Should you rely on a briefed instruction, a permission rule, or both?

Summary#

Escalation is a designed exit that pauses a loop to ask you a question, then continues with your answer — and the key reframe is that a loop that asks is being honest about its limits, not failing; the real failure is the loop that guesses confidently when it should have been uncertain. There are three triggers to build in: an irreversible or high-risk action (delete, send, spend, publish — the highest-value trigger, because a wrong guess does lasting damage), repeated failure (hitting the give-up threshold, where more rounds won’t help but a question might), and genuine ambiguity (a real fork that changes the outcome, where guessing produces confident-but-wrong results). You design escalation into the loop’s brief or project memory with explicit “if X, stop and ask me” rules, and you pair it with Module 5’s permissions — an ask permission enforces the pause on risky actions, while the brief makes the loop ask a good, specific question. A well-briefed loop is calibrated: confident on the routine, quick to ask on the risky, the stuck, and the unclear.

Key Concepts#

• Escalation — a loop pausing to ask a human, then continuing with the answer.
• The three triggers — irreversible/high-risk actions, repeated failure, and genuine ambiguity.
• Asking as honesty — a calibrated loop asks when uncertain rather than guessing confidently.
• Guidance + enforcement — a briefed escalation rule guides; an ask permission enforces the pause.

Why This Matters#

Escalation is what makes a hands-off loop trustworthy rather than merely capable — it’s the mechanism that keeps autonomy from turning into confident, irreversible mistakes. It’s also a maturity most AI usage lacks: people either babysit every action or trust the agent blindly, when the right answer is a loop calibrated to handle the routine and ask about the rest. Get escalation right and you can delegate real work — including work with risky steps — because you know the loop will check with you at exactly the moments that matter. You’ve now designed every kind of exit a loop can have. The last piece is seeing what a loop actually did — so when one misbehaves, you can diagnose it instead of guessing. Next: keeping and reading a loop’s log.

Continue Building Your Skills#

You can now teach a loop to ask — pausing on irreversible actions, repeated failure, and genuine ambiguity — and you know to reframe asking as honesty, not failure. Write “if X, stop and ask me” into your briefs, and enforce the truly risky ones with an ask permission. Next, you’ll close the module by learning to read a loop’s log: the record of what it actually did, which lets you diagnose a stuck or runaway loop from the evidence rather than guessing — and then you’ll diagnose a broken one yourself.