Hermes Agent Fundamentals

TLDR

• A personal agent only compounds if you set the foundation first: pick always-on hardware, wire up a layered memory system, teach it skills, and schedule recurring work — otherwise it degrades and forgets.
• Memory is the whole game: a two-tier default (brief markdown core files + searchable archived session logs) plus two optional upgrades — an implicit-memory plugin and an Obsidian “second brain” the agent reads and writes.
• Cost control comes from running local open-source models (via Ollama, or llama.cpp for speed/control), reserving paid cloud models for the rare hard task.

Caveman

Set foundation right, agent gets smarter forever.

ELI5

An AI helper that lives on an always-on computer can become genuinely useful, but only if you set it up so it remembers things well and can learn new tricks. You give it a good memory (short notes it always sees, plus a searchable diary), teach it repeatable skills, and let it run small jobs on a schedule. Run it on models installed on your own machine so it stays cheap and private.

Trunk → Branches

Trunk: A local agent becomes durably useful only when you build its foundation deliberately — hardware, memory tiers, skills, and scheduled automation — so it improves over time instead of forgetting and slowing down. Branches:

• Hardware is a where-it-lives decision with four tiers: a dedicated machine (Mac Studio), a cheap always-on VPS ($5–6/mo), any spare wiped laptop kept on 24/7, or your own PC — but on your own PC use Docker to contain it [2:02, 2:32].
• Setup is low-friction: install the desktop app (or one terminal command), connect a model provider (your existing OpenAI/Anthropic sub, a bundled model portal, or a local model), then just say hi [3:00, 3:52, 4:20].
• Five core features: managed tools (web search, images, browser automation), integrations + MCP for third-party services (Discord alerts, Notebook LM), and skills — reusable “instruction manuals” the agent learns with you and you invoke with a slash command [7:50, 8:18, 10:04, 11:02].
• Turn a good one-off result into a permanent capability: after the agent nails a task, say “make this into a skill” and it writes the description + how-to-use so future invocations are one command [12:32, 13:08].
• Cron jobs run recurring work unattended — a nightly news brief compiled to audio, Apple-notes summaries into Obsidian, health-checks on self-hosted models and running agents [14:01, 14:34, 15:12].
• Memory is a stack you can extend to four tiers: (1) brief core files memory.md / user.md / agent-identity, kept deliberately small; (2) session_search over archived logs in a SQLite DB; (3) an implicit-memory plugin (Honcho) that learns patterns across interactions; (4) an Obsidian second brain the agent both reads from and writes to [16:48, 17:01, 17:40, 18:37, 20:21].
• Multi-agent build loop: from a chat app (Discord), dispatch spec → PRD → queued build; multiple agents work in parallel and a native Kanban board orchestrates them [25:52, 26:23, 28:19, 28:49].

Key Patterns

• Pattern: Split memory into a tiny always-loaded core plus a searched-on-demand archive — works because the context window stays fast and uncluttered while nothing is lost; transfers to RAG design, caching layers, and any hot/cold storage split.
• Pattern: Promote a successful one-off into a named, reusable skill (“make this a skill”) — works because it converts throwaway prompting into compounding tooling; transfers to codifying repo scripts, snippets, and your own agent workflows instead of re-prompting from scratch.
• Pattern: Buy the easy default but keep an escape hatch to the primitive (Ollama for convenience → llama.cpp for control/speed) — works because you pay the learning cost only where control matters; transfers to ORMs vs raw SQL and frameworks vs standard library.

Stress Test

• Hidden assumption: You have (or will keep on) always-on hardware with enough RAM to run capable local models, and you’re comfortable enough with terminal/setup to push past the default configuration.
• Best counterargument: For most users the default memory system is “good enough” (she says so herself), so tiers 3–4 and local models add real setup/maintenance cost for marginal gains — a hosted agent with zero infra may be the rational choice until you’re genuinely power-using it daily.
• Fails when: Your hardware is underpowered (local models are slow/weak), or you over-invest in an elaborate memory + multi-agent rig before you have recurring workflows that justify it — foundation without usage is just overhead.
• Fact vs opinion: “Sonnet 5 is the best driver model” is stated consensus/opinion, not measured. “Local open-source models are now good enough to replace paid cloud models” is her experience/opinion — hardware- and task-dependent, and the video promotes a paid bootcamp + free guide + affiliate links, so treat tool/model endorsements as motivated.

In Practice

• Stand up a personal always-on agent foundation ¶1:32
  • Pick where it lives: dedicated machine, cheap VPS, spare wiped laptop, or your PC in Docker for isolation ¶2:32
  • Install the desktop app (or the one-line terminal command) and connect a model provider ¶3:27
  • Seed identity: paste a “what you know about me” blurb so it writes user.md ¶5:13
  • Locate the memory folder (.hermes/memory/) and read memory.md + user.md to see what it stores ¶6:14
• Run a local open-source model to cut cost/keep data private — start with Ollama, then try llama.cpp for speed/control; review whether quality holds for your real tasks ¶24:30
• Add an implicit-memory plugin (Honcho) as a tier-3 layer and check status in the terminal to confirm it’s collecting; keep only if the experience noticeably smooths ¶18:37
• Connect an Obsidian vault as the tier-4 second brain and drive saves via the Obsidian skill ¶20:21
  • Create/open a vault folder in Obsidian ¶20:21
  • Ask the agent to set up the Obsidian connection ¶20:48
  • Save a research output, then have the agent read a stored doc back to extend the work ¶21:39
• Turn one successful task into a reusable skill (“make this into a skill”), then invoke it via slash command to test it generalizes ¶12:32

Connections

• Building a Claude Code Agentic OS — near-identical blueprint: layered core-files + session-search + Obsidian vault plus “make this a skill” and cron is exactly that note’s skills→automations-over-an-indexed-vault pipeline.