Hermes Advanced Delegation: What It Is, How To Set It Up, And Which Models To Route To

Hermes advanced delegation is an official Nous Research plugin that lets Hermes Agent route each subagent task to a named model or to one of your Hermes profiles.

It adds two modes to the delegate_task tool, called model routes and profile routes, next to the built-in default.

The official plugin page says it needs Hermes 0.22.5 or newer, the first release with pluggable delegation providers.

It is free, and it fixes the main limit of built-in delegation, where every subagent in a batch shares one model.

I'm Julian Goldie, and in this post I'll explain what the plugin does, how to set it up and how it fails, and then I'll show which benchmarked models belong in each route.

The Hermes facts here come from Nous's plugin page, docs and release notes, not from a lab test of every route.

Hermes advanced delegation at a glance

This table sums up the plugin before we go into detail.

What is Hermes advanced delegation?

Hermes Agent's main agent spawns subagents with delegate_task.

With the built-in default, every subagent runs on delegation.model and delegation.provider, or on the parent's model.

The delegation docs say that pin is global, because the default strategy has no per-task model parameter.

The plugin registers two delegation providers that change that.

Model routes give each task a choice of named model routes that you define.

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

Hermes core still runs the whole subagent lifecycle, including spawning, isolation, limits, background runs and results.

For the basics of subagents, see my sibling post on Hermes Agent subagents.

The problem the plugin solves

The delegation docs say a parallel batch of subagents typically burns the large majority of a run's tokens.

With one model per batch, a mix of easy and hard tasks either overpays on the easy ones or underpowers the hard one.

Model routes let the easy tasks pick a cheap route while the hard task picks a strong one.

Profile routes let specialist profiles, such as a coder and a researcher, each take the tasks that suit them.

The v0.22.5 release on GitHub, published on 23 October 2026, lists pluggable delegation backends that route subagents by model map or profile.

How to set up Hermes advanced delegation

First, update to Hermes 0.22.5 or newer, because the plugin page says 0.22.0 to 0.22.4 refuses to install or enable it.

Then install and configure it with the commands from the plugin page.

hermes plugins install advanced-delegation
hermes delegation config          # pick the mode, then edit its routes
hermes delegation config --show   # print the current mode and routes (no terminal needed)

Desktop users can click Install plugin under Settings → Model → Subagents instead.

Plugins install per profile, so install it in the profile that delegates, while target profiles only need to exist with a working model.

The model routes editor uses hermes model's own pickers and validates each route before saving it.

The profile routes editor is a checklist of your other profiles, an optional description each and a default.

Model routes, configured by hand

This is the full model routes example from the plugin page.

delegation:
  backend: model_map
  backends:
    model_map:
      options:
        - name: fast                     # what the agent picks
          description: "Cheap and quick: lookups, summaries, simple edits."
          provider: openrouter           # provider and/or base_url, plus model
          model: google/gemini-3-flash-preview
        - name: deep
          description: "Slow and careful: hard debugging and design work."
          provider: anthropic
          model: claude-opus-5
          reasoning_effort: high
          service_tier: fast             # optional speed tier: normal, fast or ultrafast
        - name: local
          description: "Private: runs on this machine."
          base_url: http://localhost:8080/v1
          model: qwen3-coder
      default: fast                      # optional: route for tasks that pick none

Each route needs name, description and model, plus provider or base_url.

Optional keys are reasoning_effort, service_tier, fallback_providers, api_key and api_mode.

A speed tier the route doesn't offer, or an unknown reasoning effort, refuses the spawn with a tool error.

The page recommends provider: over api_key:, because a key written here sits in config.yaml in plain text.

Profile routes and the security catch

Profile routes are a list under delegation.backends.profile_routes.profiles, with a name and description for each profile and an optional default.

That list is also an allowlist, so a profile you don't list can never be picked.

A profile route runs the subagent exactly as if you'd started hermes -p with that profile for the task.

The plugin page warns that a listed profile's credentials, credential pool, SOUL.md and terminal policy become usable by the delegating profile's subagents.

Only list profiles whose keys and terminal access you're happy to share.

Switching modes with /delegation

/delegation shows the current mode and a picker, with buttons on Telegram, Discord and Slack. /delegation model_map saves model routes for the next session, and /delegation default switches back.

Changes apply from the next session, because the tool list is part of the prompt cache.

Adding --now rebuilds the current chat's tools at your next message, at the cost of one prompt-cache break.

How routed tasks behave and fail

Each task item gains one property, option for model routes or profile for profile routes, limited to your route names.

A task that picks nothing runs on the mode's default, or on the parent's model if there's no default.

While either route mode is active, delegation.model and delegation.provider aren't used.

If the backend is missing or disabled, delegate_task returns a tool error naming the fix, and no subagent starts.

A task that can't be routed is refused on its own with route.refused: true, while the rest of the batch runs.

A model route without its own fallback_providers uses delegation.fallback_providers, and a profile route uses that profile's chain.

Each result's route field shows the provider, model, reasoning effort and speed tier the child actually ran on.

Model routes vs profile routes

Both modes route work per task, but they suit different setups.

I'd start with model routes, because they need nothing beyond the profile you already use.

Profile routes become worth it once you've built specialist profiles, such as a coder with coding skills and a researcher with research skills.

Each mode keeps its own settings, so you can try one and switch back without losing the other.

Who Hermes advanced delegation is for

It suits anyone whose subagent batches mix quick lookups with hard reasoning or build work.

It suits agencies that want private client work on a local route while public research uses a cloud route.

It suits teams that already run several Hermes profiles and want the main agent to hand work between them.

It isn't needed if your agent rarely delegates, because a single delegation.model pin is simpler.

It also isn't a replacement for the kanban board when work must survive a restart, because kanban tasks are durable and subagents aren't.

Tips and limits

Route descriptions are the only thing the agent reads, so write them as clear instructions about when to pick each route.

Start with two model routes, such as fast and deep, before you add more.

Watch the first routed batch live, which my video at the top shows how to do, and check the route each task chose.

The plugin doesn't make subagents durable, so a Hermes restart still doesn't resume a running child.

My video on the Hermes 0.22 release, embedded below the post, covers the release line this plugin sits on.

Hermes advanced delegation: which models to route to

The plugin doesn't ship a model, so every route is only as good as the model you put behind it.

GoldieBench scores models on real one-shot builds, and these are current averages from the live board.

The plugin page's fast-route example, google/gemini-3-flash-preview, isn't on the board, so I won't guess its score.

Its local-route example, qwen3-coder, isn't on the board either.

GoldieBench measures one-shot builds, so a fast route doing summaries can use a lower-scoring model than a route that builds pages or tools.

A sensible starting pair is a fast route on a Flash-class model and a deep route on a top model such as Claude Opus 5 at 8.27.

For private work, my local models page shows what runs on your own hardware.

For the single-pin alternative, see my Hermes subagent model explainer, and for the wider shortlist see my best Hermes Agent model explainer.

Verdict

Hermes advanced delegation is the right upgrade once your subagent batches mix easy and hard work, and model routes are the place to start.

Put a top model from the live board behind your deep route, a fast model behind your fast route, and only list profiles you trust in profile routes.

Also On Our Network

• Agent Operatorsthe five-step Hermes advanced delegation install guide
• AI Income Deskfive ways a business uses Hermes advanced delegation
• AI Tool Verdictmodel routes versus profile routes, scored with a verdict
• agentos.guidewhether Hermes advanced delegation belongs in your Agent OS
• agentos.guidethe Hermes kanban guide on agentos.guide

If you run an agency and want a clear plan for putting agents to work on client SEO, you can book a free strategy session with my team.

If you'd like help choosing which models go behind your routes, you can also claim a free SEO strategy session and we'll look at it together.

Pick a strong deep route, a fast cheap route and trusted profiles, and you'll get the most out of Hermes advanced delegation.