The art of steering an agent

One evening in October, an agent was building my company's phone app while I tried each new version on my own phone. I didn't wait for it to finish. Every time something bugged me, I said so.

In 13 minutes I sent 18 notes. Some were a sentence. One was seven words: "Lot of word salad in this bar." Each note reached the agent within seconds, and it kept working, narrating as it went: "Adding that one too."

When it finished, all 18 were built and tested. There was no list of complaints at the end and no second round.

I call that steering. I talk to an agent while it works, instead of waiting for its answer. An agent, here, is an AI that does the work itself: it runs programs, edits files and checks its own results. About one in four of my messages reach one while it's still busy.

• 1in 4

  of my messages reach an agent mid-job

• 3s

  median before a Claude Code agent reads one

• 50to 1

  notes to a working agent for every stop

• 18

  notes in one job, with no second round

Most people use an agent like a vending machine. Put in a prompt, wait, read the answer, and if it's wrong, start over with a better prompt.

That works for a question. It wastes time on a job. Unlike a vending machine, an agent shows you what it's making while it makes it: its plan is in the first few lines, and a job can run for twenty minutes after that. If the plan is wrong, every minute after that is work you'll throw away. Watching an agent carefully build the wrong thing is a spectator sport I've retired from.

The idea is old. In 1999 the computer scientist Eric Horvitz laid out principles for software that shares a job with a person, and one of them is that people should be able to refine and redirect what the software is doing.¹ Today's agents make that easy. Anthropic, which makes the Claude Code agent, found that its experienced users step in more often than new users do.²

Think of a cook in the middle of a recipe. You can pass them a note, and they'll read it when they set the knife down and keep cooking. Or you can take the pan off the stove.

Agents give you both. Anthropic's Claude Code and OpenAI's Codex both let you type while the agent works. Claude Code "queues the message instead of interrupting the turn," meaning the agent's current stretch of work, and hands it over as soon as the step it's on is done.³ Codex calls the same thing steering.⁴ The stop button is the pan off the stove. It halts the agent mid-step so you can redirect it.

One difference: a cook reads the note between chops, and an agent reads it between steps. Some steps take a while.

I pass notes. From September 22 to October 31, I sent 1,666 messages to Claude Code agents that were already working, and I hit stop about 30 times. That's about 50 notes for every stop.

Of the 15 stops I followed with a message within two minutes, six started with "Wait." One, in full: "Wait I'm lost what are we doing here." Sometimes the one who needs stopping is me.

It's easy to assume steering is mostly fixing. So I took 300 of my mid-job messages at random and sorted each one by what it did.

Steering is mostly adding. Nearly half my notes add something to the job: a fact the agent didn't have, a bit more scope, or a preference. Another 18% ask a question, and 11% line up the next job. Only 9% change the agent's direction.

You can hear it in the first word. 13% of my mid-job messages start with "Also," against 3% of the messages I send to an agent that's sitting idle. If I say "also," the agent is busy. On September 22 I sent, mid-job: "While you're doing that can you also improve this screen."

Each of those adds is context the agent would otherwise have guessed at, or asked for once it was done. Steering is how I empty my head into a job while it's still soft.

The 9% that change direction are where steering pays the most, because they come early.

Earlier that same October day, at 1:27 am, an agent started building a guided tour for the app: an overlay that spotlights parts of the screen. About four and a half minutes in, I sent two messages. "We don't have to do an overlay if that's sloppy." Then: "What is more common for a situation like this? Should we just have set designed pages?"

The agent answered that most polished apps use designed pages. 54 seconds after my question it wrote "Switching to designed pages," undid its half-built tour and started over. About five and a half minutes of work went in the trash. If I'd waited, I'd have reviewed a finished, tested overlay, and only then asked for the redo.

My sample shows the same thing. Of the 26 course corrections in my sample, the agent changed its very next move in 18 and partly changed it in 3. In the other 5 its next message didn't show either way, and I couldn't find one it ignored. Half of these corrections came within the first minute of the job.

Some steers are just better ideas. Seventeen minutes into building a chess opening course, I told the agent it didn't need a chess engine for everything: "I think we could also cross-reference that with master's games." About three minutes later it had found a source for masters' games and was pulling their numbers for each position in the course.

The alternative to steering is waiting: let the agent finish, then send your notes.

After my first note in a job, the agent kept working for a median of 2.3 more minutes (half the jobs ran longer, half shorter), and one time in ten for more than 20. A note, by contrast, reaches the agent in a median of 2.7 seconds and shows up in its next move about 6 seconds after that.

I don't steer everything. About one job in five gets a note, and steered jobs run longer: a median of 3.9 minutes, against 0.7 for the jobs I leave alone. Partly that's the steering itself, since a note usually adds work.

A steer fixes this job. Sometimes it should fix every job after it.

On October 4, I watched a Codex agent pass a message to another agent by typing it into that agent's app window, and get ready to call it sent. Mid-run I said: "Also you're not sending these messages you're just typing them out in claude desktop app."

Four seconds later it agreed. 82 seconds later the message was really sent, and checked. Nine and a half minutes after my note, a new skill was in place: a saved set of instructions, loaded by every agent, on how to send those messages properly. It's the habit from Teach your AI once. When a steer catches a mistake, the lesson goes into a skill, so I never have to send that note again.

Steers carry safety rules too. Eleven minutes into a Codex cleanup of a customer-support channel, I added one: don't clear out any tickets that look legitimate and need attention. The agent confirmed 27 seconds later that no tickets would be deleted or closed.

Steering works because it's cheap. My median mid-job message is 11 words, about five seconds of talking.

And I mostly talk. In the two weeks my dictation app kept a log, 62% of my steers included spoken words. A spoken steer ran a median of 22 words, a typed one 7. Talking is the closest thing I have to a full brain dump, and the more of my head an agent sees, the better its work lands. Steering lets me do that dump while the job is still moving.

Being interrupted can even speed people up. In a 2008 study by Gloria Mark and colleagues, people who were interrupted while answering email finished faster, with the same quality, and paid for it in stress and frustration.⁵ An agent doesn't feel stress. The cost of a steer lands on me, and at five seconds it's small.

The timing works in my favor too. Claude Code hands my note over at the agent's next step, and most steps are short, so the median wait is under three seconds. A note sent during a long step waits for it to finish. My chess note sat for almost two minutes.

Agents do still find big changes of mind hard. A 2026 test that changed users' requests partway through long web tasks found that handling those changes "remains challenging" for strong models.⁶ I haven't found a study that measures whether steering improves results. My own logs show short, early notes that mostly add, and agents that act on them within seconds.

• A mid-job message is one Claude Code queued while the agent was working, or a second message within the same Codex job, from my logs for September 22 to October 31.
• I sorted the 300 sampled messages myself, in one pass, so the shares are estimates.
• Time I didn't spend waiting isn't the same as time saved. Some notes would have been fine after the job.

1. Watch the first few lines. Next time you hand an agent a job, read its plan before you look away. If it's heading somewhere you didn't mean, say so right then.
2. Add, don't restart. "Also..." beats a fresh prompt, and the agent keeps what it built.
3. Save stop for real trouble. Stop an agent that's about to do damage, or when you're lost. Otherwise, pass a note.
4. Test while it builds. Send each note the moment you find it, not as a list at the end.
5. Turn repeat corrections into rules. If you've sent the same steer twice, write it into a skill.

Steering is half of how I keep twenty agents moving. The art of context switching is the other half: getting back into a job in seconds. The art of working on the go is how I steer from my phone, and the 206× experiment shows what it all adds up to.