agentos.guide › blog

Hermes Agent Subagents: The Quick Start, And How They Fit Your Agent OS

By Julian Goldie · 27 October 2026 · agentos.guide

Hermes Agent subagents are child agents that the main Hermes agent spawns with the delegate_task tool, so one job can be split into parts that run in parallel.

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

Each worker gets a fresh conversation, its own terminal and the parent's tools, and only its summary comes back.

This page is the quick start, plus how I'd fit subagents into each part of an Agent OS.

The Hermes Agent subagents quick start

This is the shortest path to your first useful subagent run inside an Agent OS.

The rest of this page explains how subagents work and how I'd fit them into each part of an Agent OS.

What Hermes Agent subagents are

The official delegation docs describe delegate_task as a tool that spawns child agents with isolated context, inherited tool access and their own terminal sessions.

Each child gets a fresh conversation, works independently and returns only its final summary to the parent.

Top-level delegations run in the background automatically, so Hermes returns a handle and you can keep chatting.

When a child or batch finishes, the result arrives as a new message in the same chat.

The docs also say the agent delegates on its own when a task is complex enough, so you don't have to ask every time.

My first video above walks through exactly this async behaviour, with a lead agent splitting jobs out to workers.

How delegate_task works

A single task is one goal and one context.

A batch is a tasks list, and the docs give this example.

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

The parent writes these calls, not you, but knowing the shape helps you ask for good delegation.

By default a batch returns one consolidated message when every task is done.

Each task can also carry an output_schema for validated JSON and an images list of up to 8 pictures.

The child returns a structured summary of what it did, what it found, which files it changed and any problems it hit.

The one rule: subagents know nothing

The docs put this in a warning box, and it's the rule that decides whether subagents help or waste money.

A child starts with a completely fresh conversation and knows nothing about your chat, earlier tool calls or decisions.

Its 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 workspace.

So in an Agent OS, a good AGENTS.md in each project folder briefs every worker for free.

🔥 Want the exact Hermes Agent setup I run inside my Agent OS?

Inside the AI Profit Boardroom you get the installable Agent OS, step-by-step video tutorials, four coaching calls a week and 3,400+ members building real automations.

→ Get access here

Step 2: set the limits

These are the main keys, shown as the docs list them.

# In ~/.hermes/config.yaml
delegation:
  max_iterations: 250                       # Max turns per child (default: 250)
  # max_concurrent_children: 10             # Parallel children per batch (default: 10)
  # independent_completions: false          # true = each task/group returns as it finishes (default: one message per call)
  # worktree_isolation: false               # Give each child its own git worktree (see Worktree Isolation above)
  # max_spawn_depth: 1                      # Tree depth (floor 1, no ceiling, default 1 = flat). Raise to 2 to allow orchestrator children to spawn leaves; 3+ for deeper trees.
  # orchestrator_enabled: true              # Disable to force all children to leaf role.

The delegation page gives 10 as the default concurrency, while the configuration reference's example block shows 3, so I set the number explicitly.

A batch bigger than the cap returns an error instead of being silently cut short.

The docs warn that depth 3 with 3 children per level can reach 3×3×3 = 27 concurrent leaf agents, so raise max_spawn_depth deliberately.

One-shot runs such as hermes chat -q have their own cap, delegation.oneshot_max_children, which defaults to 2.

Step 4: watch, steer and stop

My second video shows the live controls with three builds: a roadmap page, an SEO ROI calculator and an audit landing page.

The docs list the controls for each surface.

Steering is queued, so a worker reads your guidance at its next checkpoint and an in-flight tool call is never cut.

If a worker finishes before the steer lands, its result carries missed_steer so you know to re-send it.

Stopping a worker keeps its partial output, and a follow-up message never cancels a background batch, though /stop does.

Every task also writes a readable log under ~/.hermes/cache/delegation/live/ that you can tail -f.

🔥 Want the exact Hermes Agent setup I run inside my Agent OS?

Inside the AI Profit Boardroom you get the installable Agent OS, step-by-step video tutorials, four coaching calls a week and 3,400+ members building real automations.

→ Get access here

How subagents fit an Agent OS workflow

My Agent OS runs Hermes alongside other agents, and subagents are how one Hermes profile does several jobs at once.

This is how I'd map common Agent OS jobs to subagent settings.

If you want the board-based version of this, where named profiles pick up durable tasks, my Hermes kanban guide covers it.

For the model each worker runs on, see my best Hermes Agent model guide.

What subagents can't do

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

That means they can't ask you questions, write to shared memory, message anyone or schedule work in your name.

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

Both leaf and orchestrator children keep execute_code, so they can batch mechanical work.

Timeouts, failures and restarts

There is no wall-clock timeout by default.

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, with a floor of 30 seconds.

A failed child is never silent, because the parent gets status: "failed" with the error and gateway chats get a notice.

A Hermes restart doesn't resume a running child, so the docs point to cronjob for work that must survive a restart.

Worktree isolation for code work

By default, subagents share the parent's working folder, which is fine for research but risky when several workers edit one repo.

Setting delegation.worktree_isolation: true gives each child its own git worktree at <repo>/.worktrees/subagent-<id> on its own branch.

The parent's checkout stays untouched, and each result reports the worktree path, the branch, the commits and whether it's dirty.

A worktree with no commits and a clean tree is pruned automatically, while anything holding work is kept.

The docs say it's opt-in, git-only and local-backend-only, and it quietly falls back to the shared folder elsewhere.

In an Agent OS, I'd switch it on for every coding profile before the first parallel build.

Delegation or execute_code?

The docs give a clear rule of thumb.

Use delegate_task when a subtask needs reasoning, judgment or multi-step problem solving.

Use execute_code for mechanical data processing, because it returns only stdout and costs far fewer tokens.

Tips before you rely on subagents

• Start with one small batch and watch it live before you hand over anything important.
• Write the brief as if the worker has never seen your project, because it hasn't.
• Pin a cheaper subagent model once the volume grows, since workers use most of a run's tokens.
• Switch on worktree isolation before two workers touch the same repo.
• Run /review on anything that goes to a client.
• Put agents that run shell commands behind a sandboxed backend.

If you want to talk through where subagents fit your SEO business, you can book a free SEO strategy session with my team.

FAQ

What are Hermes Agent subagents?

They are child agents the main Hermes agent spawns with delegate_task. Each gets a fresh conversation, its own terminal session and the parent's tools, and only its final summary returns to the parent.

Does Hermes delegate automatically?

Yes. The docs say the agent handles delegation automatically based on task complexity, although you can also ask for it directly.

How many subagents can run at once?

The delegation docs say up to 10 by default, configurable with delegation.max_concurrent_children, and an oversized batch returns an error instead of being truncated.

Do subagents know what we discussed?

No. They start with a fresh conversation and only know the goal and context the parent writes, plus project files such as AGENTS.md.

Can I steer a running subagent?

Yes. Use Ctrl+T or F6 in the classic CLI, /agents in the TUI or the Subagents frame in Desktop, and steering lands at the child's next checkpoint.

What can't subagents do?

Leaf subagents can't use delegate_task, clarify, memory, send_message or cronjob, so they can't message anyone, ask you questions or schedule work.

Final word on Hermes Agent subagents

Set the limits, write full briefs, watch the first batch live and switch on isolation for code work.

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

If you want the whole Agent OS with the Hermes tab, the profiles and the training already set up, it lives inside the AI Profit Boardroom, with 3,400+ members and four coaching calls a week.

That is how I'd get real work out of Hermes Agent subagents.

Related guides on agentos.guide

→ The Hermes Swarm System

→ Hermes Kanban: The Self-Driving Board

→ The Best Hermes Agent Model

→ Hermes Agent v0.22: The Quick Start

📺 Video notes + links to the tools 👉

🎥 Learn how I make these videos 👉

🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉

← all guides on agentos.guide