Yes, Hermes Agent subagents are built in. The delegate_task tool lets your main Hermes agent spawn child agents, each with its own fresh conversation and its own terminal session, and only their final summary comes back to the parent. You hand off the heavy lifting, your main chat stays clean, and several jobs run at the same time.
📺 Watch: Hermes Subagents Can Do the Work for You
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
Below: how a subagent gets spawned, what it can and can't touch, the depth and concurrency limits, how background runs work, and when it's worth delegating at all.
How Hermes Agent subagents work
When the parent calls delegate_task, Hermes creates a new child agent. Per the Hermes docs, the child gets isolated context, inherits the parent's tool access and gets its own terminal. It works on its own. When it finishes, only its summary enters the parent's context. All the intermediate tool calls stay out of your main window.
You can delegate one job or a batch. A single task takes a goal and a context. A batch is a list of tasks that run in parallel. In my video on Hermes turning one agent into a team, one command split into five workers that produced five pieces of content in the background while I kept working.
Here's the rule that trips people up. Subagents know nothing. The docs put it in a warning box: a child starts with a completely fresh conversation and zero knowledge of what you and the parent discussed. Its only context is the goal and context fields the parent writes. "Fix the error" fails. "Fix the TypeError on line 47 of api/handlers.py, here's why it happens" works.
There's one exception. If the parent has a workspace directory, every subagent's system prompt includes that project's context files, in the same priority order the main agent uses: .hermes.md, then AGENTS.md, then CLAUDE.md, then .cursorrules. SOUL.md is left out. So children working in a repo follow its conventions without being told.
I run Hermes daily inside my Agent OS. If you want the exact setup, with a profile per model, the AI Profit Boardroom ($69/mo) includes the Agent OS, a 30-day AI agent roadmap, daily tutorials as new tools drop, 4 coaching calls a week and the prompt library, with 3,400+ members.
Isolation: what a subagent can and can't do
Children inherit the parent's enabled toolsets. There's no toolsets parameter, so the model can't hand a child powers the parent doesn't have. They also inherit the parent's API key, provider setup and credential pool, which helps with key rotation on rate limits.
Some tools are blocked for subagents even when the parent has them:
- delegate_task for leaf children, so they can't spawn more agents by default
- clarify, because subagents can't talk to you
- memory, so no writes to shared persistent memory
- send_message, so no cross-platform side effects
- cronjob, so no scheduling work in the parent's name
Both roles keep execute_code, so a child can batch mechanical steps in a script instead of burning reasoning turns.
Files are the other risk. By default children share the parent's working directory. That's fine for research. For parallel coding, set delegation.worktree_isolation to true. Each child then works in its own git worktree under .worktrees in the repo, on its own branch, and the parent reviews or merges each branch after. It only works with git repos on the local terminal backend. Elsewhere it quietly falls back to the shared folder.
📺 Watch: How to Rank #1 with Hermes AI SEO Subagents!
Depth and concurrency limits
Delegation is flat by default. The parent spawns children, and children can't delegate further. That stops runaway recursion.
For bigger jobs, a parent can spawn a child with role set to orchestrator. That child keeps delegate_task and can run its own workers. But it only works if you raise delegation.max_spawn_depth from its default of 1. Set it to 2 and orchestrators can spawn leaf grandchildren. Set delegation.orchestrator_enabled to false and every child is forced back to a leaf.
Concurrency is set by delegation.max_concurrent_children, or the DELEGATION_MAX_CONCURRENT_CHILDREN environment variable. The delegation docs list 10 parallel children by default, with a floor of 1 and no hard ceiling. A batch bigger than the limit returns an error instead of being cut short.
Watch the multiplication. The docs give the example that depth 3 with 3 children per level can reach 27 leaf agents running at once. Every extra level multiplies spend.
| Setting | Default | What it controls |
|---|---|---|
| max_spawn_depth | 1 (flat) | How many levels of subagents can exist |
| max_concurrent_children | 10 per the delegation docs | Parallel children per batch |
| max_iterations | 250 | Tool-calling turns each child gets |
| oneshot_max_children | 2 | Total subagents in a hermes chat -q one-shot run |
| child_timeout_seconds | 0 (off) | Optional inactivity cap, minimum 30 seconds |
| worktree_isolation | false | Separate git worktree per child |
Not sure how many workers your workflow really needs? Book a free AI strategy session and we'll work it out.
📺 Watch: New Hermes Subagents Update is INSANE!
Asynchronous subagents and background runs
This is the part I like most. Top-level delegate_task calls run in the background automatically. Hermes hands back a handle straight away, your chat keeps moving, and the result arrives later as a new message. No frozen screen while a worker grinds. I covered this in my video on Hermes subagents doing the work for you, where parallel content and onboarding builds ran while I carried on.
A few details from the docs worth knowing:
- One message per batch. By default a batch returns one combined message when every task is done. Set delegation.independent_completions to true and results land as each one finishes.
- Orchestrators wait. An orchestrator child waits for its own workers so it can combine their results before reporting back.
- No stopwatch. There's no wall-clock timeout by default. A stall monitor catches children that stop making progress: 450 seconds idle, or 1200 seconds inside a tool.
- Stopping. A follow-up message won't cancel background children. /stop, the Stop button, or closing the session will. Stopped children still return their partial output.
- Process-local. Completions are saved so they survive a restart, but a running child doesn't resume after a crash. For work that must outlive the session, the docs point you to cron jobs or a background terminal command.
You can also steer a child mid-task. The parent uses delegate_task's list, steer and stop actions. You can do it yourself too: /agents in the TUI, Ctrl+T in the classic CLI, or the Subagents panel in Desktop. Steering is queued and lands at the child's next checkpoint, so you redirect without throwing away its work.
To see a live dashboard of all this, my Hermes Workspace guide walks through the visual side.
When to use subagents (and when not to)
The Hermes guide on delegation lists good candidates:
- Reasoning-heavy subtasks like debugging, code review and research synthesis
- Jobs that would flood your main context with junk data
- Parallel independent workstreams, say researching topic A and topic B at once
- Tasks where you want a fresh, unbiased take
Skip delegation for a single tool call, quick file edits, or anything needing your input, since subagents can't ask questions. For mechanical multi-step work, execute_code is cheaper: it returns only the script's output instead of running a full model loop.
One more built-in worth knowing: /review spawns a background reviewer subagent that checks the work your conversation just produced, like a PR or a diff.
Want a second pair of eyes on which parts of your work should go to subagents? Grab a free AI strategy session.
Routing each subagent to a different model
By default every child runs on the parent's model, or on one model you pin for all of them. The new official advanced-delegation plugin lets the agent pick a named model or a Hermes profile per task. Full walkthrough in Hermes advanced delegation, and the model choice itself in Hermes subagent model.
For which models hold up on real agent work, see Goldie Bench. And the Agent OS guide shows where subagents sit in a full system.
FAQ
Does Hermes Agent have subagents?
Yes. The delegate_task tool spawns child agents with isolated context and their own terminal. It's built into Hermes, no plugin needed.
Can a subagent spawn its own subagents?
Only if you allow it. Give the child role orchestrator and raise delegation.max_spawn_depth to 2 or more. At the default of 1, delegation stays flat.
Do subagents see my chat history?
No. They only get the goal and context the parent writes, plus the project's context files like AGENTS.md. Put everything they need in the call.
Will my chat freeze while subagents run?
No. Top-level delegation runs in the background. You get a handle right away and the result comes back as a new message.
Want subagents doing real work for your business this week? Join the AI Profit Boardroom for the Agent OS and tutorials, or grab a free AI strategy session and we'll map your first delegation workflow.
