Steering Mid-Task Without Losing Progress

+15 Mana ✨
Slash Commands: /steer and /queue(DOCUMENTATION)

Introduction

Interrupting an agent is destructive: it stops the current tool call, drops any in-flight reasoning, and resets the turn. Steering is constructive: it adds a note for the agent to consider at the next safe point, without stopping work. Most users reach for interrupt because they learned it first. Knowing when to steer instead is the next step up in CLI fluency, and it is the single biggest reason to switch from the interrupt mode to the steer mode for autonomous tasks.

Key Concepts

  • /steer <prompt>: Injects a note after the agent's next tool call.
  • /queue <prompt> (alias /q): Queues a prompt for the next turn without interrupting.
  • Constructive vs destructive: Steer adds, interrupt resets.
  • Save progress, change direction: The whole point of steering.

Real World Context

The agent is mid-way through writing a test suite for a module you asked it to test. You realize you also want it to add a couple of logging statements to the module while it is in there. With interrupt, you would stop the test-writing, ask for both, and the agent would restart from zero. With /steer add a couple of debug logs to the module while you are editing it, the agent finishes the current test, reads the steering note, adds the logs, and continues. No restart, no lost progress.

Deep Dive

The two commands that preserve progress are /steer and /queue. They differ in timing and visibility.

/steer <prompt>

When you send /steer ..., the prompt is stashed inside the runtime. As soon as the agent finishes its next tool call, Hermes injects the steering text into the agent's context window as a system-style note like "User added: ...". The agent reads it on its next reasoning step and naturally adjusts.

Key properties:

  • Timing: After the next tool call, before the next reasoning step.
  • Cost: Roughly the token count of your message; no rework, no restart.
  • Visibility: The steer text appears in the transcript with a distinct marker so you can audit what you injected.
  • Best for: Adding constraints, extending scope, redirecting after the current step.

/queue <prompt>

When you send /queue ..., the prompt is held until the agent's turn ends naturally. The next user prompt the agent sees is your queued one.

Key properties:

  • Timing: Next full turn, not mid-turn.
  • Cost: Same as a normal prompt; the agent runs its full reasoning loop on it.
  • Visibility: The queued message appears in the transcript like any other user prompt.
  • Best for: A follow-up question or task that comes after the current work completes.

When to steer vs queue vs interrupt

text
Situation                                                 Best response
────────────────────────────────────────────────────────  ────────────────
Agent is on track, you want to add a constraint           /steer
Agent is on track, you have a follow-up task              /queue (or /q)
Agent is finishing soon, you want the next thing ready    /queue
Agent is heading clearly wrong                            interrupt (Ctrl+C)
The current tool call must not be restarted                /steer
You want immediate processing of a new request             interrupt

The rule: the more you value the current work, the more you should reach for /steer or /queue. Interrupt is for moments when the current work is wrong.

Writing good steering messages

Because steering arrives mid-flight, vague messages are easy to misinterpret. Be specific about what should change and what should stay the same:

text
# Vague (likely to confuse)
/steer also be careful with the imports

# Specific (clearly actionable)
/steer when you edit the imports, prefer named imports over default; keep the rest of the plan

Common Pitfalls

  1. Using interrupt when steer would have preserved progress: Especially after a long tool call. Steering would have kept the work; interrupt threw it away.
  2. Steering with vague messages: Mid-flight context is fragile. Vague steering is more likely to be misread than vague new-prompt input.

Best Practices

  1. Default to steer when the direction is right but a detail is missing: Save the agent's progress; add the missing constraint.
  2. Default to interrupt when the direction is wrong: Do not pay for more wrong work.
  3. Make steering messages specific and additive: "Also include X, keep the rest" beats "be careful about X".

Summary

  • /steer adds a constraint after the next tool call without restarting; /queue waits until the next turn.
  • Interrupt is for wrong direction; steer is for missing detail; queue is for follow-up.
  • Specific, additive steering messages outperform vague ones because mid-flight context is fragile.
  • Choosing the right tool preserves progress and reduces total token cost.

Code Examples

text
# Three responses to the same situation, with very different costs

# Situation: agent is mid-way through writing a test suite for parseInput.
# You want it to also add a couple of debug logs in the same file.

# Option A: interrupt (destructive, restarts the whole turn)
<Ctrl+C>
> Write tests for parseInput AND add a couple of debug logs while you're at it
# Cost: throws away all test-writing progress, agent starts over

# Option B: queue (waits until tests are done, then starts logging)
> /queue When the tests are done, add a couple of debug logs to parseInput
# Cost: tests finish first, then a fresh turn for logging, clean but slower

# Option C: steer (injects after next tool call, preserves test-writing)
> /steer also add a couple of debug logs to parseInput while you're editing it
# Cost: agent finishes current test file, reads the note, adds logs, continues
✓ Completed