Cursor SDK New Feature: Real-Time Steering of Running AI Agents

Cursor SDK has introduced a new capability: developers can now intervene in real time while an agent is running, injecting messages into the next conversation turn via the run.steer() method. This means the AI coding agent is no longer a "black box"—you can adjust its direction at any time instead of waiting for it to finish and starting over.

From "Wait After Submitting" to "Adjust on the Fly"

The traditional agent invocation model is linear: pass in a task, wait for the result. If you spot a problem midway, you can only interrupt or wait for it to finish. run.steer() changes this flow—it inserts a new message into the agent's next turn, letting the agent naturally absorb your instruction as it continues execution. Based on the official description, this is not a simple pause-and-edit, but a lightweight intervention into the agent's execution stream.

This design is especially meaningful for long-running coding tasks. For example, if you ask the agent to refactor a module and halfway through you realize it picked the wrong file, previously you could only terminate it. Now you can directly tell it in the next turn to "switch to another path."

The agent's "turn" is the key concept for understanding run.steer(). In LLM-based agent systems, a task is typically broken down into multiple turns: in each turn, the agent receives the current context (including user instructions, history messages, tool call results, etc.), the model generates the next action (such as calling a tool or outputting text), then the action is executed and the result is fed back into the context for the next turn. The position where run.steer() inserts a message is precisely this turn boundary—it does not interrupt the turn currently being executed (for example, an in-progress file read/write or code search), but appends the new message to the context before the agent completes the current turn and is ready to generate the next action. This mechanism is similar to "interjecting" in a conversation: the agent sees both its original plan and your new instruction when making its next-turn decision. Because insertion happens at the boundary rather than mid-execution, the agent's core loop logic needs no modification—this is also the technical reason why the API remains low-intrusion.

Subagents Automatically Move to the Background

Another detail worth noting is how subagents are handled. When you perform a steer operation in the main flow, if a subagent is in the middle of a task, it is automatically moved to the background to continue working rather than being forcibly interrupted.

Behind this behavior is a practical trade-off: subagents often handle independent subtasks (such as searching code or generating tests), and forcibly terminating them would waste the parts already completed. Letting them finish in the background both preserves progress and keeps the main flow's steer instruction from being blocked.

Subagents are a common layered design in agent systems: the main agent handles planning and coordination, and when it encounters a subtask that can be completed independently, it spawns a subagent to execute it—for example, searching the codebase, running tests, or generating documentation. A subagent has its own context and execution turns, and returns the result to the main agent when done. The benefit of this pattern is isolating complexity and enabling parallel processing, but it also introduces lifecycle management issues—when the main flow needs to change direction, how should a running subagent be handled? Forcibly terminating it loses the intermediate results it has already completed, while leaving it unchecked may block the main flow. Cursor SDK chooses to "background" the subagent: the main flow continues to receive steer instructions and move forward, and the subagent's results can still be adopted or ignored after it finishes in the background. This is effectively an optimistic concurrency strategy, deferring the judgment of "whether it's wasted" until after the subagent completes, rather than arbitrarily killing it the moment the steer occurs.

Impact on AI Coding Workflows

Real-time steer capability brings "human-machine collaboration" closer to the rhythm of pair programming. You don't need to have the requirements perfectly thought out before the task starts; instead, you calibrate gradually during the process.

From an API design perspective, run.steer() is a low-intrusion interface—it doesn't change the agent's core execution logic and only inserts messages at turn boundaries. This design lowers the barrier to use while preserving room for the agent's autonomous decision-making. As for how conflicts between steer messages and the agent's original plan are resolved, the official description doesn't elaborate, and developers will need to verify the actual effects themselves.

Summary

Cursor SDK's run.steer() turns "runtime intervention" into an API call. Combined with the subagent backgrounding strategy, it attempts to solve a real pain point in agent programming: the longer the task, the higher the risk of one-shot delivery. For teams building AI coding tools, this is an interaction paradigm worth watching.