Agent Team Delegation
What it is
A workflow pattern where a coordinator breaks work into specialist agent tasks.
In plain terms
A general contractor rarely rewires a house or replumbs a bathroom personally — they bring in an electrician for one job and a plumber for another, hand each their own scope of work, and sign off on the finished result without needing a running commentary of how they got there. Agent Team Delegation is Hermes working the same way: a coordinator session splits a job into pieces and lets separate subagents handle each piece in their own workspace, reporting a finished summary instead of a narrated process.
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 own toolset minus a fixed set of tools that are always stripped out — there’s no per-call argument letting the coordinator hand-pick a narrower toolset itself (tools/delegate_tool.py). A single call can launch one subagent with a goal and supporting context, or a batch array that runs several at once, up to a configurable concurrency limit. Both shapes now run in the background: delegate_task returns immediately, and each child’s full result re-enters the coordinator’s conversation as a new message whenever it finishes, rather than the coordinator waiting idle. By default a child is a ‘leaf’ that cannot itself call delegate_task, clarify, memory, send_message, or execute_code; setting role=‘orchestrator’ lets it spawn its own workers instead, bounded by a configurable maximum nesting depth. Either way, the coordinator’s context only ever sees the dispatch call and the final summary — never a subagent’s intermediate tool calls.
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.
- Each subagent finishes independently and its full write-up lands back in the conversation as a new message.
- The developer sees two clean summaries — root cause and reproduction test — without ever seeing either subagent’s intermediate debugging steps.
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/toolsets.py#<file>— Structural Source Map fallback for toolsets.py. A core source file in the Tool Registry and Toolsets 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