Hermes delegation is how one Hermes agent hands a job to a fresh child agent and gets back only the finished summary.
The tool behind it is delegate_task, and it now runs in the background by default: you get a handle straight away and the result lands later as a new message.
This is the setup I'd run, step by step, from the version check to the /delegation change that shipped in v0.22.6 on 2 November 2026.
If you'd rather have my team wire agents into your business for you, book a free SEO strategy session and we'll map it out on the call.
What A Delegated Task Actually Gets
Each child is a separate AIAgent instance with its own conversation, its own terminal session and the parent's enabled toolsets.
Only its final summary goes back into the parent's context, so twenty tool calls of digging never flood your main chat.
The Subagent Delegation docs are blunt about the catch: the child knows nothing about your conversation.
Its only briefing is the goal and context you pass in the call.
One exception helps in repos: when the parent has a resolved workspace, every child's system prompt embeds the project context files, in the order .hermes.md, the AGENTS.md chain, CLAUDE.md, then .cursorrules.
SOUL.md is left out of that.
Step 1: Update To v0.22.6 Before You Touch Config
The behaviour in this guide matches the v0.22.6 release, dated 2 November 2026.
It's a patch release that rolls up about 776 merged PRs since v0.22.5.
Update the CLI with one command:
hermes updateDocker users pull nousresearch/hermes-agent:stable (or :latest), and the Microsoft Store app updates through the Store.
The Desktop app from the .exe or .dmg installer doesn't change in this release; it picks this up with the next bundled release.
Step 2: Brief The Child Like It Just Walked In
A vague goal is the number one way to waste a subagent.
The docs' own bad example is delegate_task(goal="Fix the error"), and the child has no idea which error.
Give it the file, the line, the symptom, the project path and the runtime:
delegate_task(
goal="Fix the TypeError in api/handlers.py",
context="""The file api/handlers.py has a TypeError on line 47:
'NoneType' object has no attribute 'get'.
The project is at /home/user/myproject and uses Python 3.11."""
)For visual work, each task also takes an images list of up to 8 entries: local paths, http(s) URLs or data:image/... URLs.
A vision-capable child model sees the pixels on its first turn; a non-vision one gets path hints and is told to use vision_analyze.
Step 3: Fan Out A Batch And Set The Ceiling Yourself
Pass a tasks array and Hermes runs the children in parallel behind one background handle.
delegate_task(tasks=[
{"goal": "Research topic A", "context": "Focus on recent primary sources"},
{"goal": "Research topic B", "context": "Compare the leading explanations"},
{"goal": "Fix the build", "context": "Project root: /home/user/project"}
])Here's the gotcha: the docs disagree on the default concurrency.
The delegation page says up to 10 concurrent subagents, while the configuration reference shows max_concurrent_children: 3.
Don't guess which one your build uses.
Set it in ~/.hermes/config.yaml and the question goes away:
delegation:
max_concurrent_children: 5You can also set it with the DELEGATION_MAX_CONCURRENT_CHILDREN env var.
A batch longer than the cap comes back as a tool error, never a silent truncation, so you'll know when you've overshot.
By default the whole batch returns as one consolidated message.
Set delegation.independent_completions: true if you want each task, or each group, to report as it finishes, then start a new session so the tool schema picks it up.
🔥 Want a delegation setup that's already wired and tested?
Inside the AI Profit Boardroom you get step-by-step video trainings, the installable Agent OS with Hermes inside, four coaching calls a week and 3,400+ members comparing how they split work across subagents.
→ Join the AI Profit Boardroom
Step 4: Put Workers On A Cheaper Model
The docs make the cost case plainly: decomposing a problem needs frontier judgement, but executing a well-specified subtask usually doesn't.
The children are where most of the tokens go in a parallel run, so that's where the model choice matters.
Keep the planner on your main model and pin the workers:
model:
default: "your-frontier-model"
delegation:
model: "your-inexpensive-model"
provider: "openrouter"Resolution runs in a fixed order: delegation.base_url wins, then delegation.provider, and with neither set the children inherit the parent's provider and credentials.
delegation.model applies on every branch, and if it's empty the children inherit the parent's model too.
In Desktop the same keys sit under Settings → Model → Subagents, scoped to the profile in Applies to, and nothing changes until you click Apply.
Step 5: Lock The Answer Shape With output_schema
Free-text summaries are fine for research and painful for automation.
Add an output_schema to a task and the child is told to return only JSON that validates against it.
If the first answer fails, the parent sends exactly one correction turn with the validation errors.
A second miss doesn't throw the work away: the result keeps status: completed, the raw text in summary, schema_valid: false, the schema_errors and a schema_note.
Keep the schema loose and require only the fields you'll actually read.
Step 6: Give Parallel Coders Their Own Worktrees
Two children editing the same repo can step on each other.
Turn on isolation:
delegation:
worktree_isolation: trueEach child then works in <repo>/.worktrees/subagent-<id> on the branch hermes-subagent/subagent-<id>.
Its result gains a worktree field with path, branch, commits and dirty, and you merge what you want.
A worktree with no commits and a clean tree is pruned for you.
It's opt-in, git-only and local-backend-only; on Docker, SSH or Modal it quietly falls back to the shared directory.
Step 7: Watch, Steer And Stop Without Killing The Batch
In the classic CLI, Ctrl+T or F6 opens the live roster; s steers a worker and x then y asks it to stop.
In the TUI, /agents (alias /tasks) opens the tree, and Desktop has a Subagents panel with Steer and Stop.
Every dispatch also writes a readable log per task:
tail -f ~/.hermes/cache/delegation/live/deleg_ab12cd34/task-0.logA manifest.json sits next to the logs, and directories older than 7 days are pruned on new dispatches.
Steering is queued, not instant: the child reads it at its next iteration boundary.
If the child finished first, its result carries missed_steer and a note saying the steer didn't land.
Ctrl+C, Esc and the Stop button end your turn, not a top-level background batch.
Use /stop to end the background children; each one returns status="interrupted" with its partial output.
Pick A Backend: default, model_map Or profile_routes
delegation.backend decides how each task becomes a subagent.
default is everything above: one global worker model for the whole batch.
The official advanced-delegation plugin adds two more strategies plus hermes delegation config and the /delegation slash command.
model_map gives the model named options like fast and deep, each with a description and a provider/model.
profile_routes hands each child to one of your Hermes profiles, so it works with the model, credentials, skills and persona set on that profile.
While either one is active, delegation.model and delegation.provider stop applying, because the routes decide.
Install the plugin from the catalog with hermes plugins install advanced-delegation; its README says it needs Hermes 0.22.5 or newer.
I covered the plugin's install and route editor in depth in the Hermes advanced delegation setup, so here's just the hand-written shape:
delegation:
backend: model_map
backends:
model_map:
options:
- name: fast
description: Cheap and quick; lookups, summaries, simple edits.
provider: openrouter
model: google/gemini-3-flash-preview
- name: deep
description: Slow and careful; hard debugging and design work.
provider: anthropic
model: claude-opus-5
reasoning_effort: high
default: fastThe model only ever sees the names and descriptions, never the provider, model or key fields.
Read The route Field On Every Result
A backend-routed task reports route on its result.
That covers the backend, the option or profile name, and the provider, model, reasoning effort and speed tier the child actually ran on.
If a fallback provider took over, you'll see fallback_activated: true.
Failures are explicit, never a silent switch.
A missing or disabled backend makes delegate_task return a tool error naming the backend and the fix, and no child starts.
A single bad task in a batch, say an unknown option or a profile that doesn't exist, comes back alone with status: "error" and route.refused: true while the rest run.
The v0.22.6 Change: /delegation Choices Now Stick
This is the bit that changed in the 2 November release, listed in the notes as "/delegation choices saved for the next session".
The commit behind it removed the old session-only override, which switched routing but not the cached tool schema.
Now a switch is saved:
/delegation default
/delegation model_map --now/delegation default writes delegation.backend to config.yaml and applies from the next session, so run /new.
A chat that's already running stays on its original backend, since the option or profile names the model sees sit in the cached tool list.
Add --now (/delegation <backend> --now) and the tools for this chat get rebuilt on its next turn; the price is a single prompt-cache miss.
Context compression rebuilds the tools anyway, so it picks up the saved backend too.
Send a parameter the chat's backend doesn't accept and the task is refused; the message tells you which backend, which parameter and how to fix it.
Without the plugin installed, reset it by hand:
hermes config set delegation.backend default📞 Want agents doing the grunt work while your team handles clients? Book a free SEO strategy session and my team will show you where AI agents and SEO fit your business. → Get your free strategy session
Limits That Will Bite You
Each child gets 250 iterations by default; lower delegation.max_iterations for fleets of simple tasks.
A child that runs out returns exit_reason: max_iterations and truncated: true.
There's no wall-clock timeout by default, but a heartbeat monitor interrupts a child frozen for 450 seconds between turns or 1,200 seconds inside a tool.
Children can't call clarify, memory, send_message or cronjob, and leaf children can't call delegate_task.
Nesting needs two things: role="orchestrator" on the call and delegation.max_spawn_depth raised to 2.
A one-shot run (hermes chat -q) may spawn only 2 children in total by default, set by delegation.oneshot_max_children.
Background children aren't durable execution: a Hermes restart doesn't resume a running child, and its attempt is recorded as unknown.
When Not To Delegate
The delegation patterns guide lists the cases where something else wins.
A single tool call: just call the tool.
Mechanical multi-step work: use execute_code, which returns only stdout and costs far less than a full reasoning loop.
Anything that needs to ask the user a question: children can't use clarify.
Work that must survive a restart belongs in a cron job, and my Hermes cron job walkthrough shows that setup.
And always check a child's claim before you trust it: if it says the tests pass, run the tests.
Want the full Agent OS build with Hermes already set up? Join the AI Profit Boardroom.
Also On Our Network
- 🌐 The business case for subagents, with three use cases and the credential risk
- 🌐 A nine-criterion scorecard for subagents, including where the docs disagree
- 🌐 Five copy-paste prompts that set up subagents inside your Agent OS
- 🌐 Which models to put in the planner and worker seats, with GoldieBench scores
- 🌐 The complete Hermes delegation guide on the AI Profit Boardroom blog
FAQ: Hermes Delegation
How many subagents can Hermes run at once?
The delegation page says 10 by default and the configuration reference shows 3. Set delegation.max_concurrent_children yourself; there's a floor of 1 and an oversized batch returns a tool error.
Does a subagent see my chat history?
No. It starts with a fresh conversation and sees only the goal and context you pass, plus the workspace's project context files such as AGENTS.md.
What does /delegation default do after v0.22.6?
It saves delegation.backend to config.yaml and applies from the next session, so run /new. Add --now to a backend switch to rebuild the current chat's tools at its next turn.
How do I see which model a routed child used?
Read the route field on its result. It names the backend, the option or profile, and the provider, model, reasoning effort and speed tier the child ran on.
Will Ctrl+C cancel a background batch?
No. Ctrl+C, Esc and the Stop button end only your turn. Use /stop, or close or reset the session, to end the background children.
📺 Video notes + links to the tools 👉
🎥 Learn how I make these videos 👉
🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉
About Julian
I'm Julian Goldie, an SEO entrepreneur, author and founder of the AI Profit Boardroom, which has 3,400+ members.
I help business owners scale with AI agents, automation and SEO.
- I've built a 7-figure SEO and link building agency, Goldie Agency, with a team of 70+ SEO experts.
- I've grown a YouTube channel to 400,000+ subscribers.
- I wrote "Link Building Mastery".
- My Udemy courses have taught over 29,000 students.
→ Get my best AI training inside the AI Profit Boardroom
Update to v0.22.6, set max_concurrent_children yourself, pin a cheaper worker model, and if you want my team to plan the rest, book a free strategy session and bring your Hermes delegation config.
