Three Interrupt Modes: Choose by Workflow

+15 Mana ✨
Slash Commands: /busy(DOCUMENTATION)

Introduction

When Hermes is busy (streaming a response or running a tool call) and you press Enter on a typed message, something has to happen. Hermes lets you choose between three behaviors: interrupt immediately, queue silently, or steer at the next safe point. The choice is controlled by the display.busy_input_mode config and the /busy slash command. Picking the right mode for your workflow is a small habit that compounds.

Key Concepts

  • interrupt (default): Pressing Enter while the agent is busy stops it immediately and processes your message.
  • queue: Your message is silently queued for the agent's next turn.
  • steer: Your message is injected as a note after the next tool call, without stopping work.
  • /busy [mode|status]: The slash command that switches modes mid-session.
  • display.busy_input_mode: The config key that sets the default.

Real World Context

A developer doing tight coding work prefers interrupt: when they see the agent heading the wrong way, they want their typed correction to take effect now. A different developer running long autonomous tasks prefers steer: they want to nudge the agent without restarting its current tool call. A third developer prefers queue: type the next thing while the agent finishes, no interruption, no rush. Same Hermes, three workflows, three modes.

Deep Dive

The three modes form a spectrum of "how aggressive" your Enter key is when the agent is mid-flight:

text
most aggressive ←──────────────────────────→ least aggressive

  /busy interrupt   /busy steer           /busy queue
  stop now          inject after          wait for next turn
  (default)         next tool call

interrupt (default)

Pressing Enter while the agent is busy:

  1. Sends a stop signal to the streaming response or running tool.
  2. Adds your typed message as the next user turn.
  3. The agent begins processing your new message immediately.

This is the right default for interactive coding. The cost of an interrupt is small (a few wasted tokens); the cost of letting drift continue is large (more wasted tokens plus a worse outcome).

queue

Pressing Enter while the agent is busy:

  1. Stores your message in a queue.
  2. The agent continues working uninterrupted.
  3. When the current turn ends naturally, your queued message becomes the next prompt.

This is useful when you want to keep typing without watching for the agent to finish. The downside: you cannot redirect mid-flight, so if the agent goes wrong, your queued message arrives too late to help.

steer

Pressing Enter while the agent is busy:

  1. Stores your message until the agent's next tool call completes.
  2. After that tool call, your message is injected into the agent's context as a steering note, without ending the turn.
  3. The agent reads the note and adjusts its plan, then continues.

This is the middle ground: you preserve in-flight work but get to nudge the agent before it does the next thing. It is the right choice for long autonomous tasks where you do not want to restart progress but do want to add direction.

Switching modes

You can switch modes at any time without restarting. The /busy command takes any of the three mode names or status to see the current value:

text
/busy interrupt    # set the mode
/busy queue
/busy steer
/busy status       # show what is currently set

You can also set a default in config.yaml:

yaml
display:
  busy_input_mode: interrupt   # or queue, or steer

Common Pitfalls

  1. Forgetting which mode you are in: Pressing Enter expecting an interrupt but getting a silent queue is confusing. /busy status is a single-keystroke check.
  2. Treating queue like interrupt: With queue, your message has no effect until the agent finishes the current turn. If the agent is going somewhere wrong, you need interrupt or steer, not queue.

Best Practices

  1. Default to interrupt for interactive coding: It matches the typical "I see drift, I want to correct now" workflow.
  2. Switch to steer for long autonomous tasks: When the agent is running for minutes and you want to nudge without restart, steer preserves progress.
  3. Switch to queue for ambient typing: When you want to keep composing while the agent works and you trust it not to drift.

Summary

  • Three modes: interrupt, queue, steer. Set by display.busy_input_mode or /busy.
  • interrupt is the default and the right choice for interactive coding.
  • queue and steer shine in long-running autonomous workflows.
  • Switch with /busy <mode>; check with /busy status.

Code Examples

text
# Three modes, three behaviors when you press Enter while the agent is busy

# Mode 1: interrupt (default)
Agent: streaming a response...
> Stop, refactor the other function instead<Enter>
[interrupted; new message processed immediately]

# Mode 2: queue
Agent: still streaming, will respond on next turn
> /busy queue
Agent: streaming...
> Add a logging line at the start<Enter>
[queued silently; delivered after the current turn finishes]

# Mode 3: steer
> /busy steer
Agent: running a tool call...
> Also include a unit test for the new branch<Enter>
[injected after the next tool call as a steering note; current work continues]
✓ Completed