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

For makers and developers using AI agents, the workflow has finally caught up with the promise of delegation. The latest update to Hermes Agent means you can offload heavy processing to child agents without freezing your main session. Previously, spawning subagents halted the parent chat until every task finished. Now, delegated work runs in the background, allowing you to continue drafting, coding, or thinking while the agents crunch the numbers.

What Are Subagents?

At its core, the delegation mechanism, known as delegate_task, spawns isolated child agents. Each child operates in its own sandbox, maintaining a separate conversation history, terminal session, and toolset.

The architecture is designed to preserve the parent agent’s efficiency. Only the final summary of the work returns to the main thread. Intermediate steps, reasoning, or tool calls remain hidden from the parent’s context window, keeping it lean and responsive.

Isolation is absolute. A subagent begins with a blank slate, unaware of the parent’s prior interactions. The parent must explicitly pass necessary information via the goal and context parameters.

Despite this separation, subagents inherit the parent’s API keys and credential pool. This setup supports key rotation when rate limits are hit and allows users to route specific subagents to cheaper models by configuring config.yaml.

What Was Blocking, and What Changed

In the original implementation, delegate_task was strictly synchronous. The parent process would pause, waiting inside the tool call until every child agent completed its duties. This design effectively froze the chat interface during the wait time.

This rigidity limited several practical workflows. Users could not initiate a long-running agent and immediately return to productive work. Nor could they check progress or steer a task mid-execution.

Nous Research has addressed this by opening the non-blocking path. Issue #5586 introduces an async_delegation toolset. This change spawns a background agent and returns a task_id instantly, unfreezing the chat for immediate use.

The new asynchronous tools cover the entire lifecycle of a task:

• delegate_task_async, Spawns a background agent and returns a task_id immediately.
• check_task, Retrieves non-blocking status and recent output.
• steer_task, Injects new instructions into a running task.
• collect_task, Blocks execution only until the task is complete, then returns the full result.
• cancel_task, Terminates a running task.
• list_tasks, Displays all active async tasks within the current session.

These background agents operate as in-process threads, reusing the same AIAgent machinery, credentials, and toolsets as the synchronous delegation.

Synchronous vs Asynchronous Delegation

The shift from synchronous to asynchronous changes how users interact with multi-agent workflows. The table below outlines the practical differences:

Code: Spawning and Steering

In the synchronous model, a batch spawns children in parallel but waits for completion. This concurrency is capped by delegation.max_concurrent_children, which defaults to three.

# Synchronous: the parent waits for all children
delegate_task(tasks=[
    {"goal": "Research topic A", "toolsets": ["web"]},
    {"goal": "Fix the build",   "toolsets": ["terminal", "file"]},
])

Conversely, the async toolset introduced in issue #5586 returns control to the user immediately.

# 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

The flexibility of asynchronous subagents opens up several practical scenarios for developers:

• Long research alongside work. Launch a subagent to scan a market while you continue drafting content in the main chat.
• Parallel approach evaluation. Spawn three subagents to test different search backends simultaneously. Because they are isolated, evaluations remain distinct and do not cross-contaminate.
• Background coding tasks. Delegate a multi-file refactor to a subagent. You can review other parts of the codebase or write new features while the refactor runs.
• Monitoring runs. The terminal user interface (TUI) includes an /agents overlay (aliased as /tasks), displaying a live tree of running and finished subagents.

Key takeaways

• Hermes Agent now supports asynchronous subagents, ensuring the delegate tool no longer blocks the parent chat.
• Non-blocking delegation is implemented via the async_delegation toolset, tracked in GitHub issue #5586.
• The async suite covers the full lifecycle: spawn, check, steer, collect, cancel, and list tasks.
• Subagents remain strictly isolated; only the final summary returns to the parent, preserving a small context window.
• The feature runs in-process and within a single session; existing users can enable it by running hermes update.