Hermes Agent Subagents: How delegate_task Spawns and Controls Them

Hermes Agent subagents are real: Hermes can split a big job into smaller pieces and hand each one to a child agent that works on its own, in parallel, then reports back. It does this through a built-in tool called delegate_task. In the video below I show how you can watch and control subagents live. Here’s how subagents actually work, the one mistake that ruins most delegations, and when you should (and shouldn’t) use them.

Does Hermes Agent have subagents?

Yes. According to the official Subagent Delegation docs, the delegate_task tool “spawns child AIAgent instances with isolated context, inherited tool access, and their own terminal sessions”. Each child gets a fresh conversation and works independently, and only its final summary enters the parent’s context.

That last part is the point. A big research job or refactor would normally flood your main conversation with tool output. With subagents, the messy work happens somewhere else and you get a clean summary back. You don’t even have to ask — the docs say the agent delegates automatically when a task is complex enough. You can also tell it directly: “Use a subagent for this.”

How delegate_task works

There are two ways to call it. A single task:

delegate_task(
    goal="Debug why tests fail",
    context="Error: assertion in test_foo.py line 42"
)

Or a parallel batch, where several subagents run at once:

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"}
])

Top-level delegations run in the background. Hermes returns a handle straight away so you can keep chatting, then posts the result back as a new message when the children finish. By default a batch comes back as one consolidated message; set delegation.independent_completions: true if you want each result as soon as it lands.

Each subagent also gets its own terminal session and inherits the parent’s enabled toolsets, API key, provider settings and credential pool. A task can even carry an output_schema, so the child must return JSON in the shape you need.

The fresh-context rule (the #1 mistake)

This is the part most people get wrong. Subagents know nothing about your conversation. They have zero knowledge of what you discussed, what tools ran or what files you looked at. The only context they get is the goal and context the parent writes into the call.

Here’s the bad versus good example straight from the docs:

# BAD - subagent has no idea what "the error" is
delegate_task(goal="Fix the error")

# GOOD - subagent has all context it needs
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."""
)

One helpful exception: if the parent has a workspace, each subagent’s system prompt includes that project’s context files (like AGENTS.md or CLAUDE.md), so it follows the repo’s rules without rediscovering them. You can also pass up to 8 images to a subagent when the job is visual.

Limits: parallel, depth and iterations

A batch bigger than the concurrency limit returns an error instead of being silently cut short. Some tools are blocked for subagents even if the parent has them: clarify (they can’t ask you questions), memory (no writes to shared memory), send_message and cronjob. Leaf subagents also can’t call delegate_task themselves.

Nested subagents: the orchestrator role

By default delegation is flat: your agent spawns children, and those children can’t spawn their own. For bigger workflows, a parent can spawn an orchestrator child with role="orchestrator", which can run its own workers.

This only works once you raise delegation.max_spawn_depth to 2 or more. And there’s a cost warning in the docs: with a depth of 3 and 3 children per level, the tree can reach 3×3×3 = 27 leaf agents running at once. Raise the depth on purpose, not by accident. You can switch nesting off entirely with orchestrator_enabled: false.

Watch, steer and stop subagents live

This is what my video above focuses on. You don’t have to wait blindly for results. The parent agent can manage its own children with the same tool:

{"action": "list"}
{"action": "steer", "subagent_id": "sa-0-1a2b3c4d", "message": "focus on pricing instead"}
{"action": "stop",  "subagent_id": "sa-0-1a2b3c4d"}

• CLI: press Ctrl+T (or F6) for the live roster; s to steer, x then y to stop.
• TUI: /agents shows a live tree with cost and token rollups.
• Desktop: expand Subagents above the composer and use Steer or Stop.

Every subagent also writes a live log you can tail under ~/.hermes/cache/delegation/live/. For more detail on redirecting a running child, see my Hermes subagent steering guide.

When to use subagents (and when not to)

The docs put it simply: use delegate_task when the subtask needs reasoning or judgment, and execute_code for mechanical data processing. Also remember that a background subagent doesn’t survive a Hermes restart — for work that must run no matter what, use a cron job. For running whole teams of agents, see my Hermes multi-agent guide.

Keep costs under control

Subagents are where the tokens go. A parallel batch usually burns most of a run’s total tokens. The easy win is to keep your main agent on a strong model and run the subagents on a cheaper one — I explain exactly how in my Hermes subagent model guide. If you want a different model per task, the new Hermes advanced delegation plugin lets the agent pick from named routes.

My verdict on Hermes Agent subagents

Subagents turn one Hermes into a small team: parallel research, clean context, live control and clear limits. Write full goals and context, start flat, and only add depth when you need it. Get that right and Hermes Agent subagents will do hours of work while you keep chatting.

About Julian Goldie

I’m Julian Goldie — founder of Goldie Agency and the AI Profit Boardroom. I test new AI agents almost every day for 432K+ YouTube subscribers and run Hermes, OpenClaw, OpenCode, Claude and Codex side by side in my own Agent OS. Claim your free strategy session or join the AI Profit Boardroom.

FAQ: hermes agent subagents

Does Hermes Agent support subagents?

Yes. Hermes spawns subagents with its built-in delegate_task tool. Each child gets a fresh conversation, its own terminal session and the parent’s tools, and only its final summary comes back.

How many subagents can Hermes run at once?

Up to 10 in parallel per batch by default. Change it with delegation.max_concurrent_children or the DELEGATION_MAX_CONCURRENT_CHILDREN environment variable.

Do subagents remember my conversation?

No. They start completely fresh. The parent must pass everything they need in the goal and context fields, though project files like AGENTS.md are included automatically.

Can a subagent spawn its own subagents?

Only orchestrator children can, and only after you raise delegation.max_spawn_depth above its default of 1.

How do I stop or redirect a subagent?

Use delegate_task with action list, steer or stop, press Ctrl+T in the CLI, use /agents in the TUI, or the Steer and Stop buttons in the Desktop app.

Related reading

• Hermes Subagent Steering
• Hermes Agent Multi-Agent
• Hermes Advanced Delegation

Last updated October 2026. This page is a living guide to hermes agent subagents — the facts here move fast and it is updated as they do.