The Hermes subagent model is the AI model Hermes Agent's child agents run on, and my verdict is simple: inherit while you learn, then pin a cheaper delegation.model once subagents do real volume.

Hermes Agent is the free, open-source agent from Nous Research, and its main agent spawns subagents with the delegate_task tool.

There are now several ways to decide which model those subagents use, from doing nothing at all to routing each task to its own model.

This page is the feature-by-feature reference, with a score for each option and the trade-offs Nous's own docs admit.

I haven't run a lab test of every option, so the scores are my judgement of what each one does on paper, based on the official documentation.

Hermes Subagent Model Options: The Scores

Here is the verdict on every option up front, so you can skip to the one you care about.

Option Setting Best for Score
Inherit the parent Leave delegation.model and delegation.provider empty Learning and small jobs 7/10
One global pin delegation.model plus optional delegation.provider Cutting cost on routine worker jobs 9/10
The hermes model picker Configure auxiliary models → delegation Setting the pin without editing YAML 8/10
The Desktop Subagents page Settings → Model → Subagents Desktop users managing several profiles 8/10
A direct endpoint delegation.base_url plus delegation.model Local or private models 8/10
A subagent fallback chain delegation.fallback_providers Keeping pinned workers alive in an outage 8/10
Model routes and profile routes The advanced-delegation plugin A different model per task 9/10
Kanban per-task override hermes kanban set-model Durable tasks that need one stronger model 7/10

My overall rating for how Hermes handles the subagent model is 4 out of 5.

The rest of the page explains each score.

🔥 Want my exact Hermes Subagent Model Options, Scored 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 The Hermes Subagent Model Is

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

The subagent model is the brain those children think with.

The 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, so key rotation on rate limits still works.

Nous's delegation page adds the number that makes this setting matter: a parallel batch of subagents typically burns the large majority of a run's total tokens.

For the bigger picture of what subagents do, read my sibling post on Hermes Agent subagents.

Option 1: Inherit The Parent Model (7/10)

This is the default, and you get it by doing nothing.

It scores well on safety, because the child uses a model you already trust with credentials that already work.

It loses points on cost, because every child summarising a page runs on your most expensive model.

My verdict is that inherit is the right starting point and the wrong long-term setting for heavy delegation.

Option 2: One Global delegation.model Pin (9/10)

This is the option I'd recommend to most people.

The docs give this exact pattern, under the heading frontier planner, inexpensive workers.

# ~/.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

The logic is the strongest part of this design.

Decomposing a problem takes frontier-level judgment, while executing a well-specified subtask usually doesn't.

Setting only model keeps the parent's credentials, and adding provider resolves that provider's full credential bundle.

It drops one point because the pin is global, so every child in a batch runs on the same model.

Option 3: The hermes model Picker (8/10)

Running hermes model and choosing Configure auxiliary models shows a delegation entry next to side tasks such as vision and compression.

The configuration reference says this entry writes to delegation.provider and delegation.model, not auxiliary.*, because subagents are full child agents.

The picker ends with a reasoning-effort step, stored as delegation.reasoning_effort.

It scores 8 because it removes YAML mistakes, but it does exactly what Option 2 does with an extra few clicks.

Option 4: The Desktop Subagents Page (8/10)

In Hermes Desktop, Settings → Model → Subagents sets the subagent provider and model plus the turn limit, concurrency, timeout and reasoning effort.

You pick the profile under Applies to, and nothing saves until you click Apply.

The page offers Inherit from main agent, Custom model (use parent credentials) and a provider plus model, and it shows an existing Direct endpoint override if you have one.

The docs say a change affects only subagents launched after Apply and never touches the main model or a running child.

It scores 8 because it is the friendliest route for anyone running several profiles, and the per-profile scope prevents accidental global changes.

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

Option 5: A Direct Endpoint For Local Models (8/10)

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.

Hermes auto-detects the Anthropic wire format for paths such as /anthropic, and delegation.api_mode overrides the guess when it's wrong.

It scores 8 because it makes private, local workers possible with three lines.

It loses points because a key written here sits in config.yaml in plain text, and if you skip api_key the reference says Hermes falls back to OPENAI_API_KEY only.

Option 6: A Subagent Fallback Chain (8/10)

This is the most important rule nobody reads.

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

Without it, the pinned child fails loudly instead of borrowing the parent's route.

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

I score it 8 because the strict behaviour is correct, since you never get a surprise bill from a silent switch, but it does mean one extra block of config for every serious setup.

Option 7: Model Routes And Profile Routes (9/10)

The default pin can't give two tasks in one batch two different models.

The official advanced-delegation plugin fixes that, and it needs Hermes 0.22.5 or newer.

Model routes let you define named options such as fast and deep, each with its own provider and model, and the agent picks one per task.

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

The agent only ever sees the route names and descriptions, never the raw provider, model or key.

Each result reports the route it ran on, including the provider, model, reasoning effort and speed tier.

It scores 9 because it is the most flexible option, and it drops a point because it's a plugin with its own setup step.

My full review is on the Hermes advanced delegation page.

Option 8: The Kanban Per-Task Model Override (7/10)

The delegation docs point to the kanban board for quality-sensitive tasks that need a stronger model.

Kanban tasks can pin their own model at creation or later.

hermes kanban set-model t_abcd claude-opus-4.6 --provider anthropic

The kanban docs say the override takes effect on the next dispatch, and hermes kanban set-model t_abcd none clears it.

It scores 7 because kanban is a different system with named profiles and durable tasks, so it's a heavier tool than a quick subagent.

The Settings Around The Model

A few other delegation keys shape how the subagent model behaves, and they deserve a quick verdict too.

Setting What it does Verdict
delegation.reasoning_effort It sets the effort level for subagent calls. It is useful for pushing cheap workers harder or easing off expensive ones.
delegation.request_overrides It sends extra request settings on every subagent call. It is handy for OpenRouter hints such as sort: throughput.
delegation.max_iterations It caps tool-calling turns per child, with 250 as the documented default. Lower it for fleets of simple tasks.
delegation.api_mode It forces the wire protocol for a direct endpoint. You only need it for endpoints the auto-detection can't classify.
auxiliary.review It pins a separate model for the /review reviewer subagent. It is a nice way to give reviews a stronger model than routine workers.

Strengths And Weaknesses

These are the strengths I'd point to.

  • The default is safe, because subagents inherit a model and credentials that already work.
  • The global pin is one or two lines, and the docs explain exactly why it saves money.
  • Local and private workers are supported through a direct endpoint.
  • Failures are explicit, because the parent gets status: "failed" with the error rather than a silent switch.

These are the weaknesses I'd flag.

  • With the default strategy, one pin covers every child in a batch.
  • Per-task models need a plugin or the kanban board.
  • Pinned children don't fall back unless you add a chain.
  • Each profile has its own config, so a change in one profile doesn't touch the others.

Which Model Should You Pin?

I'm not quoting prices, so check your provider's current pricing before deciding.

For research and summaries, a fast, inexpensive model is usually enough when the brief is clear.

For builds and coding, I'd pin a stronger coding model or use routes so only the build tasks get the expensive one.

For private data, a local model through base_url is the only option that keeps the work on your machine.

For named recommendations, see my best Hermes Agent model verdict, and for safe execution read my Hermes Agent sandbox review.

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 choosing models for your Hermes workers? The AI Profit Boardroom has the Agent OS, Hermes training and four weekly coaching calls where you can ask me which subagent model to pin. → Join the AI Profit Boardroom

Related Reading

Also On Our Network

FAQ: Hermes Subagent Model

What is the best Hermes subagent model setting?

For most people it is one inexpensive delegation.model pin while the main agent stays on a frontier model.

Is inheriting the parent model a bad choice?

No, because it is the safe default, and it only becomes wasteful when subagents do lots of simple work on an expensive model.

Can I choose a different Hermes subagent model per task?

Not with the default strategy, but the advanced-delegation plugin's routes and the kanban board's per-task override both allow it.

Do pinned subagents fall back to another provider?

Only if you declare delegation.fallback_providers, otherwise a pinned child fails loudly.

Does Hermes include its own subagent model?

No, because Hermes is the agent, and the subagent model is whichever provider and model you connect.

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

Inherit while you learn, pin a cheaper worker when the volume grows, add a fallback chain, and you'll have the best Hermes subagent model setup for your budget.