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

Iterating & Steering

Even a great brief drifts. Steering — nudging the agent back on course without micromanaging — is what separates a frustrating session from a productive one.

⏱ ~14 min read 🧭 The pilot's skill 🔁 Mid-task control

🎯 By the end you'll understand

Why long agent runs drift even from a perfect brief, the four moments that genuinely call for intervention (and the many that don't), how to write a correction that actually lands, when a clean restart beats salvaging a derailed run, and how to avoid the two failure modes — steering thrash and over-steering.

KEY INSIGHTThe one idea to take away

You're not the agent's boss handing down orders once. You're the pilot — hands near the controls, correcting small drifts before they become a crash.

A perfect brief gets you a good start. But an agent run is a long string of decisions, and small wrong turns compound (you saw this as cascading errors in 2.9). Steering is how you catch the drift mid-flight — not by re-explaining everything, but by adding the one thing that was missing and pointing at the exact place it went wrong.

🔑 Hold onto this

Good steering is specific + contextual: name what's wrong, say what you want instead, and supply the missing context. "No, wrong" gives the agent nothing to act on. And sometimes the fastest fix isn't steering at all — it's a fresh start with a better brief.

CORE CONCEPTWhy steering is even needed

If you've internalised writing a good brief (3.2), it's tempting to think steering is a sign you briefed badly. It isn't. Here's why drift is structural, not a personal failure:

So drift is the default, not the exception. Steering is simply you doing what the agent can't reliably do for itself: notice that the trajectory has bent away from the goal, and bend it back. You correct course mid-flight, before the wrong turns stack up.

Think of it the way a pilot thinks about a long flight. The flight plan is filed and good, but wind, traffic, and weather push the plane off the line constantly. The pilot doesn't re-file the plan every minute — and doesn't ignore the drift until the plane lands in the wrong city either. They watch the instruments and make small, timely corrections. Steering an agent is the same discipline: not constant control, not blind trust, but attentive correction.

📖 Steering

Steering is the act of correcting an agent's course while it's still working — giving it targeted feedback that redirects its next steps, rather than waiting for a finished (wrong) result or starting over from scratch.

FRAMEWORKWhen to step in — and when to let it work

The hard part isn't how to steer; it's when. Intervene too late and you've wasted a long run. Intervene constantly and you've become the bottleneck you were trying to escape. Here are the four moments that earn an interruption:

🧭

It's heading the wrong way

The plan it's executing will not reach the goal — wrong feature, wrong file, wrong approach. The longer you wait, the more it builds on the wrong foundation.

🎯

It misunderstood the goal

It's working hard on the wrong target. Often visible in its very first plan or restatement — read that, and you can catch a misunderstanding before any work happens.

🔁

It's stuck in a loop

Same action, same error, same fix attempt, repeated. It's not converging. Left alone it'll burn time (and tokens) circling. Break the loop with new information.

⚠️

It's about to do something irreversible

Delete data, push to production, send the email, spend the money. This is the hard stop from 3.4 · The Trust Gradient (permissions & the kill switch) — intervene before, not after.

💡 The opposite skill: letting it work

Most moments are not these four. If the agent is making reasonable progress in a slightly different style than you'd choose, let it finish. Interrupting a working agent to nudge cosmetics resets its momentum and clutters its context. Reserve your interruptions for course, not taste. You'll judge the finished work properly in review (3.6).

PRACTICALHow to steer effectively

A correction is just a small brief delivered mid-run. The same rules from 3.2 apply, compressed. Four moves, in order of impact:

MoveWeak versionStrong version
Be specific about the problem"That's not right.""The login form is missing the 'remember me' checkbox the spec asked for."
Say what you want instead"Fix it.""Add the checkbox below the password field; default it to off."
Point to the exact step / output"Something's off.""In auth.js, the function you just wrote ignores the session flag."
Add the missing context"No, wrong.""Our users stay logged in for 30 days — that's why the flag matters."

Notice the pattern: weak steering describes your feeling ("wrong," "off," "no"); strong steering hands the agent something to act on. The single highest-leverage habit is the fourth one — add the missing context rather than just rejecting. The agent guessed wrong because it lacked a fact, not because it's careless. Supply the fact and the guess corrects itself.

One more: if the run has clearly drifted off the original goal, re-state the goal and the hard constraints. "Remember, the whole point is X, and it must never do Y." This re-anchors the agent when the original brief has scrolled out of its working attention.

▸ A good steer, fully formed

"Stop — you're refactoring the whole module, but I only asked you to fix the date bug in parseDate(). Revert the unrelated changes and just patch the off-by-one in the day calculation. Keep the public API identical; other files depend on it." (Problem named, target given, location pinned, context added, constraint restated.)

SEE ITSteer the agent

The agent has drifted. Pick a scenario, then choose how you'd intervene and press Send. Watch where the trajectory goes. Notice that vague rejections make things worse, a specific + contextual correction gets it back on track, and when the context is already poisoned, a clean restart often beats salvage.

🤖 Interactive · Course-correct a drifting run

You
Agent

FRAMEWORKNudge vs restart — the decision aid

Steering assumes the run is salvageable. Often it isn't. When the agent's context is full of wrong assumptions, half-built dead ends, and your own contradicting corrections, you're trying to patch a poisoned context (2.3) — and a poisoned context is very hard to fix mid-stream. The bad premises stay in the window, quietly tugging every new step back toward the mistake.

Nudge (keep going) when…Restart (fresh brief) when…
It's mostly right; one wrong turnIt misunderstood the whole goal
A single missing fact explains the driftYou've already steered 3+ times with no convergence
The work so far is good and reusableThe context is cluttered with dead ends and contradictions
You can name the fix in one messageYou realise your brief was the problem

The instinct is always to salvage — you've watched it work for ten minutes; throwing that away feels wasteful. But the sunk cost is a trap. A restart with a better brief starts from a clean context and the lessons you just learned about what confused it. It's frequently the faster path, not the slower one.

📖 Restart vs salvage

Salvage = keep the existing run and steer it back. Restart = abandon the run and begin fresh with an improved brief and a clean context. The choice is an estimate: which gets you to a correct result with less total effort?

💡 Make the restart count

A restart only beats salvage if the new brief is genuinely better. Before you re-run, write down the one thing the agent didn't know and fold it into the brief. Otherwise you'll just watch it drift the same way again.

CORE CONCEPTIt's a feedback loop, and two ways it breaks

Steering isn't a one-shot correction; it's a rhythm: correct → observe → correct again. You nudge, you watch the next few steps, you confirm it's back on track (or nudge once more). This mirrors the agent's own act-observe loop — you're the outer loop around its inner one.

Two failure modes lurk in that rhythm:

⚠️ Steering thrash

You contradict yourself across corrections — "make it shorter," then "add more detail," then "shorter again." Each reversal lands in the context and confuses the agent about what you actually want. It starts hedging or oscillating. Decide what you want before you send the correction, and don't reverse without explaining why.

⚠️ Over-steering

You correct every tiny choice until you're effectively dictating each line. At that point you've taken over — you might as well have done the task yourself, and you've lost the leverage that made the agent worth using. Steer course, not keystrokes.

The healthy middle: correct decisively when the trajectory is wrong, then back off and let the agent execute. Observe. Correct again only if it drifts. That cadence — firm nudges separated by trusting silence — is what an experienced operator looks like.

WEAKNESSCommon mistakes to avoid

✗ Saying "wrong" without saying what's right

"No, that's not it" tells the agent nothing actionable. It'll guess again — often into a new wrong direction — and you've spent a turn going nowhere. Always pair the rejection with the correction and the missing context.

✗ Never restarting, always salvaging

Stubbornly steering a run whose context is already poisoned (2.3) wastes more time than a clean restart would. If you've corrected three times with no convergence, stop. Re-brief and re-run.

✗ Micromanaging every step

Interrupting reasonable progress to tweak style or second-guess minor choices kills the agent's momentum and turns you back into the bottleneck. If it's heading the right way, let it work — judge the result in review (3.6).

KEY INSIGHTHow this connects

  • The agent loop (2.1) — steering is the human outer loop wrapped around the agent's act-observe-decide inner loop.
  • Context & poisoning (2.3) — why a derailed run is hard to fix mid-stream, and why restart sometimes beats salvage.
  • Cascading errors (2.9) — the compounding small wrong turns that make mid-flight correction necessary in the first place.
  • The Trust Gradient (3.4) — permissions & the kill switch: the hard stop for the "about to do something irreversible" trigger.
  • Reviewing output (3.6) — steering is course-correction during the run; review is judgment after it. Different jobs, same goal.
  • Briefing (3.2) — a correction is a mini-brief; a restart is a better brief. The same craft, applied mid-flight.

Next, in 3.8 · Agentic Coding, you'll see steering in its most demanding arena — long, multi-file coding runs where drift is constant and the nudge-vs-restart call gets made every session.

GLOSSARYKey terms introduced

Steering
Correcting an agent's course while it's still working, via targeted feedback that redirects its next steps.
Intervention
Any deliberate human interruption of a running agent — to redirect, pause, or stop it.
Course-correction
Bending a drifting trajectory back toward the goal before the wrong turns compound.
Restart vs salvage
The choice between abandoning a run for a fresh brief (restart) and steering the existing one back (salvage).
Steering thrash
Contradicting yourself across corrections, confusing the agent about what you actually want.
Feedback loop
The correct → observe → correct-again rhythm; the human outer loop around the agent's inner loop.

ACTIVE RECALLCheck your understanding

Answer in your own words first, then reveal.

1Why does drift happen even when your brief was good?›

Because the agent makes thousands of unspecified small decisions, and a loop feeds each step's output into the next — so a small early misread compounds into a confident wrong direction. The original goal also slides out of working attention as the run grows. Drift is structural, not a sign of a bad brief.

2What makes a correction land instead of bounce?›

Specificity plus context: name what's wrong, say what you want instead, point to the exact step/output, and — highest leverage — supply the missing fact that caused the wrong guess. "No, wrong" gives the agent nothing to act on; "you missed X because of fact Y" corrects the guess itself.

3When should you restart instead of steer?›

When the agent misunderstood the whole goal, you've steered 3+ times without convergence, the context is cluttered with dead ends and contradictions (poisoned), or you realise your brief was the real problem. A clean restart with a better brief beats patching a poisoned context — but only if the new brief actually fixes what confused it.

4What are steering thrash and over-steering, and how do you avoid them?›

Steering thrash is contradicting yourself across corrections (shorter, longer, shorter) — avoid it by deciding what you want before you send. Over-steering is dictating every tiny choice until you've effectively done the task yourself — avoid it by steering course, not keystrokes: correct decisively when wrong, then back off and let it work.

You can fly the plane now. Next: agentic coding →