How to Steer a Coding Agent Mid-Run: Queue, Interrupt, Rewind

Published August 31, 2026 · by the AQ team

Steering a coding agent mid-run means correcting a session that is still working, without killing it and losing its context. Every major agent CLI now ships some version of three levers: queue a message the agent picks up at its next boundary, interrupt the current step and redirect, and rewind to an earlier checkpoint. This guide covers the exact mechanics in Claude Code, Codex CLI, and Cursor's cloud agents as of August 2026, the signals that a run needs intervention, and how to redirect cleanly.

Why mid-run steering is the cheapest intervention you have

Most agent-quality guidance covers the two ends of a run: a better prompt before, diff review after. The middle is where the money is. An agent that pivoted away from your intent at minute three will happily spend twenty more minutes building the wrong thing, and by review time the abandoned plan is several hundred lines to read, reject, and re-run. Catching the pivot live costs one sentence. And drift is not rare: long runs compact their own context so early constraints silently fall out, debugging detours become the new main quest, and a plan goes stale the moment the agent discovers the codebase disagrees with it, and none of it shows up as an error. With several agents going at once, monitoring the fleet tells you which session needs eyes; this page is what to do in the thirty seconds after you look.

The three levers, and what each one costs

• Queue a correction. Type your message while the agent works; it is delivered at a safe boundary and in-flight work is preserved. Cost: a fast-moving agent may take a few more steps before your note lands.
• Interrupt and redirect. Stop the current response or tool call now, then send a fresh instruction. The session and its context survive; the action that was mid-flight does not.
• Rewind. Restore code, conversation, or both to an earlier checkpoint and re-approach. Cost: everything after the checkpoint, exactly what you want when the last ten minutes were the mistake.

Escalate in that order: queue fixes most drift, interrupt when the agent is doing damage, rewind when the wrong path has contaminated code or conversation.

What each CLI actually gives you (as of August 2026)

Claude Code. Typing a message and pressing Enter while Claude works queues it rather than interrupting: it is delivered as soon as the current tool calls finish, within the same turn. Esc is the interrupt: it stops the current response or tool call mid-turn, keeps the work done so far, and sends anything you had queued right away. Double Esc on an empty prompt opens the rewind menu, backed by checkpoints captured before each prompt you sent: restore code, conversation, or both. Two documented limits matter: rewind only tracks edits made through Claude's own file tools (files changed by shell commands such as rm or mv are not restored), and checkpoints are session-level recovery, not a git replacement.

Codex CLI. OpenAI shipped steer mode in January 2026 and it is now stable and on by default: pressing Enter while the agent is working sends your message mid-turn, delivered at the next step boundary, and the agent adapts without losing its progress. Tab queues the message for after the current turn completes instead. Esc interrupts the active task while keeping the session, and /fork branches the conversation to try a different approach without abandoning the original.

Cursor cloud agents. Cursor's cloud agents accept follow-up messages while running, delivered at the agent's next tool call rather than cutting it off mid-action. Notably, Cursor documents that teammates on the same Cursor team can send follow-ups to a cloud agent another person started, provided they can view the agent and have access to its repository.

The signals that a run has drifted

You cannot steer what you do not notice. The reliable signals are visible in the live transcript:

• The loop signature. Repeated reads, edits, and searches over the same few files without new output: the agent is stuck.
• Step inflation. A task the agent scoped as four steps is on step eleven.
• Out-of-scope file touches. The diff starts growing in directories your task never mentioned. Agents love improving code they were never asked about.
• Stale plan execution. The agent wrote a plan, discovered mid-run that the codebase invalidates it, and is executing the plan anyway.
• Silent constraint loss. After a long run or a compaction, an early instruction (do not touch the schema) stops being honored. Re-state constraints in your correction.

A short playbook for the redirect itself

How you phrase the correction decides whether the agent recovers:

• Name what to keep. "The parser changes are right, keep them. Stop working on the cache layer" recovers minutes of work that a bare "stop, wrong direction" throws away.
• Re-anchor to the goal, not the mistake. State the original intent in one sentence. A drifted agent usually still has your first prompt in context; pointing back at it beats re-explaining.
• Commit before you pivot. Built-in rewind has holes (Claude Code's does not track shell-command changes), so a plain git commit before a big redirect is the checkpoint that always works. Running each agent in its own git worktree caps the blast radius of any run you fail to catch.
• Prefer a fresh start over a poisoned context. If two corrections in a row have not landed, rewind or restart with a tighter prompt. A conversation full of failed redirections keeps pulling the agent back into the same rut, and its own claim that it is back on track is not evidence.

Steering also starts before the run: plan-first modes (the agent proposes an approach you approve before it edits) and executable specs give the run a contract to steer against, turning "this feels wrong" into "step three violates the plan you approved."

Steering is still a single-player sport

The structural problem: on almost every surface, the only person who can see a drifting run, and the only person who can correct it, is the person whose terminal it is. A July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. The same pattern holds one stage earlier, mid-run, where the fix is cheapest: your teammate may know the subsystem the agent is mangling far better than you do, but if the session lives in your local terminal, their knowledge cannot reach it. The DIY answer is a shared box (agents in tmux on a server, teammates attach over SSH), but SSH-for-everyone is a blunt permission model, and nothing tells a teammate which of five sessions needs eyes.

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. Agents run as real CLIs in persistent tmux sessions on your team's VM, streamed live to the browser, so every steering mechanic in this guide works exactly as the vendor built it. The difference is who can reach them.

Teammates open the same workspace and watch the same live session as it runs, which turns drift-spotting from one person's peripheral vision into something the whole team can do. When a teammate needs to do more than watch, typing into someone else's terminal is delegated, not assumed: the session owner approves a control request in one click and keeps their own input. Each workspace runs in its own isolated git worktree, so a drifting run never contaminates a teammate's work, and sessions survive a closed laptop, so the run you need to redirect is still there when you get back. Visibility stays owner-managed: team-visible, or private and shared with specific people.

The Free plan is a personal sandbox for one person: AQ creates a private machine in an isolated network, nothing to install, no time limit. The Team plan is $50 per user per month in early access (standard $200, billed monthly), covers VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, and locks your rate for your first 12 months.

Honestly: if you run one agent at a time in one local terminal, the vendor keybindings above are all you need. Shared steering earns its place when runs outlive your attention span, or when the person best qualified to correct a session is not the one who started it.