If you've experimented with complex multi-agent systems, you've probably hit a nasty billing surprise at the end of the month. The pitch sounds great: you spin up an orchestrator agent powered by a flagship model like Claude Opus 5.5 or DeepSeek-R1, give it a delegate_task tool, and let it slice a project into dozens of subtasks for child subagents.
In practice, that setup torches your API balance in no time. Why? Because in most baseline frameworks, every spawned subagent inherits the parent's expensive model. Imagine a heavyweight reasoning model burning forty seconds and thousands of pricey thinking tokens just to filter IP addresses in a text file or check an HTTP status code. It's like hiring a math professor to mop the lab floor.
Nous Research tackled this head-on by releasing the official Advanced Delegation v1.0 plugin for its open-source Hermes Agent (v0.22.5 and up). The plugin introduces dynamic task routing across different models and isolated profiles. Let's look under the hood at how this load balancer works.
Two Routing Modes: Model Routes vs. Profile Routes
Advanced Delegation splits labor using two complementary approaches:
- Model Routes. You define abstract capability tiers in a config file. For example:
fast— a lightweight model for entity extraction, log parsing, and sorting;deep— a flagship reasoning model for systems planning and complex coding;local— a quantized model running locally on vLLM for sensitive data that can't leave your network.
The orchestrator only sees one-line text descriptions of these routes. It decides on its own: "Okay, parsing this table only needsfast, while microservice architecture goes todeep." Raw API keys, endpoints, and tokens stay completely hidden from subagents. - Profile Routes. Here, routing targets a full isolated Hermes profile rather than just a model. Each profile carries its own
SOUL.mdpersona file, distinct skill sets, and a locked-down working directory. For instance, asecurity-auditorsubagent is tuned to hunt vulnerabilities and has zero file-edit permissions, whiledocs-writeronly touches Markdown documentation.
Configuration in Action: Setting Up delegation.yaml
Installing the plugin takes one terminal command:
# Install the official extension via the Hermes package manager
hermes plugins install advanced-delegation
That generates a clean delegation.yaml config file in your project root. Here's how a production mix of cloud APIs and a local model looks:
version: "1.0"
mode: "model_routes"
model_map:
fast:
provider: "openrouter"
model: "anthropic/claude-3-5-haiku-20241022"
description: "Fast search, entity extraction, log filtering, and basic parsing"
temperature: 0.1
max_tokens: 1024
deep:
provider: "anthropic"
model: "claude-3-7-sonnet-20250219"
description: "Complex architectural planning, systems coding, and deep refactoring"
temperature: 0.2
max_tokens: 4096
local:
provider: "openai_compatible"
base_url: "http://localhost:8000/v1"
model: "Nanbeige/Nanbeige4.3-33B-AWQ"
description: "Confidential work with local files and terminal commands offline"
temperature: 0.1
Next, validate your routes and launch the agent session:
# Validate route syntax
hermes delegation config --validate
# Start a lead-engineer session with the plugin enabled
hermes session --profile tech-lead --with-plugin advanced-delegation
Cost and Security: Where the Savings Come From
In real workflows, smart delegation pays off immediately: total costs for multi-hour pipelines drop 3–5x.
The heavy deep model handles roughly 10–15% of calls—breaking down the problem upfront and verifying the final output. All the mechanical steps in between—gathering context, running tests, converting formats—flow to fast, where a million tokens cost mere dimes.
The second win is infrastructure security. When the orchestrator spawns a subagent, it hands over an isolated context. The child process never sees your master cloud keys and can't accidentally leak them into a third-party log.
Sharp Edges in v1.0
As useful as it is, the v1.0 release has a couple of caveats to watch for.
First, model_routes and profile_routes are mutually exclusive in 1.0: you pick either model routing or profile routing (hybrid cascading is slated for v1.1).
Second, watch provider rate limits. If the lightweight model on your fast route suddenly hits a 429 Too Many Requests error, the parent pipeline can hang without built-in retries. For production workloads, wrap fast routes behind a router like LiteLLM or OpenRouter with fallback gateways.
Even so, the direction is obvious: the era of monolithic agents running every single step on one pricey frontier model is ending. The future belongs to smart ensembles of specialized models.

