Agent Team Delegation
What it is
A workflow pattern where a coordinator breaks work into specialist agent tasks.
In plain terms
A general contractor can send an electrician and plumber out together, but one combined work order is not two separate inbox updates: the contractor receives the joined report when the whole order is complete. Hermes behaves the same way. One batch runs several specialists together and reports once at the end; separate top-level delegations report separately. Their conversations are isolated, but their project files are shared, so each specialist still needs a non-overlapping scope.
Why it matters
A single agent isn’t always the right shape for a task, and agent team delegation is what happens when a coordinator session breaks the work into pieces and hands each to a specialist subagent before assembling whatever comes back. This is the pattern behind moving from one agent doing everything sequentially to something closer to a small team, where a research subagent, a coding subagent, and a verification subagent can each stay focused on their own slice. Standard operating procedures matter more here than in single-agent work, since a subagent picking up a handoff needs explicit enough instructions to not require the coordinator’s full context.
How it works
delegate_task spawns one or more child AIAgent instances, each with a fresh conversation, its own terminal session, and the coordinator’s inherited toolsets minus a fixed blocked set — there is no model-facing per-call argument for choosing child toolsets or max iterations (tools/delegate_tool.py). A top-level model call launches either one task or one concurrent batch in the background, so the coordinator can keep chatting. A single task returns one later completion message; a batch is one background unit and returns one consolidated message only after every child finishes. Separate top-level calls produce separate completion messages. A child called by an orchestrator subagent runs synchronously so that orchestrator can use the result in its own turn; stateless HTTP delivery and a full background pool also fall back to synchronous execution. A child defaults to role=‘leaf’ and cannot call delegate_task, clarify, memory, send_message, execute_code, or cronjob; role=‘orchestrator’ permits nested workers within configured depth. Children have separate conversations and terminal task IDs, but they are not filesystem sandboxes and can touch the same project files, so parallel write scopes must not overlap.
A concrete example
A developer asks Hermes to fix a bug and needs both a root-cause investigation and a written test that reproduces it, without wanting to babysit either.
- Hermes calls delegate_task in batch mode with two tasks: one subagent gets ‘find why the login endpoint returns 500 for expired tokens,’ the other gets ‘write a failing test that reproduces a 500 on expired-token login.’
- Both subagents start work immediately in their own terminal sessions; the coordinator keeps chatting with the developer about something else in the meantime.
- Hermes waits until both batch tasks finish, then posts one consolidated completion message containing both summaries.
- If the developer instead wants each result to arrive as soon as it is ready, the coordinator makes two separate top-level delegate_task calls rather than one batch call.
How it connects
This note belongs to the Workflow Patterns family. Its closest neighboring concepts are: Kanban Execution, Personal OS, Agent Runtime.
Source evidence
vendor/hermes-agent/tools/delegate_tool.py#<file>— Structural Source Map fallback for tools/delegate_tool.py. A core source file in the Tools, Toolsets, and MCP — Other Core Files structure within Tools, Toolsets, and MCP.
Workflows
- Kanban Agent Execution
- Agent Team Delegation
Related articles
- Mastering Hermes Desktop: From Local Chat App to an Always-On Agent Control Center
- Ten Hermes Workflows That Turn a Chatbot into a 24/7 Assistant
- Ten Underused Hermes Features That Reveal Its Real Power
- How to Use Hermes Better Than Most People: Architecture, Project Isolation, and Scalable Workflows