You sent /steer to change course and it froze: the clarify that locked the whole turn

Halfway through a long task in Slack, the agent stops and asks: “Should I keep cleaning up the old build artifacts?” You do not want to answer that. You changed your mind — you want it on the auth module instead. So you type /steer skip the artifacts, look at auth and hit Enter.
Then: silence.
No acknowledgement, no new output, the question still sitting there. You wait thirty seconds, send “you there?”, nothing. A few minutes later the question disappears on its own and the agent lumbers on — without any sign it ever saw your steer.
This is not flaky networking and it is not a slow model. It is a real deadlock, and the reason is very specific.
What /steer actually promises
Start with the semantics, because the misunderstanding lives here.
/steer does not start a new turn and does not interrupt. It appends a note to the run that is already going, so the model sees it after the next tool call — the docs say exactly that: it arrives after the next tool call, no interrupt, no new user turn. The tool-calling loop is not broken; it just gains context.
That is genuinely useful. The agent is running tests, you say “focus on the auth module”, and on its next iteration it adjusts instead of starting over.
But it comes with an assumption: there has to be a next tool call.
How the deadlock forms
When the agent asks you something mid-task, the tool doing the asking is clarify. It is unlike other tools: it returns no data, it just waits for a person. On the gateway side it is a pending prompt — possibly a persistent native card in Slack or Feishu.
Now stack two facts:
- The only tool in flight in this run is that
clarify, blocked on the user. - The user did not answer; they sent something recognised as a command (
/steer).
The second fact is the trap. A recognised slash command is deliberately not treated as an answer to the prompt. That design is right — you wanted to issue a command, not answer the question. So the prompt stays armed and the clarify stays blocked.
Which means the tool batch never returns. No next tool-call boundary, no place for /steer to land. Worse, the steer is accepted anyway: agent.steer() only requires a live turn, and the turn is alive — it is sitting inside the clarify. So you get a promise (“arrives after the next tool call”) that can never be kept.
Before the fix, the only exit was agent.clarify_timeout expiring.
The fix: release the prompt before accepting the steer
The first commit (fix(gateway): a /steer releases the clarify that owns the turn) does exactly that: in the /steer handler, before the steer is accepted, the pending prompt is released.
Release works the same way the timeout does: the prompt resolves as CANCELLED and a persistent native card is retired. With the prompt withdrawn, the block is gone, the unblocked turn continues, and the steer drains at the next boundary. The resolve-plus-retire pair that used to be inlined in the prose branch became _release_pending_clarify, shared by both call sites.
And if the model ends the turn right after being unblocked? The steer is not lost — the finalizer re-delivers a leftover steer as the next user turn, so the note arrives eventually, just possibly one turn later.
The second trap: the order matters
Once the first fix was in, a subtler race remained, and it is worth its own paragraph because it explains why “just swapping two lines” deserved a separate fix.
Releasing the prompt unblocks the agent thread immediately. Right after that it awaits a card update — a real network round trip on Slack or Feishu. The original order was: release the prompt, await the card update, then accept the steer. During that await, the freshly woken agent could start its next request, or finish the turn entirely. By the time the steer was queued there was no live turn to inject into, and the note was gone.
The second commit (fix(gateway): /steer is queued before the clarify it releases wakes the agent) inverts the order: queue the steer first, then release the prompt. However slow the card update is, the steer is already waiting in the queue.
In one sentence: releasing the prompt is what unlocks the turn, and queueing has to happen before unlocking.
What to do today
Until these land in a release (both are on main, not in v0.23.0), there are practical workarounds.
Do not answer a prompt with a command. If the agent is asking something, answer it — even “hold off for now” — let the turn end, then /steer. Or do nothing and let it time out.
Know your timeout. The default dropped from an hour to 90 seconds; older configs may still carry 3600. Check your own value:
hermes config get agent.clarify_timeout
0 or a negative number means unlimited (and a legacy top-level clarify.timeout, if explicitly set, still wins). If you once raised this to “give users plenty of time”, that is exactly where this deadlock hurts most: an unanswered question pins the whole turn to the desk.
Want to interject without taking over the turn? Use /btw. It is the aside channel: it answers a side question without interrupting the work in progress, and it does not turn your message into a command that disturbs the pending prompt. See asking a side question with /btw.
Ask fewer questions up front. If you need five things clarified, ask them in one batch instead of five round trips — the pattern is covered in clarify batch questions.
What the bug is really telling you
On the surface it is a two-line ordering bug. The interesting part is the three assumptions it broke:
First, /steer assumes there is always a next tool boundary. That holds while tools return on their own — but clarify is the one tool whose return condition is a human, and it breaks the assumption.
Second, command routing assumes a command does not need the turn. Mostly true: most slash commands read or write config and switch modes. /steer is one of the few that needs the turn to take effect.
Third, and this is the one to carry into your own code: unblocking is a side-effecting act. Split it from delivery and the await between them becomes a new race window. Either deliver before you unblock, or make the pair atomic — here the cheaper option was reordering, because swapping two lines costs less than building a transaction.
If you orchestrate several agents, or use /steer to correct a subagent, the same command-versus-answer boundary shows up elsewhere; the control-signal notes in subagent live orchestration and the site’s hermes gateway reference cover the routing side.
Status
Both commits are on main (November 7) and in no tag, v0.23.0 included. hermes update gets you releases, so you will not have this fix until the next one — or track main.
Update (2026-11-10): these changes shipped in v0.23.1 (November 9) —
hermes updateis enough. The “not in v0.23.0” statements above are still accurate; v0.23.1 closes the gap.
Until then the shortest possible advice is enough: when the agent is waiting for an answer, do not answer its question with a command.