agentos.guide › blog

Hermes Subagent Model: The Quick Start, And How To Set Worker Models In Your Agent OS

By Julian Goldie · 27 October 2026 · agentos.guide

The Hermes subagent model is the AI model Hermes Agent's child agents run on when the main agent hands work out with delegate_task.

Hermes Agent is the free, open-source agent from Nous Research, and by default its subagents simply reuse the main agent's model.

You change that with one setting, delegation.model, and it is one of the easiest cost wins in an Agent OS.

This page is the quick start, plus how I'd set a worker model for each profile.

The Hermes subagent model quick start

This is the shortest path from the default setup to a deliberate subagent model inside your Agent OS.

The rest of this page explains each step and then shows how I'd set worker models per profile.

What the Hermes subagent model is

When the main Hermes agent calls delegate_task, it spawns child agents that each get a fresh conversation, their own terminal session and the parent's enabled tools.

The subagent model is the brain inside those children.

The official delegation docs say that if you don't set one, subagents use the same model as the parent.

They also inherit the parent's API key, provider configuration and credential pool, which keeps key rotation working on rate limits.

That default is safe, but the same docs say a parallel batch of subagents typically burns the large majority of a run's total tokens.

So in an Agent OS that delegates a lot, the worker model is where most of the spend sits.

Step 1 and 2: check the default and keep a strong planner

Open ~/.hermes/config.yaml and look at the delegation: block.

If model and provider are empty, your subagents inherit the main model.

The hermes model picker shows the same thing as "auto / inherit main agent" on its delegation row.

Keep your main agent on the strongest model you can justify, because the docs say decomposing a problem into well-specified subtasks takes frontier-level judgment.

Step 3: pin one cheaper model for every subagent

Nous calls this pattern frontier planner, inexpensive workers, and the docs give it in exactly this form.

# ~/.hermes/config.yaml
model:
  default: "your-frontier-model"     # parent (planner) stays on the frontier model
delegation:
  model: "your-inexpensive-model"    # all delegate_task children run on this
  provider: "openrouter"             # optional: route children to a different provider

Setting only model keeps the parent's credentials and changes just the model name.

Adding provider makes Hermes resolve that provider's full credential bundle, including the base URL and key.

The configuration reference gives the precedence as delegation.base_url, then delegation.provider, then the parent's provider.

🔥 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 4: set it without touching YAML

In the terminal, run hermes model, choose Configure auxiliary models and pick the delegation entry.

The docs say that entry writes to delegation.provider and delegation.model, and it ends with a reasoning-effort step saved as delegation.reasoning_effort.

In Hermes Desktop, open Settings → Model → Subagents, choose the profile under Applies to, pick a provider and model and click Apply.

That page also sets the subagent turn limit, concurrency, timeout and reasoning effort.

The docs say a Desktop change affects only subagents launched after you click Apply, and it never changes the main model or a running child.

Step 5: add a fallback chain for pinned workers

The configuration reference says a child pinned by provider, endpoint or model only falls back when you declare delegation.fallback_providers.

Without that list, a pinned child fails loudly instead of borrowing the parent agent's route.

An unpinned child still inherits the parent's chain, and fallback_providers: [] disables child fallback.

When a child fails, the parent receives status: "failed" with the error text, so it can retry or re-route.

Step 6: one worker model per Agent OS profile

My Agent OS runs Hermes as one of several agents, and separate jobs live in separate Hermes profiles.

Each profile has its own config, so each one can carry its own subagent model.

That is the simplest way to give a research desk cheap workers and a coding agent stronger ones without any plugin.

This is how I'd map common profiles.

Local workers through a direct endpoint

Sometimes the right subagent model is one that runs on your own hardware.

The docs show subagents pointed straight at an OpenAI-compatible endpoint.

delegation:
  model: "qwen2.5-coder"
  base_url: "http://localhost:1234/v1"
  api_key: "local-key"

A direct base_url takes precedence over delegation.provider, and Hermes auto-detects the Anthropic wire format for paths such as /anthropic.

If the guess is wrong, set delegation.api_mode to chat_completions, codex_responses or anthropic_messages.

A key written in config.yaml is stored in plain text, so use a named provider when you have one.

🔥 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

The other delegation settings that shape a worker

A few more keys in the same delegation: block change how the worker model behaves.

None of them are required, so I'd only add one when you hit the problem it solves.

The one I'd set early in an Agent OS is max_iterations on profiles that fire off lots of small tasks, because a lower cap stops a cheap worker wandering.

A child that runs out of turns comes back with exit_reason: max_iterations and truncated: true, so the parent can tell a budget stop from a finished job.

When one pin isn't enough

The docs admit the main limit plainly.

With the default strategy, delegate_task has no per-task model parameter, so every child in a batch runs on the same delegation model.

They list three ways round it.

• You can leave delegation.model unset for that session, so the children use your strong main model.
• You can install the official advanced-delegation plugin, which adds model routes and profile routes and needs Hermes 0.22.5 or newer.
• You can hand quality-sensitive work to the kanban board, which has a per-task model override with hermes kanban set-model.

Model routes are named options such as fast and deep, and the agent picks one per task by reading only the name and description.

Profile routes run a subagent as one of your Hermes profiles, with that profile's own model, credentials, skills and SOUL.md.

My Hermes kanban guide covers the board side of this.

How I'd roll it out in an Agent OS

Start with inherit while you learn how your agents delegate.

Watch a few real runs in the live subagent dock, which my second video above walks through with three builds.

Then pin a cheaper worker model on the profile that delegates the most, usually research.

Add a fallback chain before anything client-facing depends on it.

Only reach for routes once you see one batch mixing light and heavy tasks.

For the model shortlist itself, my best Hermes Agent model guide is the place to start.

The limits to know

• The default pin is global, so every child in a batch shares one model.
• Pinned workers don't fall back unless you declare a chain.
• A change in one profile doesn't touch any other profile.
• Subagents know nothing except the goal and context the parent writes, so a cheap model with a vague brief will disappoint.
• The /review reviewer runs on your main model unless you pin auxiliary.review.

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

FAQ

What model do Hermes subagents use by default?

They use the same model as the parent agent, along with the parent's API key, provider configuration and credential pool.

How do I set the Hermes subagent model?

Set delegation.model, and optionally delegation.provider, in ~/.hermes/config.yaml. You can also use hermes model → Configure auxiliary models → delegation, or Settings → Model → Subagents in Desktop.

Should subagents use a cheaper model?

Often yes. The docs recommend a frontier planner with inexpensive workers, because subagents typically burn most of a run's tokens while well-specified subtasks rarely need a frontier model.

Can each subagent use a different model?

Not with the default strategy. The official advanced-delegation plugin adds model routes and profile routes, and the kanban board has a per-task model override.

Can subagents run on a local model?

Yes. Set delegation.base_url to an OpenAI-compatible endpoint plus delegation.model, and the direct endpoint takes precedence over the provider.

Do pinned subagents fall back if the provider fails?

Only if you declare delegation.fallback_providers. Without it, a pinned child fails loudly instead of borrowing the parent's route.

Final word on the Hermes subagent model

Keep a strong planner, pin a cheaper worker model on the profile that delegates most, and add a fallback chain before clients depend on it.

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 value from the Hermes subagent model.

Related guides on agentos.guide

→ The Best Hermes Agent Model

→ Hermes Kanban: The Self-Driving Board

→ Hermes Agent v0.22: The Quick Start

→ The Hermes Swarm System

📺 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