# Agent Steering

> Agent steering means sending a follow-up instruction to a running coding agent without cancelling it. Which harnesses accept mid-run input as of October 2026.

Published October 24, 2026 · by the AQ team · Canonical: https://aq.dev/glossary/agent-steering/

**Agent steering** is sending a follow-up instruction to a coding agent that is already working, so the agent changes course inside the live run instead of being cancelled and restarted. A steered message reaches the model at the next safe point in its loop (typically when the current tool call finishes), the work done so far is kept, and the agent folds the new instruction into the same task. As of October 2026, Claude Code, Codex CLI, Cursor's CLI, and Kimi Code CLI all accept input mid-run in some form, OpenAI has made steering a first-class API event for its newest models, and a few harnesses still document only the older pattern: interrupt the run, then start over with a better prompt.

## Steering vs interrupting, queueing, and subagents

Four words get mixed up here, and the differences decide what you lose:

- **Steering** delivers your message inside the live turn. Nothing is cancelled: the agent finishes the step it is on, reads your instruction, and continues with both the original task and the correction in context.
- **Interrupting** stops the in-flight action now (Esc in most CLIs). The session and its context survive, and completed edits stay on disk, but the step that was mid-flight is abandoned. You then send a fresh instruction as a new turn.
- **Queueing** holds your message until the agent reaches a boundary, in the strictest sense until the whole turn ends. A queued message never alters the current turn; it becomes the next one. Several harnesses blur this line by delivering "queued" messages inside the same turn, which is steering by behavior under a queue name.
- **Subagents** are a different mechanism entirely: the agent delegates a subtask to a separate agent with its own context window. Steering changes what the main run is doing; a subagent adds a parallel worker. The two meet only in that some harnesses let you message a subagent's parent while the subagent runs. See [subagents in coding agents](https://aq.dev/guides/subagents-in-coding-agents-explained/) for that mechanism.

The practical order is steer first, interrupt second, restart last: steering costs nothing, an interrupt costs the in-flight step, and a restart costs the accumulated context. The hands-on playbook for all three is in [how to steer a coding agent mid-run](https://aq.dev/guides/steer-coding-agents-mid-run/).

## Why steered input lands at a tool boundary

A coding agent is a loop: the model proposes an action, the harness executes it (run a command, edit a file), and the result goes back to the model, which proposes the next action. While the model is generating or a tool is executing, there is no way to inject new words into the middle of that step: the model's request is already in flight. So the harness holds your message and delivers it at the next boundary, usually when the current tool call returns and before the next model request goes out. That is why a steered instruction sometimes takes a few seconds to land, why a fast-moving agent may complete one or two more steps before adapting, and why steering never un-runs a command or un-edits a file. Steering changes the future of the run, not its past; anything already done needs an interrupt, a revert, or a checkpoint restore instead.

## Which harnesses accept mid-run input, as of October 2026

Each row is verified on the vendor's own documentation, changelog, or release notes as of October 2026. "Not documented" means the vendor's reference describes no such feature, not that one is hidden.

| Harness | Mid-run input | Interrupt |
| --- | --- | --- |
| Claude Code | Enter while Claude works queues the message, and queued messages are passed to Claude as soon as the current tool calls finish, within the same turn (steering under a queue name). Ctrl+Enter sends queued messages immediately (v2.1.275 and later). Queued slash commands and shell commands wait for the turn to end | Esc stops the current response or tool call and keeps the work done so far; queued messages are sent next |
| Codex CLI | Steer mode is stable and on by default since v0.98.0 (February 2026): Enter sends your message into the running task immediately, and Tab explicitly queues it for after the turn instead | Esc interrupts the active task and keeps the session |
| Cursor CLI | Enter while the agent works sends your message into the active run at a safe boundary to steer it (changelog, August 2026); a follow-up moves running tools to the background instead of killing them | Pressing Enter again interrupts the turn |
| Kimi Code CLI | Ctrl+S is a dedicated steer key: it injects the current input directly into the running turn, and the model sees it at the next interruptible point | Esc or Ctrl+C interrupts streaming output |
| Gemini CLI | Queue only: Tab queues the current prompt to be processed after the current task finishes; no mid-turn steer is documented | Ctrl+C cancels the current request |
| OpenCode | Not documented: the keybind reference lists no queue or steer binding | Esc (the session_interrupt binding) |
| Devin CLI | Not documented in the keyboard reference; Devin's platform API can send a message to a running cloud session | Esc cancels the running agent |

The split in that table is the state of the art in one picture. Four harnesses treat mid-run input as a feature with its own key and delivery semantics. The rest still offer the 2025 pattern: your only live controls are stop and wait, so changing direction means interrupting the run (or letting it finish) and spending a fresh turn, and in the harnesses with no queue at all, whatever you typed while the agent worked is simply input waiting to be submitted.

## Steering is becoming an API primitive

Mid-run input started as a terminal keybinding, and it is now moving into the model APIs themselves. OpenAI's Responses API documents mid-turn steering as a WebSocket event (response.steer with the new input and the id of the response to steer), supported by its GPT-6 model family and not by earlier models, with explicit semantics: acceptance means the input is queued rather than acted on, steering never rewrites output already sent, and it cannot cancel tools that have already started. Those are the same rules the CLIs converged on, now enforced one layer down. Cognition's Devin exposes the equivalent at the session level: an API call delivers a message to a session that is actively running. For anyone building their own agent loop, the lesson of both designs is that steering is a delivery contract (hold input, apply at the next boundary, never pretend it can undo the past), not just a keybinding.

## Why steering matters more as runs get longer

Steering exists because agent runs outgrew the prompt-response rhythm. A run that lasts half an hour will discover things mid-flight (a plan that does not survive contact with the codebase, a constraint the model has silently dropped), and the person watching usually spots the drift minutes before the run ends. Without steering, that observation has nowhere to go: you either kill twenty minutes of context or watch the agent finish building the wrong thing. With it, a one-sentence correction lands while the work is still cheap to redirect. The craft of noticing drift and phrasing the correction is its own topic, covered in [the steering guide](https://aq.dev/guides/steer-coding-agents-mid-run/); the glossary-level point is that steering is the cheapest intervention a harness can offer, and vendors have spent 2026 making it the default meaning of typing while the agent works.

## 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. On AQ, agents run as real CLIs in persistent tmux sessions on your team's VM, streamed live to the browser, so every steering mechanic in the table above works exactly as its vendor built it, and the session is still there to steer after you close the laptop. The difference is who can reach a running agent: teammates open the same workspace and watch the same live session, and when someone else should drive, typing into another person's terminal is delegated by its owner approving a control request in one click, with the owner keeping their own input. Each workspace runs in its own isolated git worktree, so a run that needs redirecting never contaminates anyone else's work. 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.

## Frequently asked questions

### What is the difference between steering and interrupting a coding agent?

Steering delivers your instruction into the live run at the next safe boundary, and nothing is cancelled: in-flight work completes and the agent adapts. Interrupting (Esc in most CLIs) stops the current response or tool call now; the session and completed edits survive, but the step that was mid-flight is lost and your next message starts a new turn. Steer when the agent should change course, interrupt when it is actively doing damage.

### Does pressing Enter interrupt Claude Code or Codex?

Neither, as of October 2026. In Claude Code, Enter while Claude works queues your message, and queued messages are delivered as soon as the current tool calls finish, within the same turn; Esc is the interrupt. In Codex CLI, steer mode has been on by default since v0.98.0 (February 2026), so Enter sends your message into the running task immediately and Tab queues it for after the turn; Esc interrupts.

### Why does my message take a while to reach a running agent?

Because there is no way to inject text into the middle of a model request or a running tool call. The harness holds your message and delivers it at the next boundary, usually when the current tool call returns and before the next model request. A fast-moving agent may take another step or two before your correction lands, which is normal, not a dropped message.

### Can steering undo something the agent already did?

No. Steering changes the future of the run, never its past: OpenAI's API documentation states it plainly (steering does not rewrite output already sent and cannot cancel tools that already started), and the CLIs behave the same way. To unwind completed work you need a different lever: an interrupt plus a revert, a checkpoint restore such as Claude Code's rewind, or plain git.

### Which coding agents cannot be steered mid-run?

As of October 2026, Gemini CLI documents queueing only: Tab holds your prompt until the current task finishes, so the live turn cannot be redirected. OpenCode's keybind reference documents an interrupt key but no queue or steer binding, and Devin's CLI keyboard reference documents cancel only (its platform API can message a running cloud session). On those surfaces, interrupt-and-restart is the only way to change a live run's direction.

---

About AQ: 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. Start at [aq.dev](https://aq.dev/).