Tell Your Agent When to Stop and Ask

Most agent instructions are about what to do. Very few say when to stop.

That gap matters. When an agent hits something it doesn't understand, it has two choices: ask, or guess. If nothing tells it to ask, it usually guesses. Then it keeps going, and the next step gets built on the guess.

The fix is a short set of stop rules. Plain conditions that mean "pause here and check with a person before you go on." Here are the ones I'd start with, what goes wrong without each one, and what it looks like with it.

Why agents guess

An agent is set up to finish the task. Stopping can look like failing, so the pull is always toward one more step.

It also can't tell on its own which mistakes are cheap and which are expensive. Renaming a draft and deleting a folder are both just commands. The difference lives in your head, not in the instructions, unless you put it there.

So stop rules are really a way of writing down what you already know: where the edges are, and what's on the other side of them.

Rule 1: Stop when the instructions don't cover it

Without the rule: You ask for a report "in the usual format." There are two formats in the folder. The agent picks one and builds the whole report in it. It was the wrong one.

With the rule: It sees two formats, stops, and asks which one. One short question, one short answer, and nothing gets redone.

The plain version: if two readings of the instructions would lead to different work, ask before choosing.

Rule 2: Stop before anything that can't be undone

Without the rule: The agent is tidying up and finds files that look unused. It deletes them. One of them wasn't unused.

With the rule: It lists what it plans to delete and waits for a yes.

Deleting, overwriting, sending, publishing, merging: anything you can't take back gets a pause first. Things you can undo in one step can usually go ahead. Things you can't undo, wait.

Rule 3: Stop before it spends or sends

Without the rule: A task seems to need a paid service, so the agent signs up. Or it finishes a reply and sends it, because sending felt like the last step.

With the rule: It drafts the reply and stops. It names the service and what it costs, and stops.

Money and messages both leave your hands the moment they go. They're also the two places where "it seemed helpful" is the least comforting thing to hear afterward.

Rule 4: Stop when what it finds doesn't match what it was told

Without the rule: The instructions say the settings live in one file. The agent finds them in another, quietly edits that one, and moves on. Now there are two places that look like the truth, and nobody knows.

With the rule: It says, "You told me the settings are here. I found them there. Which is right?" Then it waits.

A mismatch is information. It usually means the instructions are out of date, or the agent is looking in the wrong place. Either way, a person should know.

Rule 5: Stop before it tries the same fix again

Without the rule: A step fails. The agent tries a small change. It fails again. Another small change. An hour later the bill has grown and the problem hasn't moved.

With the rule: After a couple of failed tries at the same thing, it stops and reports what it tried and what happened.

Pick the number yourself. The point is that there is a number.

Rule 6: Stop before it reaches past its own lane

Without the rule: The agent was asked to fix a typo on one page. It notices the page next door "could be better" and rewrites that too.

With the rule: It fixes the typo, notes the other page as a suggestion, and leaves it alone.

Good agents notice things. That's useful. Acting on everything they notice is not.

How to ask well

Stopping is only half of it. A good stop comes with a good question.

• Say what it was doing. One line of context.
• Say what it found. The actual thing, not a summary of a summary.
• Give the options. Two or three, if it can see them.
• Say which one it would pick, and why. So the person can just say yes.
• Say what happens while it waits. Usually nothing. That's the point.

A question like that takes seconds to answer. A vague "I ran into an issue, how should I proceed?" takes a whole conversation.

Don't overdo it

There's a failure on the other side, too. An agent that asks about everything gets tiring, and people start saying yes without reading. Then the stop rules are just noise.

So keep the list short. Stop for what's unclear, what can't be undone, what costs money, what goes out the door, what doesn't match, and what keeps failing. Let everything else run.

If you find yourself answering the same question every day, that's not a reason to drop the rule. It's a sign the answer belongs in the instructions.

A starter set

Here's a version you can adapt and put near the top of an agent's instructions:

1. If the instructions could mean two different things, ask which one.
2. Before deleting, overwriting, sending, publishing, or merging, list what you'll do and wait for a yes.
3. Before spending money or signing up for anything, stop and ask.
4. If what you find doesn't match what you were told, say so and wait.
5. After two failed tries at the same fix, stop and report.
6. Stay inside the task. Note anything else as a suggestion.
7. When you ask, give the options and say which one you'd pick.

The short version

An agent doesn't know where your edges are unless you tell it. Stop rules are how you tell it.

The cost is a few short questions. The payoff is that guesses get caught while they're still guesses.

My novels live at the far end of that road. The Shadows Series is about what happens when an intelligence you cannot see decides who you are allowed to be. Book One, Shadows of the Forgotten, is where it starts: https://johndclay.com/books/shadows-of-the-forgotten