Hermes Agent subagents are child agents that the main Hermes agent spawns with delegate_task, and my verdict is that they're one of the strongest features in Hermes right now.

Hermes Agent is the free, open-source agent from Nous Research, and subagents are built into it.

Each child gets a fresh conversation, its own terminal session and the parent's tools, and only its final summary goes back to the parent.

This review scores 12 subagent features one by one, using Nous's own documentation, and it ends with the weaknesses the docs admit.

I've made two videos on subagents, but I haven't lab-tested every feature below, so each score is my judgement of what the documented feature does.

Hermes Agent Subagents: The Scorecard

Here are all 12 scores up front.

# Feature What it does Score
1 Background delegation Top-level delegations return a handle and post results back later. 9/10
2 Parallel batches One call runs a list of tasks side by side. 9/10
3 Fresh context with project files Children start clean but read AGENTS.md and similar files. 8/10
4 Structured output output_schema makes children return validated JSON. 9/10
5 Image forwarding Up to 8 images can be passed to a child. 8/10
6 Independent completions Results can land per task or per group. 7/10
7 Live monitor, steer and stop You can watch and redirect workers mid-task. 9/10
8 Live transcripts Every task writes a readable log you can tail. 8/10
9 Nested orchestration Orchestrator children can spawn their own workers. 7/10
10 Worktree isolation Each child edits code on its own git branch. 9/10
11 The /review reviewer An independent subagent checks finished work. 9/10
12 Timeouts and failure reporting Stuck or failed children are always reported. 8/10

My overall rating for Hermes Agent subagents is 4.5 out of 5.

🔥 Want my exact Hermes Agent Subagents Reviewed setup, step by step? Inside the AI Profit Boardroom you get step-by-step video trainings, my installable Agent OS and four coaching calls a week with 3,400+ members building real automations. → Join the AI Profit Boardroom

What Hermes Agent Subagents Are

The docs describe delegate_task as a tool that spawns child agent 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.

The parent agent decides when to delegate, and the docs say it does so automatically based on task complexity.

You can still ask for delegation in plain language when you know a job splits cleanly.

1. Background Delegation (9/10)

Top-level delegations run in the background automatically.

Hermes returns a handle immediately, so the conversation can continue, and the result posts back as a new message.

Completions are stored in the profile's state.db before delivery, so a result that finished before a restart is restored and delivered.

It loses a point because a running child is not resumed after a Hermes restart, and its attempt is recorded as unknown.

2. Parallel Batches (9/10)

A tasks list runs several subagents at once.

The delegation page says up to 10 run concurrently by default, while the configuration reference's example shows 3, and delegation.max_concurrent_children sets the real number.

A batch larger than the limit returns a tool error instead of being silently cut, which I rate highly.

In the CLI, a tree view shows each child's tool calls live with per-task completion lines.

3. Fresh Context With Project Files (8/10)

The docs warn that subagents know nothing about the parent's conversation.

Their only context is the goal and context the parent writes.

The exception is project context, because children read .hermes.md, the AGENTS.md chain, CLAUDE.md and .cursorrules from the parent's workspace.

I score it 8 because the isolation keeps the parent clean, but it puts all the pressure on the brief.

4. Structured Output (9/10)

Each task can carry an output_schema, which is a JSON Schema the child's answer must match.

The parent validates the answer and sends one correction turn with the exact errors if it fails.

A miss after that still keeps the child's work, with schema_valid: false and the raw text, so an hour of work isn't thrown away.

That is a thoughtful design, and it makes cheaper worker models far safer for structured jobs.

5. Image Forwarding (8/10)

A task's images list takes up to 8 local paths, web links or data URLs.

A vision-capable child sees the images directly, while a non-vision child gets path hints and is told to use vision_analyze.

The docs say forwarding is best-effort and can never break a spawn.

It scores 8 because it's useful for design and layout checks, though it depends on the child model's vision support.

6. Independent Completions (7/10)

By default, a batch returns one consolidated message after every task finishes.

Setting delegation.independent_completions: true makes results land per task, and a shared group string brings related tasks back together.

The docs say it's off by default because a 15-task call can become up to 15 wake-ups for the orchestrator.

I score it 7 because it's handy for long campaigns, but it needs a new session after you change it.

🔥 Want my Hermes subagent setups, explained on video? Inside the AI Profit Boardroom, I've got Hermes Agent training, the Agent OS and walkthroughs on delegation, steering and models. You'll be learning alongside 3,400+ members with four coaching calls every week. → Get access here

7. Live Monitor, Steer And Stop (9/10)

This is the feature my second video covers, with the CLI and Desktop controls and three real builds.

In the classic CLI, Ctrl+T or F6 opens a live roster, and the TUI has /agents with per-branch cost and token rollups.

Desktop shows a Subagents frame above the composer with Steer and Stop for each worker.

The parent agent can also use delegate_task itself with list, steer and stop actions on its own children.

Steering is queued and lands at the child's next iteration boundary, and a steer that arrives too late is reported as missed_steer.

It scores 9 because the honesty about delivery is as good as the control itself.

8. Live Transcripts (8/10)

Every dispatch writes one readable log per task under <hermes_home>/cache/delegation/live/<delegation_id>/task-<n>.log.

The paths come back in the dispatch response, and you can tail -f them while the child works.

The logs show assistant text, tool calls and results, and they're pruned after 7 days.

It scores 8 because it's a genuine audit trail, though it lives in files rather than a dashboard.

9. Nested Orchestration (7/10)

By default delegation is flat, so children can't delegate further.

A parent can spawn a child with role="orchestrator", which can then spawn its own workers, but only once delegation.max_spawn_depth is raised from its default of 1.

The docs warn that depth 3 with 3 children per level can reach 27 concurrent leaf agents.

I score it 7 because it's powerful but needs deliberate setup, and the delegation page and the configuration reference describe the depth ceiling differently.

10. Worktree Isolation (9/10)

delegation.worktree_isolation: true gives each child its own git worktree and branch, hermes-subagent/subagent-<id>.

The parent's checkout stays untouched, and a worktree with no commits is pruned automatically.

If an inspection fails, the worktree is kept with inspection_failed: true rather than deleted.

It scores 9, losing a point because it only works for git repos on the local terminal backend.

11. The /review Reviewer (9/10)

Typing /review spawns an independent, full-privilege background subagent that reviews the work your conversation just produced.

It starts from the last 10 messages, gets the full subagent toolset and actually opens the PR or runs the code.

By default it uses your main model, and auxiliary.review pins a different reviewer model.

It scores 9 because it's the most practical everyday use of subagents I've seen.

12. Timeouts And Failure Reporting (8/10)

There is no wall-clock timeout by default, which the docs explain was a deliberate change after hard caps kept killing busy children.

Instead, a child with no progress for 450 seconds, or 1,200 seconds inside a tool, is interrupted and reported as a timeout.

delegation.child_timeout_seconds adds an optional inactivity cap if you want one.

Failures are never silent, because the CLI prints a one-line reason, gateway chats get a notice and the parent gets status: "failed".

It scores 8 because the reporting is excellent, though the stall thresholds are long for impatient users.

What Subagents Are Blocked From Doing

Leaf subagents can't call delegate_task, clarify, memory, send_message or cronjob.

Orchestrator children keep delegate_task but keep the other blocks, and both roles keep execute_code.

Children inherit the parent's enabled toolsets, and the model can't widen them per call.

I see these blocks as a strength, because a subagent can't message a client or schedule work in your name.

The Subagent Model Question

By default, subagents use the parent's model, provider, key and credential pool.

The docs recommend a frontier planner with inexpensive workers, and a single delegation.model pin does that.

With the default strategy that pin covers every child in a batch, so mixed batches need the advanced-delegation plugin or kanban.

My verdicts on those options are on the Hermes subagent model and Hermes advanced delegation pages.

Strengths And Weaknesses

These are the strengths.

  • Delegations run in the background, in parallel, without blocking your chat.
  • Structured output, image forwarding and worktree isolation make the results usable.
  • Live steering and stopping work across the CLI, the TUI, Desktop and the parent agent itself.
  • Failures, timeouts and missed steers are always reported.

These are the weaknesses.

  • Subagents depend completely on the brief the parent writes.
  • One model covers the whole batch unless you add a plugin.
  • Running children aren't resumed after a restart.
  • Nested orchestration needs config changes and can get expensive fast.

If you'd like a second opinion on how agents fit your SEO business, you can book a free SEO strategy session with my team.

🔥 Want help using Hermes subagents on real work? The AI Profit Boardroom has the Agent OS, Hermes training and four weekly coaching calls where you can ask me how to brief and limit your subagents. → Join the AI Profit Boardroom

Related Reading

Also On Our Network

FAQ: Hermes Agent Subagents

Are Hermes Agent subagents any good?

Yes, because they combine background batches, live steering, structured output, worktree isolation and clear failure reporting.

What is the biggest weakness of Hermes subagents?

They know nothing except the brief the parent writes, and one model covers the whole batch by default.

How many subagents can Hermes run in parallel?

The delegation docs say up to 10 by default, and delegation.max_concurrent_children changes it.

Can Hermes subagents run forever?

No, because a child with no progress for 450 seconds, or 1,200 seconds inside a tool, is interrupted, and each child has a 250-turn limit by default.

Are Hermes subagents free?

The feature is free, but each subagent uses tokens from your model provider.

If you run an agency and want help planning agent work for clients, you can book a free strategy session with my team.

📺 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 70+ people in Bangkok.
  • I've grown a YouTube channel to 400,000+ subscribers.
  • I wrote the book "Link Building Mastery", which covers nine link building strategies.
  • I run GoldieBench, where I score AI models on real one-shot builds.

→ Get my best AI training inside the AI Profit Boardroom

Brief them well, watch them live and isolate their edits, and Hermes Agent subagents earn their 4.5 out of 5.