You do not need to choose between "I want a free agent" and "I want a frontier-quality agent." The cheapest real Hermes Agent setup in 2026 is two models running side by side: a paid frontier brain (Claude Opus, GPT-OSS, or a Tencent Hunyuan subscription via Nous Portal) does the planning and the hard reasoning passes; a free worker (Tencent Hy3 on a Nous Portal free window, OpenRouter's :free models, or a local Ollama model) does the cheap, repetitive sub-tasks. Per-call billing, routed by Hermes's own delegation tools, drops the dollar-weighted share of tokens spent on the paid brain to a small fraction of the total — often under 10–20% of what running everything on the paid model would have cost.
This is not another "how to install Hermes" guide (we already have one — see our Hermes fleet setup walkthrough) and not another "which free model is best" listicle (we already published every free model lane compared). This is the cost-optimization layer on top: how to architect the agent loop so a paid model spends tokens only where it earns them, and how to keep working when a free lane throttles out.
Last verified: 2026-07-30 · Pricing, free-model availability, and rate limits all change fast — re-check each provider's pricing page before you commit to a setup. Primary sources are linked inline.
Why a single-model setup wastes money (the problem this fixes)
Most people boot Hermes Agent, pick one model in the hermes model menu, and let it run. That model does everything — every tool call, every boilerplate file edit, every conversation title, every summarization, every reasoning pass. The problem surfaces as soon as you let the agent loop for any real work, because agent loops are token-heavy on the cheap 80% of the work. Per OpenRouter's own integration write-up, Hermes Agent is already OpenRouter's most-used application by token volume, with more than 17 trillion tokens processed — so even a modest percentage saving is real money over a month.
Consider what one "build me a landing page" task actually spends:
| Turn | Work | Tokens | Where the value is |
|---|---|---|---|
| 1 | Read the prompt, plan the build | ~3K | High reasoning value — brain |
| 2–6 | Read files, scaffold dirs, write boilerplate HTML/CSS | ~12K | Low value — family of free models handles it |
| 7 | Reason about the layout, pick a design pattern | ~4K | High reasoning value — brain |
| 8–14 | Iterate on the markup, add copy, fix typos | ~10K | Low value — worker |
| 15 | Final review, decide it is good | ~2K | High reasoning value — brain |
| — | Total | ~31K | ~9K should run on the brain; ~22K can run on a free worker |
Run all 31K on a paid Claude Opus plan and you paid for thinking that a free model could have done. Run the same task on the delegate-to-free pattern and roughly 70% of the tokens land on a $0 worker. That is the whole game.
What is the delegate-to-free pattern, in concrete Hermes terms?
In Hermes Agent, the pattern is built out of two existing mechanics:
- Multiple profiles. A profile is an isolated copy of the agent with its own model, settings, and memory — each lives under its own
~/.hermes/profiles/<name>/. You runhermes --profile brainfor the planner and a separatehermes --profile workerfor the executor. - The
delegate_tasktool. Hermes's built-in delegation tool lets a parent agent spawn a subagent to run a focused subtask in an isolated context, returning only the final summary to the parent. According to the Hermes Agent Skills docs, Hermes's learning loop, skills, and subagent features compose cleanly — which means the brain profile can hand the cheap, repetitive passes to a free worker profile and only receive the result back.
In config terms, the two profiles look like this (~/.hermes/profiles/brain/config.yaml):
model:
provider: anthropic # or nous, openrouter — your paid frontier route
default: ~anthropic/claude-opus-latest
And the worker (~/.hermes/profiles/worker/config.yaml):
model:
provider: openrouter # or nous (free window), ollama (local, truly free)
default: openrouter/free # auto-routes to a free model that supports tool calls
Then hermes --profile brain is where you type your task. The brain plans it. For each small subtask ("write the boilerplate CSS", "summarize this file", "fetch that doc"), the brain calls delegate_task, which spawns the worker profile to do it, returns only the summary, and the brain keeps reasoning.
The four worker lanes, ranked by cost and stability
The worker doesn't have to be one model — it's a lane you pick. Ranked by "how close to truly free and how stable," here are the realistic options in mid-2026.
Worker Lane 1: Nous Portal promotional free windows (highest free quality, time-limited)
Nous Portal periodically tags a major new model :free for roughly two weeks. The clearest recent example: Tencent Hunyuan Hy3, a 295B-parameter Mixture-of-Experts model (21B active per token, 256K context, Apache 2.0), officially released by Tencent on 2026-07-06. Nous opened Hy3 free in the Portal for two weeks starting roughly 6 July 2026, per Mervin Praison's write-up. The official Tencent release explicitly lists Hermes among integration partners.
For a worker lane, this is gold: Hy3 scores 78.0 on SWE-bench Verified and 90.4 on GPQA Diamond per its HuggingFace model card — strong enough that you could even let it run some planning passes in a pinch. Config:
model:
provider: nous
default: tencent/hy3:free
Catch: promotional windows are time-limited and rare. When the window closes the model either goes paid or drops off the free list. Plan to recable to Lane 2 or 3 in advance.
Worker Lane 2: OpenRouter free-tier models (always available, capped)
OpenRouter lists roughly 16 permanently-free models tagged with the :free suffix, leading with openai/gpt-oss-120b:free (131K context) and google/gemma-4-31b-it:free (256K context), per remoteopenclaw's stable free-models roundup. The meta-model openrouter/free automatically picks a free model that supports your request's feature requirements (tool calling, structured outputs).
model:
provider: openrouter
default: openrouter/free # or pin a specific model:
# default: openai/gpt-oss-120b:free
The limits to know:
- Unfunded OpenRouter accounts get ~50 free requests/day; a one-time $10 credit unlocks 1,000/day. (OpenRouter pricing)
- Free models can disappear from the catalog without notice and latency varies.
- One critical constraint across ALL lanes: Hermes Agent needs at least 64K context to start cleanly, because the system prompt plus tool schemas fill smaller windows. Models below that threshold are rejected at startup. Always confirm context length on the provider's page.
Worker Lane 3: Local Ollama (truly unlimited, offline)
Ollama is the only lane with no daily request cap and no meter at all — it runs on your own hardware. That makes it the ideal "always available" worker lane, immune to rate limits and pricing windows.
The same 64K context rule applies: many popular 7B models default to 2-4K context and will be rejected unless you set num_ctx explicitly. A respected mid-2026 agentic pick is Qwen3.5 27B on a machine with 16+ GB VRAM, or Gemma 4 12B coder on lighter hardware.
# ~/.hermes/profiles/worker/config.yaml
model:
provider: ollama
default: gemma-4-12b-coder
ollama_num_ctx: 65536 # Hermes needs 64K+ context
Speed reality: on a 24GB M3 MacBook Air, crewclaw's setup benchmark measured roughly 12 tokens/second from one local model with every optimization applied — usable as a background worker, but slow enough that you'd never want it as your interactive brain.
Worker Lane 4: OAuth plan reuse (highest quality, marginal-cost free)
If you already pay for a Claude Pro/Max, Gemini Advanced, or comparable subscription, hermes auth add <provider> runs a device-login flow (browser opens, you approve, token saves) and the agent can ride that plan with no per-token bill above what you already pay. This is the highest-quality "free" lane and is the natural pick for the brain side of the pattern, not the worker — but you can also flip it: reuse a Gemini Advanced plan subscription for the brain and a free OpenRouter model for the worker.
How to size your real savings (a worked example)
Take a typical day of agent use: 50,000 tokens across maybe 20 tool-loop turns.
- All on Claude Opus 5 (~$15/M input, $75/M output per the Anthropic pricing page): roughly $3–$4/day, call it **$100/month**.
- All on a free Nous Portal Hy3 window: $0. As long as the window is open.
- Delegate-to-free (the pattern in this guide): the brain (Opus) spends ~9K of the 31K-task tokens, the worker (any free lane) does the other ~22K. Effective cost per task is about ~30% of the all-Opus path — call it ~$30/month on a $100/month base. And critically, that third of the spend lasts forever — it doesn't disappear when a free window closes, because the bulk-cost absorbing the cheap work stays on a free lane.
The math is intentionally conservative (real ratios depend on your job mix). The point is structural: most agent tokens are cheap work, so routing the cheap work to free lanes pays for itself whether or not a promotional window is live.
How to beat rate limits with a fallback chain (so you never stop working)
Free models throttle. OpenRouter free is capped at ~20 requests per minute and 50–1,000 per day depending on funding; local Ollama is the only lane with no cap. Two habits keep you unblocked.
Configure a fallback chain. Hermes supports provider fallbacks in
~/.hermes/config.yaml: if your primary model 5xxs or rate-limits, the agent falls through to the next provider mid-session, with no manual retry. OpenRouter's guide documents automatic failover the same way at the OpenRouter layer.Switch mid-session. The command
/model provider:modelchanges the model inside a running conversation without a restart, so if you hit a rate limit on Hy3, you can hop to an OpenRouter:freemodel in seconds, per the OpenRouter + Hermes tutorial. This is also what makes the delegate-to-free pattern resilient — you can re-point the worker lane mid-task without losing the brain's context.
For a permanently-near-zero bill, pair OpenRouter free as the primary worker with local Ollama as an offline fallback. Local never throttles, which makes it the ideal "always available" lane in the fallback chain.
How does the delegate-to-free pattern interact with the /learn skills loop?
Hermes's /learn command turns any doc page, local SDK directory, or in-session workflow into a reusable SKILL.md file under ~/.hermes/skills/. Because /learn runs on whatever model is active, you can teach skills on the free worker and the skills survive after the worker lane changes.
One honest caveat on free models for skill authoring: the skills loop does fire on free models, but auto-generated skills are noticeably lower quality than those authored by frontier models, per remoteopenclaw's actual testing. The pattern therefore says: have your brain write the load-bearing skills and let the worker only write throw-away helper skills. This composes perfectly with the delegate-to-free setup — you ask the brain to learn a new skill, the brain authors the skill, and from then on the worker can use it.
A decision table to pick your two models
| If your priority is… | Brain | Worker | Why |
|---|---|---|---|
| Lowest possible bill, no promotional window | OAuth plan reuse (Claude/Gemini) | Local Ollama | Paid brain only on hard passes, local worker has zero cap |
| Highest worker quality while a promo lasts | Claude Opus (paid) | Nous Portal tencent/hy3:free |
Best of both — paid brain, near-frontier worker, both $0 incremental during the window |
| Privacy / fully offline | Local Ollama (large model) | Local Ollama (smaller coder model) | Both lanes on your machine; data never leaves |
| Maximum variety / experimentation | Claude Opus (paid) | OpenRouter :free rotation |
One paid brain, rotating free worker across 16 models |
What this means for you
If you have been putting off running Hermes Agent because every long agent loop feels expensive, the delegate-to-free pattern removes the objection: pick a paid brain you trust for the reasoning, route the cheap 80% down a free worker lane, and let the agent run unattended without watching the meter. Keep the fallback chain configured and a local model as the unlimited offline lane, and the setup keeps paying for itself long after any individual free window closes.
The bigger shift is mental: agents are not single-model blobs. They are pipelines. Treat the model choice as a routing decision per subtask — the same way our guide to running a 744B-parameter LLM locally with Colibri treats local quantization as a deployment decision — and the bill follows the value of the tokens, not the volume.
For a deeper inventory of where else you can shave cost across the open-source stack, our free open-source AI tools roundup and our end-to-end free Hermes setup guide cover the broader landscape.
FAQ
Q: Does the delegate-to-free pattern actually work with Hermes Agent's built-in delegation?
A: Yes. Hermes ships a delegate_task tool that spawns subagents to run subtasks in isolated contexts and return only the summary to the parent. The brain profile is the parent; the worker profile is the subagent. Both profiles live under ~/.hermes/profiles/<name>/ with their own config (model + provider), and you launch them with hermes --profile brain and hermes --profile worker.
Q: How much does this actually save versus running everything on one paid model? A: Conservatively, ~70% of tokens in a typical agent tool loop are "cheap" work (boilerplate file edits, single-file scaffolds, summarization) that a free model can handle. Routing those pass to a free lane drops the dollar-weighted cost to roughly 30% of the all-paid path — and that saving persists even when a promotional free window closes, because the cheap-absorbing lane is whatever free option is current.
Q: Which free model should I use as the worker right now?
A: For highest quality: Tencent Hunyuan Hy3 (295B MoE, 256K context, SWE-bench Verified 78.0) when a Nous Portal free window is live. For always-available: OpenRouter :free models like openai/gpt-oss-120b:free (131K context) or google/gemma-4-31b-it:free (256K context). For truly unlimited: a local Ollama model like Qwen3.5 27B (needs 16+ GB VRAM).
Q: What is the 64K context rule and why does it matter here?
A: Hermes Agent needs a model with at least 64K-token context to start cleanly — the system prompt plus tool schemas fill smaller windows and the agent rejects the model at startup. This applies to the worker profile too. Always confirm a model's context length on the provider's page before selecting it; with Ollama, set ollama_num_ctx: 65536 in the worker profile config. (OpenRouter's Hermes guide)
Q: Will rate limits on the free worker stop my agent mid-task?
A: They can, which is why you configure a fallback chain in ~/.hermes/config.yaml. If the primary worker model 5xxs or hits a rate limit, Hermes falls through to the next provider mid-session with no manual retry. Pairing OpenRouter free as primary with local Ollama as fallback is the most common resilient setup — local never throttles.
Q: Can I let free models author skills via /learn?
A: They can trigger the skills loop and produce reusable SKILL.md files, but the auto-generated skills are noticeably lower quality than those authored by a frontier model. Best practice: have your paid brain author load-bearing skills and let the free worker only generate throw-away helper skills.
Discussion
0 comments