Hermes Agent Manual Subagent Control: Steer, Stop, and Watch Live

Hermes Agent's delegate_task subagents used to be the definition of fire-and-forget: you handed a child a goal and context, walked away, and hoped the summary that came back matched what you meant. Nous Research changed that trajectory with the Pantheon release (Hermes v0.21.0, August 31, 2026), and by September 10–11, 2026 the operator story is fully documented: manual subagent control — list live children, steer one mid-flight, stop another without losing partial work — is a first-class surface across Hermes Desktop, the TUI, CLI, and gateway RPCs.

That matters because delegation is where the tokens go. A parallel batch of three research subagents can burn most of a run's budget. If the first child drifts toward summarizing tickets instead of grouping complaints, you want to correct it in place, not wait ten minutes for a wrong answer and restart. Manual control turns delegation from a gamble into a supervised process — the same shift Cursor Projects is attempting at the coordinator layer, but Hermes ships it in an open-source, local-first harness you already run on a VPS or laptop.

If you are new to Hermes, start with the Hermes Agent setup guide. For the multi-agent social layer Nous added in August, see Bot Mode. This post is about the operator console for delegate_task children — the layer that sits underneath Bot Mode's named coworkers and above raw single-thread chat.

TL;DR — what changed and where to click

What Nous actually shipped (and when)

The headline feature landed in Hermes v0.21.0 — the Pantheon release on August 31, 2026. Teknium's release notes describe delegate_task gaining live orchestration: list running children, steer mid-flight, stop early and keep partial results, optional JSON-schema validation on child outputs, per-delegation cost in results, and raised defaults (250 iterations, 10 concurrent children).

Nous framed Pantheon as "the gods assemble" — Bot Mode for named agent societies, cron jobs that remember between runs, MCP as a command center, and subagents you can steer while they run. Manual subagent control is the human half of that last bullet: the parent model could already orchestrate its own children via tool actions; September's documentation pass makes the same controls reachable to you without asking the parent agent to relay instructions.

v0.21.1 (tag v2026.9.7, released September 7, 2026) is a rollup patch — Nous notes it includes "delegation reliability improvements" among thousands of commits, with full curated notes deferred to v0.22.0. For operators, the practical takeaway is: run hermes update before relying on manual control in production delegations.

Official references as of September 11, 2026:

• Subagent Delegation docs — steering semantics, /agents, subagent.steer RPC
• Desktop App docs — Live subagents — Subagents frame, Steer / Stop controls
• TUI docs — /agents — observability overlay with kill/pause and cost rollups
• Slash commands — /steer — mid-turn nudge for the parent agent (distinct from subagent steering)

How manual subagent control works (mechanism)

Understanding the delivery semantics prevents frustration when you click Steer and nothing visible happens for thirty seconds.

Three control actions

Whether you are the parent agent or a human operator, the control surface is the same trio documented under Steering a Running Subagent in Nous's delegation guide:

1. list — returns live children: subagent_id, goal, status, running_seconds, accepting_steer, transcript path
2. steer — queues a course correction without stopping the child
3. stop — ends the child at its next iteration boundary; partial result still re-enters the conversation

The parent agent invokes these through delegate_task with action parameters:

{"action": "list"}

{"action": "steer", "subagent_id": "sa-0-1a2b3c4d", "message": "focus on pricing instead of features"}

{"action": "stop", "subagent_id": "sa-0-1a2b3c4d"}

Humans reach the same steering path through subagent.steer gateway RPC (session-scoped — you can only steer children spawned by your live UI session) or the Desktop/TUI affordances below.

Steer delivery: queued ≠ delivered

This is the detail most README summaries skip. A "queued" response means Hermes accepted the steer before the child's completion boundary — not that the child has read it yet. Steering appends text to the child's last tool result at the next iteration boundary; an in-flight tool call is never cut. The child sees steers as an out-of-band user message wrapped in a trusted [OUT-OF-BAND USER MESSAGE] marker (a fix merged in PR #40240 so injection-hardened models stop refusing mid-turn guidance).

If the child finishes before the steer lands, the parent receives missed_steer in the completion entry with an explicit note — so you know to re-issue guidance as a follow-up instead of assuming it landed. Calls after closure return "rejected".

Stop preserves partial work

Before Pantheon, stopping a delegated agent often meant losing whatever it had done. The September-era behavior Nous documents: early stop returns a normal completion message with whatever summary the child produced up to that point. That single change lowers the cost of experimentation — you can kill a drifting research pass without restarting from zero.

Where to control subagents manually (by surface)

Hermes Desktop — Live subagents frame

The Desktop documentation describes a Subagents frame above the composer while workers are live: task names, elapsed time, latest activity, preview of up to three workers. Expand the header for the full roster, select a worker, then use Steer / Stop.

Each frame belongs to its chat — including in split panes — so parallel sessions do not cross wires. The UI copy is explicit: steering acknowledges queuing, not instant delivery.

Desktop also exposes Agents and Command Center as orchestration surfaces (Cmd/Ctrl+. opens Command Center per the docs). When delegation.child_timeout_seconds is configured, the Agents panel can pause or restore a running child's timeout ("Let 'em cook" / "Restore timeout") via PR #88783 — useful when a deep code review legitimately exceeds a cost-control cap.

For steering the main agent mid-turn (not a child), Desktop reserves Cmd/Ctrl+Enter while busy: it steers via session.steer, plain Enter queues. That parent-level /steer path is separate from subagent steering but shares the same trusted-marker backend.

TUI — /agents overlay

The TUI ships /agents (alias /tasks) as a first-class audit surface: live tree of running and recently finished subagents, per-branch cost/token/file rollups, kill and pause controls, post-hoc turn-by-turn replay. A docked agents panel above the composer merges live in-turn subagents with background/async rows; ^a opens the full tree.

Phase-2 TUI work (PR #70899) added @subagent_id message routing in the composer when the token resolves to a live child — ordinary prompts like email @john later fall through untouched.

CLI and messaging gateways

On the classic CLI and every gateway platform (Telegram, Discord, Slack), /agents prints background delegations with live per-child activity — API call counts, current tool, seconds since last activity. A child the stall monitor flagged shows as stalling · no progress 450s — interrupting; long-quiet but healthy children show quiet time so you can distinguish slow from stuck.

This is manual control for operators who run Hermes headless on a VPS with Telegram: you do not need Desktop to see that two of three research children are still in web_search.

What people are asking

"Is this just the parent agent steering, or can I intervene directly?"

Both. The parent model orchestrates via delegate_task actions. You orchestrate via Desktop Steer/Stop, TUI /agents, @id steering, or subagent.steer RPC. Session scoping applies: the gateway rejects steering from a foreign session identity — knowing a global subagent id is not authority.

"How is this different from Bot Mode?"

Bot Mode is persistent named bots with group chats and bot-to-bot messaging — a social layer for multi-agent work. Manual subagent control is the supervision layer for ephemeral delegate_task children inside a session. You might run Bot Mode for your standing research bot and still use /agents to steer three parallel subagents that bot spawned for a one-off audit.

"Can I steer from Telegram while Desktop spawned the children?"

Only from the owning session that spawned them. If delegation started in Desktop, steer from Desktop (or attach another client to the same live gateway session — programmatic integration docs note multi-client attach shares streaming but keeps submit exclusivity). A Telegram message to a different gateway session cannot steer Desktop's children.

"Does steering work on every model?"

Steering relies on the trusted out-of-band marker in the system prompt. Models hardened against injection initially refused steers delivered inside tool results; Nous fixed the common case. Exotic or heavily fine-tuned models may still behave inconsistently — if a steer misses, check for missed_steer in the completion and re-issue as a new delegated task with corrected context.

"What should I delegate now that I can supervise?"

The top Hermes workflows guide lists parallel research as a high-value pattern — three subagents, one per competitor, orchestrator synthesizes. Manual control makes that pattern production-viable: watch child 2 drift, steer it back to pricing, stop child 3 early when you have enough signal. Same for multi-file refactors where one child handles tests while another edits source — kill a stuck terminal worker without aborting siblings.

Configuration knobs worth knowing

Defaults moved in Pantheon. Relevant ~/.hermes/config.yaml entries:

delegation:
  max_concurrent_children: 10   # v0.21 default; floor 1, no hard ceiling
  max_iterations: 250           # per child; lower for cheap tasks
  child_timeout_seconds: 0      # 0 = no wall-clock cap (default)
  model: "google/gemini-flash-2.0"  # optional cheaper worker model
  provider: "openrouter"

Cost strategy: pin a frontier model for the parent session and an inexpensive model for all children — the parent decomposes; children burn volume. delegate_task has no per-task model parameter in the global pin (kanban tasks support per-task overrides per docs).

Stall detection: background delegations use progress-based monitoring (450s idle / 1200s in-tool thresholds) — distinct from optional hard child_timeout_seconds. The /agents output surfaces both.

Not durable: top-level delegation remains tied to the owning session. Session closure, /stop, /new, or process restart can cancel in-progress work — use cronjob for scheduled durability.

Comparison: Hermes manual control vs other orchestration stacks

Hermes's bet is operator visibility on local hardware — relevant if you are running NVIDIA PAIR clusters with Hermes Desktop or routing through OpenRouter's top-ranked agent traffic. Cursor Projects bets on months-long coordinator memory inside the IDE. Neither replaces the other; they overlap on "don't fire-and-forget parallel agents."

For harness design background, see what is an agent harness and Goal Mode for completion-gated long runs.

Actionable workflow: supervised parallel research

Copy-paste starting point — adapt goals to your project:

1. Enable web + terminal tools on the parent before delegating (children inherit parent's toolsets; they cannot grant themselves new capabilities).

2. Ask the parent to delegate with explicit context (subagents know nothing except goal + context):

Delegate three parallel research tasks: (A) competitor pricing pages updated in 2026, (B) recent HN/Reddit sentiment, (C) official docs changelog. Pass full context per child — URLs, output format, what "done" means.

3. Open /agents or the Desktop Subagents frame within the first minute. If child B is scraping forums instead of official docs, steer:

Steer sa-0-xxxx: "Stop forum scraping. Only primary sources and official changelogs."

4. Stop early if sufficient: when A and C return enough signal, stop B rather than waiting for iteration cap.

5. Review costs in the delegation result — Pantheon surfaces per-delegation spend so you can tune delegation.model downward for the next batch.

Honest limitations (September 2026)

• Queued steering has latency. You steer at tool boundaries, not instantaneously — a child mid-long-terminal-command will not see guidance until that command finishes.
• Session-bound, not global. Manual control is scoped to the spawning session; multi-device steering requires attaching to the correct gateway session.
• Docker sandbox sharing. Parallel subagents share one persistent Docker container by default — concurrent cd and writes can collide; use worktree isolation or per-task env overrides for conflicting edits.
• Documentation lagged the release. Core shipped Pantheon August 31; operator docs and Desktop framing consolidated in early September — verify behavior against your installed tag (hermes --version / hermes update).
• Not a replacement for kanban/cron. Long-horizon task boards and scheduled jobs are separate primitives also expanded in v0.21 — manual control supervises live children, not queued kanban cards waiting for dispatch.

Closing

Manual subagent control is the feature that makes Hermes delegation trustworthy at scale: list running children, steer a drifted worker, stop another and keep partial results, watch stall state from Telegram or Desktop. It shipped in v0.21.0 Pantheon and is documented for operators as of September 2026 — the same week Cursor launched Projects for month-long coordinator memory. Hermes answers a different question: what are my subagents doing right now, and can I fix one without restarting the batch?

If you have not tried delegation since pre-Pantheon Hermes, rerun a parallel research task with /agents open — the supervision surface is the product change, not a minor changelog line.

Related on explainx.ai

• Nous Research Bot Mode — multi-agent teams in Hermes Desktop
• Top 10 things you can do with Hermes Agent
• Hermes Agent vs OpenClaw comparison
• Hermes Agent remote VPS + Telegram + CLI guide
• Hermes hits #1 on OpenRouter
• NVIDIA PAIR + Hermes Desktop on RTX Spark
• Cursor Projects — persistent coordinator agents (Sept 2026)
• What is an agent harness?

Sources

• Hermes v0.21.0 Pantheon release notes (August 31, 2026)
• Hermes v0.21.1 patch (September 7, 2026)
• Subagent Delegation — Nous Research docs
• Desktop App — Live subagents — Nous Research docs
• TUI — /agents overlay — Nous Research docs

Release tags, default delegation limits, and UI labels reflect Nous Research's Hermes Agent documentation and GitHub releases as of September 11, 2026. Run hermes update and verify against hermes-agent.nousresearch.com/docs before relying on specifics in production workflows.