01What Is Hermes Advanced Delegation and How Does It Work?

Hermes Advanced Delegation is a new plugin for Hermes Agent that lets your main agent pick a different model, or a whole different Hermes profile, for every single subagent it hands work to. It fixes one of the most expensive problems with AI agents: sending small jobs to a big, costly model.

Right now, when an agent hands work to a subagent, that subagent usually runs on one model. A click, a quick lookup, a file summary and a short writing job all go to the same big, expensive model. With Advanced Delegation, each job can go somewhere that fits it:

  • Cheap and fast for the simple stuff.
  • Slow and careful for the hard stuff.
  • Private and local for anything sensitive.

In this episode, Julian Goldie shows what the plugin does, how to set it up in about five minutes, and how he would use it inside a real agentic setup. The idea is simple. Your most expensive model stops doing boring work that a cheaper, smaller model could handle, and you keep control over where every task goes.

02The Three Modes: Default, Model Routes and Profile Routes

Advanced Delegation gives you three modes. You pick one at a time:

  • Default: how Hermes has always worked, with subagents on one model.
  • Model routes: a short list of named routes, each pointing at a model.
  • Profile routes: the main agent sends tasks to your other Hermes profiles.

Model routes are the one most people will use. Each route has a name, a one-line description and a model behind it. Nous Research gives a nice example in its docs:

  • A route called fast, described as cheap and quick, for lookups, summaries and simple edits. It can run something like a Gemini Flash model through OpenRouter.
  • A route called deep, described as slow and careful, for hard debugging and design work. It can run Claude Opus with high reasoning effort.
  • A route called local, which is private and points at a local model on your own machine.

Every time the main agent hands off a task, it reads those descriptions and picks the right route. The quick lookup goes to fast. The tricky bug goes to deep.

Private client data stays local.

03Built-In Safety: What the Agent Can and Cannot See

One detail Julian likes is how locked down the routes are. The agent only ever sees the route names and your one-line descriptions. It does not see model IDs, endpoints or API keys, and it can only pick from your list.

If the agent tries to pick a route that does not exist, Hermes refuses it before the subagent even starts. So the agent cannot make up a route, and it cannot wander off onto a model you did not approve. A few more controls help you stay in charge:

  • Default route: any task where the agent does not pick a route goes to your default, such as fast.
  • No default set: those tasks just run on the main agent's own model.
  • Clear reports: every result tells you which route it took, including the route name, provider, model and reasoning effort.
  • Provider choice: it works with OpenRouter, and you can add a custom route for any OpenAI-compatible endpoint, which is how a local route works.

Because each result shows where the work went, you can see exactly which model did what. That makes it easy to spot when an expensive model is doing cheap work, or when a cheap model is getting jobs that are too hard.

04Profile Routes: Build a Team of Specialist Agents

The second mode, profile routes, is the powerful one. In Hermes, a profile is a whole separate setup. Each profile has its own:

  • Model.
  • Credentials.
  • Skills.
  • SOUL.md file, which holds that agent's personality instructions.

With profile routes, the main agent can send a task to one of your profiles. For example, you might have a coder profile that refactors code and runs tests, and a researcher profile that does web research and long write-ups. The main agent hands the coding job to the coder and the research job to the researcher.

Each one runs exactly as if you had started that profile yourself for the task. So instead of one agent trying to be good at everything, you get a team of specialists and a manager who knows who to call.

There is one important safety note from the docs. The list of profiles is also an allow list. The agent can only send work to profiles you have listed.

But when you list a profile, you let your main agent's subagents use that profile's credentials, its SOUL.md and its terminal access. So only list the profiles you are happy for your main agent to use.

05How to Set Up Hermes Advanced Delegation in Five Minutes

Setup takes about five minutes. First, check your version. You need Hermes 0.22.5 or newer, the first version that supports this kind of plugin.

Anything from 0.22 to 0.22.4 will not work, and Hermes will not install it. Then follow these steps:

  1. Update Hermes to 0.22.5 or newer.
  2. Install the plugin in the terminal with hermes plugins install advanced-delegation.
  3. Or, in the desktop app, go to Settings, then Model, then Subagents, and hit Install plugin.
  4. Make sure you install it in the profile that does the delegating, because plugins install per profile.
  5. Run hermes delegation config to open a simple menu.
  6. Pick your mode: default, model routes or profile routes.
  7. For model routes, hit add a route, give it a name like fast, and write a one-line description.
  8. Pick a provider you already have credentials for, then pick the model.
  9. If you want, set the reasoning effort and a speed tier.
  10. Add your deep and local routes, pick a default, and you are done.

Hermes checks each route before it saves it. If the provider is not known or the effort level is not real, it tells you right there. For profile routes it is even easier: you get a checklist of your profiles, tick the ones you want, add a line about each and pick a default.

06Using Hermes Advanced Delegation Commands in Chat

Once your routes are saved, a few commands help you check and change them. To see your setup at any time, run hermes delegation config --show. It prints your current mode and all your current routes.

There is also a slash command right inside the chat. Type /delegation and you will see your current mode and a picker to switch. Here is how switching works:

  • Next session by default: a mode change applies from your next session, when you type /new.
  • Why it waits: changing the agent's tools in the middle of a chat can break the prompt cache, so Hermes waits to save you tokens.
  • Right now if you need it: add --now and the change applies to the chat you are in.
  • Buttons in messaging apps: on Telegram, Discord and Slack, you get buttons to pick the mode.

This small design choice matters. Many people switch settings mid-chat without thinking about cost. Hermes protects your cache by default and still lets you force the change when you need it.

That keeps your token use low while giving you full control.

07Real Examples: How Julian Would Use Delegation Routes

Inside his agentic operating system, Hermes runs a lot of jobs for Julian, including SEO. When he asks Hermes to research a keyword and build out a page, the job splits into pieces:

  • Pull the Search Console data.
  • Check what is already ranking.
  • Summarize the top pages.
  • Write the outline.
  • Write the code.

Most of those steps are simple. Pulling data and summarizing pages are perfect for the fast route. Planning the outline and writing the page is where the deep route becomes useful.

Anything with client data in it can stay on the local route on his own machine. It is the same job, but each piece runs on the model that fits it.

Here is another example. Say Julian is building a new panel for his agentic operating system dashboard. The researcher profile can look up how the data source works.

The coder profile can write the panel and run the tests. The main agent just manages the team.

This is where profile routes shine. Each specialist does the part it is best at, and the main agent stays focused on coordinating the work instead of doing every step itself.

08Tips, Old Way vs New Way and Who It Is For

In the old way, every subagent runs on one model. You either pay top price for every lookup, or you go cheap and your hard jobs come back half done. Or you write your own messy routing code to glue it all together.

In the new way, you write a short list of routes, each with one line saying what it is for. The main agent picks the right one. Simple work goes cheap and fast, hard work goes to your best model, and private work stays on your machine.

Every result shows which model did it, and the agent cannot pick anything you did not approve.

Julian's advice for getting started:

  • Start with model routes and just two routes: fast and deep.
  • Write really clear descriptions, because that is how the agent decides.
  • Set fast as your default.
  • Run your normal jobs for a week and look at which route each result took.
  • If deep is doing simple work, tighten the descriptions.
  • Once that works, add a local route or try profile routes.

This is for anyone running Hermes who wants to cut token costs without losing quality on hard tasks. People who learn to run a team of agents, each on the right model, will get far more done for far fewer tokens.