Hermes Agent Adds Asynchronous Subagents, So Delegated Work No Longer Blocks the Parent Chat

Nous Research has shipped a change to Hermes Agent. Its delegate tool can now run subagents asynchronously. Per the announcement, delegated work no longer blocks the parent chat.

Hermes Agent is an open-source personal agent from Nous Research. A parent agent can spawn child agents, called subagents, to fan out work. Until now, that delegation made you wait.

The update was announced on X by Nous Research and co-founder Teknium. Existing users enable it by running hermes update.

Hermes Agent now supports asyncronous subagents!

The existing delegate tool, which your agent uses to spawn subagents to fan out and do work, no longer blocks your chat!

To access now, hermes update, and enjoy! pic.twitter.com/6hN94wpRLW

— Teknium (@Teknium) June 15, 2026

What are Subagents

The delegation tool is delegate_task. It spawns a subagent, which is an isolated child agent. Each child gets its own conversation, terminal session, and toolset.

Only the final summary returns to the parent. The parent’s context never sees the child’s intermediate tool calls or reasoning. That keeps the parent’s context window small.

Isolation is strict. Subagents start with a completely fresh conversation. They have no knowledge of the parent’s history. The parent must pass everything through the goal and context fields.

Subagents inherit the parent’s API key, provider configuration, and credential pool. That credential pool enables key rotation on rate limits. You can route subagents to a cheaper model through config.yaml.

What Was Blocking, and What Changed

In source, delegate_task is synchronous. The parent blocks inside the tool call until every child completes. Your chat stays frozen during that wait.

That design prevented several workflows. You could not start a long agent and keep working. You could not check in on a run or steer it mid-flight.

Nous built the non-blocking path in the open. Issue #5586 adds an async_delegation toolset. It spawns a background agent and returns a task_id immediately. The announcement confirms async subagents are now available.

The async tools cover the full lifecycle:

delegate_task_async — spawn a background agent, return a task_id

check_task — non-blocking status plus recent output

steer_task — inject a message into a running task

collect_task — block until done, then return the full result

cancel_task — stop a running task

list_tasks — all async tasks in the session

Background agents run as in-process threads. They reuse the same AIAgent machinery, credentials, and toolsets as delegate_task.

Synchronous vs Asynchronous Delegation

DimensionSynchronous delegate_taskAsynchronous delegation (async_delegation, #5586)

Parent chatBlocks until all children finishReturns a task_id immediately; chat stays free

Control while runningNone — you waitCheck status, steer, collect, or cancel per task

ExecutionParent waits inside the tool callBackground in-process threads

Context costOnly the final summary returnsOnly the final summary returns

IsolationFresh conversation per childFresh conversation per child

Best forQuick fan-out you wait onLong tasks you run alongside the chat

DurabilityNot durable across turnsSingle-session; ACP (#4949) targets cross-turn

resize listener:

============================================================ -->

Code: Spawning and Steering

A synchronous batch spawns children in parallel and waits. Concurrency is capped by delegation.max_concurrent_children, which defaults to 3.

Copy CodeCopiedUse a different Browser

Synchronous: the parent waits for all children

delegate_task(tasks=[ {"goal": "Research topic A", "toolsets": ["web"]}, {"goal": "Fix the build", "toolsets": ["terminal", "file"]}, ])

The async toolset from issue #5586 returns control immediately.

Copy CodeCopiedUse a different Browser

Asynchronous (async_delegation toolset, issue #5586)

t1 = delegate_task_async(goal="Research topic A") t2 = delegate_task_async(goal="Research topic B")

check_task(t1["task_id"]) # status, without blocking steer_task(t2["task_id"], "Use post-2024 sources only") results = [collect_task(t["task_id"]) for t in (t1, t2)]

Use Cases With Examples

Long research alongside work. Start a subagent on a market scan. Keep drafting in the main chat while it runs.

Parallel approach evaluation. Spawn three subagents to test three search backends. Each stays isolated, so evaluations do not cross-contaminate.

Background coding tasks. Delegate a multi-file refactor to a subagent. Review other files yourself while it works.

Monitoring runs. The TUI ships an /agents overlay, aliased /tasks. It shows a live tree of running and finished subagents.

Key Takeaways

Hermes Agent now supports asynchronous subagents; the delegate tool no longer blocks the parent chat.

Non-blocking delegation ships via the async_delegation toolset, tracked in issue #5586.

Async tools cover the lifecycle: spawn, check, steer, collect, cancel, and list tasks.

Subagents stay isolated; only the final summary returns, keeping the parent context small.

It runs in-process and single-session; existing users enable it with hermes update.

Sources

Teknium on X — announcement of asynchronous subagents: https://x.com/Teknium/status/2066619275989991861

Nous Research on X: https://x.com/NousResearch/status/2066619860852134384

Hermes Agent docs, Subagent Delegation: https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation

Hermes Agent docs, Delegation & Parallel Work: https://hermes-agent.nousresearch.com/docs/guides/delegation-patterns

GitHub issue #5586, non-blocking background agent delegation (async_delegation toolset): https://github.com/NousResearch/hermes-agent/issues/5586

GitHub issue #4949, persistent ACP background subagents (referenced in #5586)

NousResearch/hermes-agent repository: https://github.com/NousResearch/hermes-agent

The post Hermes Agent Adds Asynchronous Subagents, So Delegated Work No Longer Blocks the Parent Chat appeared first on MarkTechPost.