1.The mindset: Hermes is a system, not a model

People ask "which model is best?" first. Wrong question. Hermes' output quality is roughly:

result = model × context × tools × memory × skills × your feedback

A flagship model with no memory and no skills loses to a mid-tier model with six months of accumulated skills and clean memory — and costs 10× more doing it. Optimize the multipliers in order of leverage: skills > memory > model routing > config > everything else.

2.Model routing — the biggest cost lever

Hermes lets you assign different models to different jobs. Use that ruthlessly:

Job type	Route to	Why
Cron jobs, health checks, monitoring	Cheap/free models (Gemini free tier, DeepSeek, Kimi)	Structured, low-stakes, high-frequency. These are 80% of your token volume.
Daily ops (SSH work, HA config, file edits)	Mid-tier (your default)	Tool-calling competence matters more than benchmark scores.
Multi-file debugging, architecture, tricky migrations	Flagship (Claude Sonnet/Opus, GPT-5-class)	Reserve for tasks where being wrong costs more than the tokens.
Auxiliary tasks (vision, compression, session naming)	Cheapest that works	Set explicitly or they fall back to auto and may silently fail.
Sub-agents (delegation)	Configurable separately	delegation.model — children often need less brain than the parent.

Concrete commands:

# per-job model pinning for cron (routine work on cheap models)
hermes cron edit <id>          # set model/provider per job

# auxiliary models — stop silent vision/compression failures
hermes config set auxiliary.vision.provider openrouter
hermes config set auxiliary.vision.model google/gemini-flash-1.5

# delegation gets its own brain
hermes config set delegation.model deepseek/deepseek-chat

3.Memory hygiene — small, hot, and honest

Hermes injects memory into every turn. That makes memory both its superpower and its biggest failure mode: a bloated or stale memory degrades every single response and burns tokens 24/7.

The rules that keep memory sharp

• Declarative facts, not instructions. "User prefers concise responses" ages well. "Always respond concisely" gets re-read as a directive and can override a current request.
• If it's stale in a week, it doesn't belong there. PR numbers, "Phase 2 done", current bug states — that's session history, not memory. Hermes already has session_search (FTS5, free) for recalling past work.
• Procedures belong in skills, not memory. "How to deploy the landing site" is a skill. "The landing site deploys via scp to .222" is memory.
• Durable reference data goes to long-term storage. If you have a memory provider configured (Honcho, Mem0, local stores), keep the built-in buffer for hot facts only and let the provider hold the archive.

4.Skills — the compounding moat

Skills are where Hermes pulls away from every other agent. Two months of disciplined skill-building and your agent does things a fresh install simply cannot.

Build the habit

• After any task that took 5+ tool calls or hit a non-obvious pitfall: "save that as a skill."
• When you correct the agent and the correction sticks: "add that to the [relevant] skill."
• When a skill's instructions turn out wrong: tell it to patch the skill immediately — stale skills are liabilities.

Curate or drown

Hermes ships a background curator that tracks skill usage, marks idle ones stale, and archives them (never deletes). Keep it enabled:

hermes curator status
hermes curator run           # deterministic sweep — free, no tokens
hermes curator pin home-assistant   # protect your crown jewels

Pin the 3–5 skills that define your setup (mine: home-assistant, homelab-services, plus the SSH fleet one). Everything else can flow through the lifecycle.

5.Delegation — parallelize the grunt work

Hermes can spawn sub-agents with isolated contexts and terminal sessions. Use delegation when a subtask is reasoning-heavy but independent (debugging one service while it works on another, researching two options in parallel). The key config:

hermes config set delegation.max_iterations 50      # cap child loops
hermes config set delegation.model <cheap-model>    # children don't need your flagship

Two rules from experience:

• Sub-agents have no memory of your conversation. Everything relevant goes in the task description — file paths, error messages, constraints. Under-briefing is the #1 cause of useless sub-agent output.
• Sub-agent claims are self-reports. For anything with external side effects (deploys, posts), have it return a verifiable handle (URL, path, ID) and check it yourself before believing "done".

6.Cron — where autonomy actually lives

The gateway + cron is what turns "assistant I query" into "operator that works while I sleep." Patterns that work well:

Pattern	Setup
Silent watchdog	Job runs a script; empty output = no message. Only state changes and new issues alert. Recurring known-bad belongs in kanban, not your Telegram.
Morning brief	Daily job, cheap model, aggregates overnight state into one message.
Chained jobs	Job A collects data, job B processes it (context_from links them).
Project-scoped jobs	workdir pins a job to a repo so its AGENTS.md loads — the job behaves like a team member who read the docs.

7.Profiles — hard isolation for risky experiments

Profiles are separate Hermes instances with isolated config, sessions, skills, and memory (~/.hermes/profiles/<name>/). Uses I've found genuinely valuable:

• A sandbox profile with a different (cheaper) model and no SSH keys in its .env — for testing prompts or skills before promoting them.
• A work vs. homelab split — different credentials, different skills, different memories, zero leakage.

hermes profile create sandbox --clone     # clone current as starting point
hermes -p sandbox                          # run against it

8.Config knobs worth touching

Defaults are sane; these are the ones that actually change daily experience:

Setting	Recommended	Why
approvals.mode	smart	Auto-approve low-risk, still asks on dangerous. Manual gets old fast.
compression.threshold	0.50 (default)	Earlier compression = cheaper long sessions but more summary loss. Raise slightly if summaries lose too much.
agent.max_turns	90 (default)	Lower it for cron jobs on cheap models — bounded loops = bounded cost.
terminal.timeout	180+ for build-heavy work	Nothing's worse than a killed 20-minute build at 95%.
security.redact_secrets	true (default) — never change	Scrubs keys from tool output before they hit context/logs.
display.show_cost	true while tuning	You can't optimize what you can't see. Turn off later.
curator.enabled	true	Free skill lifecycle maintenance. Keep consolidate: false unless you want an aux-model merging skills.

9.Context discipline — the invisible multiplier

• One task per session. Context is the agent's working memory; a session that's done six unrelated things is an agent that's forgotten the details of the first. /new is free.
• Use /compress before long multi-step work in a session you want to keep — better to compress on your terms than the auto-compressor's.
• Name sessions (/title) — session_search and --resume become actually useful, and future-you can find "the vacuum automation session" in seconds.
• Paste outputs, not descriptions. "It errored" makes the agent guess. The actual error text makes it right the first time. Tokens spent on real data beat tokens spent on wrong hypotheses.

10.The feedback loop that trains it

Hermes improves fastest when you treat corrections as training data:

1. Correct explicitly: "No — never recreate that container without confirming the mount first." Good agents save corrections to memory themselves; if yours didn't, tell it to.
2. Promote patterns: the third time something works well, it deserves a skill.
3. Review monthly: hermes insights for cost, the memory-audit prompt from section 3, hermes curator status for skills.
4. Evolve SOUL.md: when you notice a behavioral tendency you like or hate, that's a SOUL.md edit, not a repeated correction.

11.The optimization checklist

In order of leverage — do these once and Hermes is operating near its ceiling:

1. ☐ Route cron/routine jobs to cheap models; reserve flagship for hard tasks
2. ☐ Set auxiliary model providers explicitly (vision, compression)
3. ☐ Memory audit: declarative facts only, procedures → skills, stale → gone
4. ☐ Pin your 3–5 crown-jewel skills; curator enabled for the rest
5. ☐ Approvals on smart; secret redaction untouched
6. ☐ At least one silent-by-default watchdog cron job running
7. ☐ hermes insights bookmarked — check monthly, adjust routing
8. ☐ SOUL.md reflects how you actually want it to behave (not the default)

Previous guide

← Getting started with Hermes

Install, provider setup, gateway on Telegram, memory seeding, safety — the zero-to-useful path.

Related: Letting an AI agent run your Home Assistant · Official docs