Issue Station
Sign In
Tools hereToolbox

hermes - 💡(How to fix) Fix delegate_task blocks agent during wait — breaks coordinator pattern [1 participants]

Official PRs (…)
ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
NousResearch/hermes-agent#11508•Fetched 2026-04-18 06:00:39
View on GitHub
Comments
0
Participants
1
Timeline
0
Reactions
0
Author
AppleLV918AppleLV918
Participants
AppleLV918AppleLV918
RAW_BUFFERClick to expand / collapse

The delegate_task tool is synchronous-only. When an agent calls it, the agent is blocked until the sub-agent completes. This breaks the coordinator pattern — a core use case where an agent acts as a task router:

1. Coordinator receives a task from user
2. Coordinator delegates to sub-agent(s)
3. Coordinator immediately returns to **available state** — ready to receive new messages from user
4. User can send follow-up instructions while sub-agents work
5. Sub-agents complete → coordinator reports back

Currently, step 3 is impossible. While the coordinator waits on `delegate_task`, user messages are blocked. This makes the coordinator unusable for real multi-task workflows.

## Proposed Solution

Add `async_mode=True` to `delegate_task`:
- Returns immediately with a `task_id`
- Sub-agent runs in background
- Coordinator stays free to receive messages
- Backwards compatible (sync remains default)

## Alternative

Add `busy_input_mode: queue` — messages during busy state are queued and delivered when agent is free.

## Why This Matters

Without a coordinator pattern, every task must be handled in a single conversation turn. For task routing, delegation, and cross-session continuity, this is a fundamental limitation.
```

extent analysis

TL;DR

To enable the coordinator pattern, consider adding an asynchronous mode to the delegate_task tool, allowing it to return immediately and keep the coordinator available for new messages.

Guidance

  • Evaluate the proposed solution of adding async_mode=True to delegate_task to enable asynchronous delegation and assess its compatibility with existing workflows.
  • Consider the alternative approach of implementing busy_input_mode: queue to handle messages during the busy state, ensuring they are delivered when the agent is free.
  • Assess the impact of these changes on the overall system architecture and task routing functionality.
  • Test both solutions with real multi-task workflows to determine which best supports the coordinator pattern.

Example

No explicit code example is provided due to the lack of specific implementation details in the issue.

Notes

The choice between the proposed asynchronous mode and the alternative busy input mode queueing should be based on the specific requirements of the task routing system and the expected behavior of the coordinator pattern.

Recommendation

Apply the workaround by adding async_mode=True to delegate_task, as it directly addresses the synchronous limitation and enables the coordinator pattern without introducing additional complexity like message queuing.

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…
#orchestration issue#cache issue#memory leak#API versioning#request timeout

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING

hermes - 💡(How to fix) Fix delegate_task blocks agent during wait — breaks coordinator pattern [1 participants]