Jonathon's AI Wiki

Hermes Agent — Full Catalog

30 min read

Full annotated catalog for Hermes Agent. The topic index carries a one-line gloss per article for fast navigation; this file preserves the complete annotation for every entry, verbatim.

Split out 2026-07-24: hermes-agent/_index.md had grown past the point where it could serve as a navigation step (claude-ai reached ~210KB / ~50k tokens to read). Nothing was deleted — the long-form descriptions live here.

Hermes Agent is Nous Research’s self-hosted, self-improving agent framework — a stateful agent that learns from experience, remembers across sessions, and runs 24/7. This topic tracks its architecture, memory model, security, skills, and the growing community ecosystem of dashboards, plugins, themes, and integrations around it.

WEO Marketly’s applied Hermes articles (deployment, configuration as run internally, marketing and ops integrations) live in the internal work vault at weomarketly:hermes-agent/_index; that copy’s framework-core articles are frozen at the 2026-05-06 migration, so this topic is the current reference for releases and framework changes.

Currency check — 2026-07-24

Current release: v0.19.0 “Quicksilver” (v2026.7.20), verified against both the GitHub releases page and PyPI on 2026-07-24 — no newer tag exists. Nous ships between releases through skills and model availability rather than version bumps, so the release article alone will lag: the newest feature at this check is the tldraw-offline skill (2026-07-23), which shipped as a skill install three days after the release. Update with hermes update; check hermes skills for what landed since.

Visual overview

The Anatomy of Hermes Agent — a 10-section community infographic by nainsi dwivedi covering what it is, how it's built, the SOUL.md identity layer, the three-tier memory system, self-evolving skills, GEPA offline evolution, getting started, scaling 1 to 10 agents, customizing agents, and CRON scheduling

One-page community infographic by nainsi dwivedi. Ten-section visual walkthrough: (1) what Hermes Agent is — learns, remembers, works 24/7; (2) how it’s built — AIAgent class loop (build system prompt, check context compression, API call, execute tools, loop up to 12 turns); (3) before-memory identity via SOUL.md as the load-bearing system prompt; (4) three-tier memory system — Tier 1 Core Memory in Context (2,200 chars plus a 1,375-char USER.md, persistent across projects, fast and essential), Tier 2 Session Search (full-text search across all past conversations with LLM summarization, searchable and on-demand), Tier 3 External Memory Providers (pluggable — Obsidian, Notion, Roam, MongoDB, Upbrand, Redis, Zep, Chroma; deep, persistent, synced); (5) self-evolving skills written as Markdown plus YAML with progressive disclosure (Level 0 names, Level 1 metadata, Level 2 drill into reference files); (6) GEPA — Genetic-Pareto Prompt Evolution evolving skills offline using execution traces (no GPU required, roughly 2 to 10 USD per run, published at ICLR 2026); (7) getting started — curl install, setup wizard, start chatting, Telegram connect; (8) going from 1 to 10 agents (full profiles in ~/.hermes/ versus fully isolated); (9) customizing your agents (Programmer / Designer / Researcher / Coder example team); (10) CRON scheduling made simple with YAML config. A useful “show me Hermes in one page” surface for anyone arriving cold to the topic — sister visual to Nate Herk’s 1-hour course narration. Caveat: community-made distillation, not Nous Research’s official documentation — verify load-bearing figures (the 12-turn loop cap, the GEPA per-run cost, the Tier-1 character counts) against hermes-agent.nousresearch.com/docs before quoting in production work.

Framework, skills, clients, integrations and community builds

Note: this section is the topic’s general article pool — courses and walkthroughs sit alongside client apps, plugins, skills, and integration write-ups. It has outgrown a single flat list; splitting it into sub-sections (courses / client surfaces / skills / integrations / field reports) is a pending organizational cleanup, not a content gap.

  • Access Your Hermes Agent From Anywhere — Tailscale + Termius + tmux — YouTube walkthrough of a three-tool remote-access stack for reaching a self-hosted Hermes host from any device with zero public-port exposure: Tailscale (private WireGuard mesh — devices reachable by MagicDNS name, peer-to-peer, free personal plan) solves reach; Termius (mobile-grade SSH client with command keyboard, mosh, port forwarding) solves control; tmux (tmux owns the shell, SSH is just a window into it) solves persistence so agentic loops survive dropped SSH / closed laptop / bad Wi-Fi. Full server-side commands (sudo tailscale up --hostname, apt install openssh-server, tmux new -s / attach -t), Termius key-gen + export + dashboard port-forwarding, and the live demo of starting a task on a PC and reattaching the same running session from an iPhone. Rejects port-forwarding / ngrok / Cloudflare Tunnel / VPS+reverse-SSH as the alternatives. Honest caveat: secures reach, not the agent — pairs with the seven-layer security model which governs what the agent can do once reached. Windows+WSL host throughout; Tailscale must be installed inside whatever environment runs the agent. Framework credited to a Pseudo Sue (X) post.

  • Hermes Skill Bundles — Slash-Command Skill Composition — New Hermes feature shipped with v0.14.x. Save a named set of skills behind one slash command (e.g., /research, /release-prep, /incident-response). Bundles are tiny YAML files under ~/.hermes/skill-bundles/ with name / skills / description / instruction (mini agents.md) fields. CLI: hermes bundles create/list/reload. Solves the probabilistic-skill-invocation problem — agents may skip skills you intended; bundles make the set explicit per workflow. Pairs with the self-improvement loop (consult Hermes itself about which skills to bundle, let it draft the YAML, ship). Sister surface to Browse.sh runtime skill hub announced same week. Team sharing pattern: commit bundles to dotfiles or shared repo.

  • * Turns to Codex CLI — Opt-in runtime that delegates openai/* and openai-codex/* turns to OpenAI’s Codex CLI instead of running Hermes’ own tool loop. Hermes keeps the orchestration layer (session DB, memory, cron jobs, slash commands, review forks); Codex executes the turn with its sandbox, built-in toolset (shell, apply_patch, update_plan, view_image, web_search), and plugin ecosystem (Linear, GitHub, Gmail, etc.). Headline value prop: runs OpenAI agent turns against your ChatGPT subscription (no API key required) via Codex CLI’s existing OAuth flow. Wired up via JSON-RPC over stdio + bidirectional MCP callback so Codex can still reach Hermes-side tools (browser automation, vision, image gen, skills, TTS) during the turn. Enabled per-session with /codex-runtime codex_app_server. Requires Codex CLI 0.130.0+. Four Hermes tools (delegate_task, memory, session_search, todo) unavailable in this runtime; background review forks downgrade to codex_responses to access them. Auxiliary tasks (title generation, etc.) also flow through ChatGPT subscription by default — can be overridden per-task to cheaper providers. Multi-profile isolation requires explicit CODEX_HOME. Goals fully compatible; Kanban supported; cron jobs untested but expected to work.

  • Hermes Agent — Security Model (Defense-in-Depth) — Nous Research’s official seven-layer security model for self-hosted Hermes deployments: (1) dangerous command approval against a curated pattern list (rm -rf, bash -c, curl \| sh, tee to ~/.ssh, etc.), (2) container/sandbox isolation, (3) MCP-server credential scoping (each MCP subprocess sees only its declared env block, not the full host env), (4) credential redaction in error messages (ghp_..., sk-..., token=, etc. → [REDACTED]), (5) website access policy, (6) user authorization on messaging channels, (7) encrypted secrets at rest (decrypted only at heartbeat). Three approval modes (manual / smart / off) configured via ~/.hermes/config.yaml. Why each layer matters and what fails if it isn’t there. Operational pairing with Nate Herk’s course — platform-side defenses + operator-side discipline together close the security loop.

  • Hermes Agent — User Stories and Use Cases — Community-curated catalog from Hermes’ official docs across five categories: Privacy & Self-Hosted (Tailscale serve for secure remote access without exposed ports), Business Ops (Google Slides, Hunter.io for sales outreach, live inventory tracking, AgentMail email-inbox via MCP), Integrations (JMAP for Fastmail), Personal Assistant (Google Tasks), Meta & Ecosystem (OpenClaw → Hermes shadow-mode migration, real cutover testimonials). Three operational patterns surface from the catalog: (1) Hermes’ value prop is stateful business agent, not coding agent — multi-day session continuity matters more than raw code-gen speed; (2) MCP is the integration substrate — every new integration ships as MCP server or skill wrapping one; (3) OpenClaw → Hermes migration is a real, documented path. Useful as roadmap signal and deployment-pattern map.

  • Hermes Skins — Community Visual Themes for the Hermes CLI Agent (joeynyc) — Community-curated visual-theme bundle for the Hermes CLI agent (380★, MIT, Python). 15 custom skins (Pirate, Vault-Tec, Bubblegum 80s, Skynet, Lain, Neonwave, Sakura, Netrunner, Mythos, Nous, Mother, DOS, Telemate, Empire, Catppuccin) + reference docs for the 7 built-in skins shipped with Hermes (default, ares, mono, slate, poseidon, sisyphus, charizard). Visual-only — “They don’t affect personality or behavior — just how things look.” YAML config under ~/.hermes/skins/<name>.yaml, 28 color keys per SCHEMA.md, default-skin inheritance so partial skins work. Activation: /skin <name> (session) or display: skin: in ~/.hermes/config.yaml (permanent). Orthogonal to Hermes Skill Bundles (which modify behavior). Several skins double as brand homages — Nous mirrors Nous Research’s #DD8E35 brand color, Mythos uses Eye of Providence + Prometheus Labs branding.

  • Hermes MemoryKit — duclamvan’s 8-Layer Memory Stack for Hermes (v0.2.0) — Memory toolkit extending Hermes’s three-tier memory model with an opinionated 8-layer stack: LCM raw transcript → native memory → QMD/markdown wiki → entity graph → hybrid RRF router → focus brief → regression tests → nightly maintenance. Hermes-native plugin wrapper exposes 4 tools (memory_stack_status / memory_stack_route / memory_stack_focus_brief / memory_stack_regress). Config templates for .env, ~/.hermes/config.yaml, and cron prompts. Companion benchmark repo claims 100/100 A+ / 27/27 retrieval checks / 35 Hermes profiles verified. Adoption signal caveat: 1 star / 0 forks / 5 commits / 3 days old at ingest — extremely early; benchmark claims are self-reported. The novel layer set (4-8) is the routing + regression discipline that most agent-memory toolkits don’t ship. MIT / Python.

  • Hermes Console — Obsidian Plugin for Hermes Agent (Danny Shmueli, v1.1.14) — Obsidian community plugin embedding Hermes as a tabbed PTY terminal inside the vault. Three-component architecture — Obsidian plugin (terminal UI + tabs) + bridge file (.obsidian/hermes/context.json) + companion Hermes plugin (obsidian-context-bridge, installed via hermes plugins install dannyshmueli/obsidian-hermes-console --enable). Highlight text in any note → press Enter in Hermes Console → selection becomes context inside Hermes. xterm.js + node-pty for real interactive shell (not just command execution); ConPTY backend on Windows with patched windowsConoutConnection.js for Electron Worker incompatibility. 12 themes, tab pin/drag/color-code, wiki-link autocomplete, session persistence, busy/idle per-tab status, background-turn-complete notifications, obsidian://hermes-console URI handler. Built on fork of Lean Terminal with upstream credit preserved. Desktop only / Obsidian 1.7.2+ / MIT / 162 downloads at 6 days old.

  • Bun, 189★, v1.7.1) — Tabbed, mouse-aware TUI built with OpenTUI (React renderer) + Bun. Talks to the same gateway the Hermes CLI uses. Streaming chat with markdown / inline images (chafa) / LaTeX→unicode / diff chips / tool-call expansion / animated ASCII avatar. 11 dashboard tabs — sessions / context / agents / analytics / skills / cron / toolsets / config / env / memory / kanban. Profile switching, command palette (Ctrl+K), slash popover, @-refs for file/diff context. Fully rebindable keys via /keys, opencode-compatible keymap. Theme picker. Resume last session: herm -c. Install: bunx herm-tui (trial), bun add -g herm-tui (stable), npm i -g herm-tui. Author built it because they wanted Hermes capabilities with an OpenCode UX. MIT / TypeScript / 189★. v1.7.1 released 2026-05-22.

  • SwiftUI, 1.6k★) — Native macOS companion that manages a Hermes host over pure SSH — “no gateways, no exposed ports, no browser layer.” Eight focused views (Overview / Sessions / Workflows / Kanban / Files / Cron / Usage / Skills / embedded Terminal) over the host’s own state, with the host as the only source of truth (no daemon, no local mirror, no sync layer). Multi-profile / multi-agent — the active ~/.hermes/profiles/<name> flows through every view. Stays usable when higher-level surfaces break (SSH-direct recovery path). Complementary to the official web dashboard (“browser for administration, Mac app for direct host work”). Sessions Chat embeds the real hermes --tui over SSH; Workflows are the only locally-stored state (reusable presets that seed a fresh Terminal turn). Universal app (Apple Silicon + Intel, macOS 14+), localized EN/zh-CN/RU. Ad-hoc signed (not notarized) + per-release SHA-256/manifest + from-source build. The native-Mac sibling of Herm-TUI and Hermes Console in the client-surface cluster. MIT / Swift / 1,604★.

  • Linux) — Nous Research’s first-party desktop app for Hermes Agent (MIT, v0.15.2): one cross-platform install (macOS 12+ / Windows 10-11 / Linux) packaging the full stack behind a GUI. Six pillars — Connect (one agent + one memory across Telegram/Discord/Slack/WhatsApp/Signal/Email/CLI), Remember (persistent memory + auto-generated skills), Schedule (natural-language unattended automation), Delegate (isolated subagents with their own terminals + Python RPC), Search (web/browser/vision/image-gen/TTS/multi-model), Experiment (five sandbox backends — local/Docker/SSH/Singularity/Modal). Paid usage via Nous Portal (Free/Plus/Super/Ultra — monthly credits across Hermes Agent + Nous Chat, hundreds of models). The official counterpart to the community client cluster, and distinct from dodo-reach’s third-party SSH client that confusingly shares the name. Answers the dodo-reach “will Nous ship an official desktop?” open question.

  • Hermex — Native SwiftUI iPhone Client for Hermes Agent (uzairansaruzi, Swift, 39★) — Open-sourced 2026-07-02 (MIT). Native SwiftUI iOS app (not a web wrapper; iOS 18+; Xcode 26+ to build) that is “a mobile cockpit for an AI agent that lives on a machine you control” — points at a self-hosted hermes-webui server the user already runs. Real-time streaming chat, session browsing, model/provider switching, task scheduling, skill browsing, workspace file exploration, memory/usage analytics, file/image attachments. Independent/unofficial client, not affiliated with upstream hermes-webui; repo ships dev-workflow docs, a security policy, TestFlight ops, and contract tests against upstream hermes-webui. The first native mobile client in this topic’s client-app cluster — sibling to Hermes Console, Herm-TUI, and the two Hermes Desktop apps above.

  • Companion for Hermes Agent (db-aeon, AGPL) — open-source AGPL cloud desktop where the agent is available 24/7 via voice, text, or shared desktop; open-sources the commercial Joshu LGUI showcase. Repo verified (40 commits, extensive self-hosting/architecture docs); joins the client-surface cluster alongside the two Hermes Desktop apps and Hermex.

  • Hermes Agent Cloud — Deploy Hermes Agents in the Cloud via Nous Portal — Launched 2026-07-08. Select a model + server size and the agent instance goes live in ~60 seconds with two clicks, provisioned at portal.nousresearch.com/cloud. Org features: team agent provisioning, granular access controls, unified billing; pricing scales with server size. Hermes Desktop now auto-discovers and connects to active Cloud instances (2026-07-10) once signed in with Nous Portal — the managed-compute counterpart to the self-hosted VPS path in Hermes Runs My Web App on a $6 VPS.

  • Nous Portal — Unified Subscription Backend for Hermes Agent — Nous Research’s unified subscription + model-access backend for Hermes Agent: one plan gives metered access to 300+ models plus hosted tools (web search / scraping / image gen / browser use / code execution / voice) from a single credit pool — no per-provider API keys. Four tiers (Free / Plus 100 / Ultra $200; paid tiers +10% credits + tier-scaled rollover caps). Switch with hermes portal. The paid layer under Hermes Desktop; documents the Portal that the velocity release and MCP catalog already route through.

  • Hermes Multi-Agent Workflow — Kanban-Coordinated Triage Pipeline Template (tonbistudio) — Reusable MIT template for an autonomous, human-gated multi-agent triage pipeline on Hermes: sources → intake → dedup → score → research (parallel) → route → HUMAN GATE → fulfill → deliver, all coordinated on one Hermes Kanban board as the message bus / dispatcher / fan-in. Hard config/code split (whole domain in triage.yaml; generic engine/ rarely edited), one explicit approve/shelve/modify gate, 12 tests + 7 deep-dive docs + a worked ai-agent-pain-points example. The readable reference implementation of the Kanban-orchestration pattern — sibling to the complexity-routed SWE workflow below. 153★ / Python / pushed 2026-06-01.

  • RUDR9 — Turning Hermes Agent Into a Dev Team via Toolset Restriction, Not Prompts — One-command installer (MIT, 29 stars) turning a Hermes install into an 8-role dev organization (CTO + Planner/Architect/VCM/Builder/Security Auditor/Performance Auditor/Reviewer) coordinated via Hermes’ Kanban board. Distinguishing claim: role authority is enforced by which tools a profile has, not by prompt instruction — the Planner literally has no write tool — backed by a rudr9-guard pre-tool-call hook as a second layer. Notably candid about its own gaps (Builder/VCM retain terminal access; a self-included Opus-authored review recommended collapsing to 3 roles, partially accepted). A dev-team-roles counterpart to the Kanban-triage template above, both using the board as coordination bus for different jobs.

  • Hermes GAPA — Self-Improvement Loop (v0.8.0) — GAPA (Get-Act-Plan-Act) is Hermes’s runtime self-evolution mechanism: every ~15 tool calls it reviews its trajectory, writes a new skill if a reusable pattern emerged, and updates MEMORY.md — “back-propagation for prompts.” 5 stages (trajectory capture → LLM review → skill creation → memory update → compounding reuse). Configurable via skills.creation_nudge_interval. Source: Agent Wikis compiled from official Hermes docs + raw/GAPA.md.

  • Hermes Memory Providers — 9 Pluggable External Memory Providers Compared — Pluggable memory backend interface (since v0.7.0): 9 external providers (Honcho, OpenViking, Mem0, Hindsight, Holographic, RetainDB, ByteRover, Supermemory, Memori) compared across cost, hosting, trust model, and setup difficulty. Only one external provider active at a time alongside built-in; no cross-provider migration path. Holographic recommended as first upgrade (zero dependencies, one command).

  • Hermes Profiles & Multi-Instance — Running Multiple Isolated Agents — A profile is a fully isolated HERMES_HOME at ~/.hermes/profiles/<name>/ — its own config, keys, memory, sessions, skills, cron, and subprocess $HOME. Added v0.6.0. Key architectural rule: two gateways on the same HERMES_HOME corrupt SQLite; profiles are the fix. Clone modes (--clone copies config/identity only; --clone-all copies everything). Wrapper scripts auto-created per profile.

  • Hermes Autonomous SWE Workflow — Model Routing via Kanban (Shubham Saboo) — Worked-example infographic + thread showing Hermes as an orchestrator that routes a coding task by complexity: simple scoped work (patches, tests, repo cleanup) → SmallCode + Ollama on a Mac mini (terminal-native agent running local models like Gemma 4 at zero API cost); hard/ambiguous work (reasoning, architecture, reviews) → Claude or Codex. Everything tracked on a single Kanban board (Backlog → Todo → In Progress → In Review → Done). Traces one feature request (“add dark mode toggle + persist preference”) end-to-end: Telegram prompt → Hermes decompose → route → parallel execute → review (Claude flags a system-theme edge case) → merge-ready settings_dark_mode.patch with 5 passing tests. The cheapest-successful-outcome principle (Puneet Shah / Lucas) pushed to a free local tier, with the routing decided structurally at decomposition time. SmallCode repo: github.com/Doorman11991/smallcode.

  • Hermes Plugin — MemeLord (karmsheel, dashboard plugin example) — Meme generation + gallery plugin for the Hermes Agent dashboard (hermes dashboard --tui --port 9119). 11 built-in templates (Drake / Distracted Boyfriend / Two Buttons / Expanding Brain / Anakin & Padme / Change My Mind / This Is Fine / Always Has Been / Bernie Sanders / Epic Handshake / Running Away Balloon) + Imgflip catalog discovery with 1h cache + drag-and-drop upload + JSON-backed humor profile (safe mode, blocked topics) + exclusive KingPepe theme (PEPE aesthetic, scanline overlay, Orbitron + Share Tech Mono). FastAPI backend (15+ endpoints, ~565 LOC) + vanilla-JS React frontend (no build step). Load-bearing read for plugin authors: worked example of the Hermes dashboard plugin-development pattern — module-level router = APIRouter(), sys.path injection for sibling imports, window.__HERMES_PLUGIN_SDK__ global, window.__HERMES_PLUGINS__.register() for tab registration, CustomEvent-based cross-tab refresh. Companion SKILL.md for agent-side use (two-surface plugin model). v0.1.0 / 1 star / MIT / Python. Surfaces the hermes-dashboard-plugin-development skill as an unindexed primary source for plugin authors. Sister plugin example to Hermes MemoryKit (same FastAPI + sibling-import pattern, different domain).

  • RoboNuggets) — Beginner-tier intro built around Jay’s recurring three-element model + harness + context framework (same framing he uses in OpenClaw Concepts). Side-by-side comparison of Claude Code vs OpenClaw vs Hermes across the three elements: Claude Code = Anthropic-only model + CLI/IDE harness + CLAUDE.md context; OpenClaw + Hermes = model-agnostic + messaging-channel-native (Telegram/Discord/Slack/WhatsApp) + skills+memory context. Distinctive contribution: explicit cross-system comparison framing in one place. Positions Hermes for stateful long-running workflows — the use case user stories catalogs. Audience signal: Jay/RoboNuggets is the same author as the OpenClaw Concepts walkthrough, credible recurring source across CC / OC / Hermes intro content.

  • Hermes Agent — Zero to Personal AI Assistant (Nate Herk 1-Hour Course) — May 2026 YouTube walkthrough by Nate Herk. Covers the five-pillar mental model (memory / skills / soul / crons / self-improving loop), Hostinger one-click VPS setup with the Docker route (KVM 2 plan, code Nate Herk for 10% off annual), OpenAI Codex authentication via ChatGPT subscription OAuth (cheapest non-open-source path), Telegram channel wiring through BotFather, the Cloud-Code-as-VPS-manager pattern (one Claude Code project tracks all VPS agents’ passwords/env/IPs/integration notes), live cron-creation demo where Hermes self-detects a daylight-savings gotcha and installs an hourly self-checked variant, multi-agent decision tree (when to spin up a new Hermes vs keep one mega-agent), and operator hygiene (least-privilege API keys, separate Gmail per agent, stale memory is the #1 cause of weird agent behavior). Sister course to Nate’s Claude Code AIOS masterclass — same operator, on-the-go surface vs desk surface.

  • Hermes MCP Catalog — One-Click Install for Nous-Approved MCP Servers — Built-in catalog of PR-reviewed MCP servers installable in one command (hermes mcp / mcp install <name> / mcp configure <name>), instead of hand-pasting JSON into config.yaml. Linear + n8n at launch (GitHub disabled for now); manifests gated by PR review into the official repo, per-tool whitelisting at install, OAuth tokens cached in ~/.hermes/mcp-tokens/, never auto-updates (sync via hermes update). Beginner-safe least-privilege install path; the curated-vetted-slice counterpart to Essential MCP Servers. Ships in the v0.15 release.

  • Set Up a Grok Subscription in Hermes Agent (xAI OAuth, No API Key) — Concrete setup walkthrough (YouTube, AI Garage) for using a SuperGrok subscription as a Hermes model provider via OAuth — no xAI API key. The Grok-subscription analog of the Codex App-Server Runtime (ChatGPT-sub → OpenAI turns). Flow: hermes update → hermes setup → select xAI Grok OAuth (distinct from the existing xAI direct-API entry, and from X-Premium Grok) → authorize “Grok build” in browser → pick Grok 4.3 (creator-reported 1M-token context). Differentiators: native X-post summarization that plain Claude Code/Codex can’t do (x.com 403s direct agent fetches), natural-sounding Grok TTS (beats default Edge TTS), Grok Imagine images (~27s) and video (Grok-exclusive vs Codex/GPT-Images — even adds audio + on-screen text). Pricing ~$30/mo, 3-day free trial (card required). Video gen must be checked on under configure all platforms or Grok can’t see the tool. Model names/prices creator-stated — verify vs official xAI/Nous docs.

  • Hermes Agent Masterclass (4-Part Hands-On Series) — Build-it-live YouTube walkthrough (AI Garage, first 4 of an 11-part series) taking a fresh WSL2 machine to a 24/7 agent. Part 1: install + ~/.hermes/ layout (config.yaml/.env/memories//state.db) + CLI/slash commands + Docker sandbox via one hermes setup terminal switch. Part 2: $6 DigitalOcean droplet + gateway as systemd service + loginctl enable-linger root to survive SSH logout + Telegram (@BotFather/@userinfobot allow-list) and Discord wiring (the Message-Content-Intent silent-empty-message trap). Part 3: four-layer memory (markdown caps + § separator + frozen-snapshot prompt-cache + FTS5 state.db session search + Honcho provider + headless Obsidian skill via OBSIDIAN_VAULT_PATH). Part 4: skill.md anatomy + progressive disclosure + skills hub + self-written-skill review fork + the v12/v13 curator (hermes curator pin) + agentskills.io portability. The hands-on, Windows/WSL2 counterpart to Nate Herk’s 1-hour course and the natural next step after Jay’s 15-minute intro.

  • Stripe Payments Skill Suite — first-party Hermes + Stripe skills (stripe-link-cli, mpp-agent, stripe-projects) for agent commerce (buy on the open web, pay-per-call APIs, provision SaaS), installed via hermes skills install official/payments/<skill>, with human-approval gates + credential isolation.

  • Hermes Accelerated Business Hackathon — Custodian, Mom-n-Pop Skills, CashFromChaos — Nous Research + NVIDIA + Stripe hackathon (292 submissions) challenging builders to run real Hermes-based commerce. 1st place Custodian: a safety kernel gating real Stripe payments with cryptographic approval receipts, a human kill switch, and self-policy-rewrite detection — a hackathon-proven, standalone parallel to Hermes’ own incoming Write Gate. 2nd — Mom-n-Pop Skills, a Telegram-only, owner-approval-gated CRM/pricing/marketing agent for non-technical small-business owners. 3rd — CashFromChaos, an end-to-end recommerce agent (photo → listing → negotiation → Stripe escrow → payout) built on Hermes + Nemotron.

  • Hermes Personal-Agent Briefing (Dmitry Shapiro, MindStudio) — practitioner what-it-is/why/how briefing: harness mental model, activity-dependent model selection, GBrain long-term-memory layer, customization dimensions, 2 metric-backed case studies.

  • Dmitry Shapiro’s Multi-Agent Hermes Architecture — Watson, Sherlock & Harry — Live-webinar walkthrough (2026-07-02) of Shapiro’s actual production setup: three named agents across two physical machines (Watson as chief-of-staff triaging Linear webhooks, Sherlock as delegate-worker, Harry running free local inference via Ollama + ComfyUI for image/video) coordinated over Tailscale, Linear webhooks, and a human-broadcast browser view. ~24 scheduled cron jobs across ingestion/CRM/Twitter-engagement/intelligence/cost-control buckets under a “silence is a feature” design principle. The concrete architecture follow-up to the conceptual briefing above.

  • Wiring Gbrain into Hermes Agent as an MCP Server — Practitioner walkthrough (Tonbi Studio) of running GBrain as a local gbrain serve MCP subprocess under Hermes — a clean three-way distinction (Hermes memory recalls only what passed through chat; an LLM-wiki knows one domain; GBrain knows your whole world, ingesting notes that never touched the agent). Demonstrates a bidirectional loop (cited reads from seeded notes, durable decision-writes back to GBrain) and explains why the MCP server beats CLI shell-outs (one long-lived process + typed tools vs. per-call process/DB-reopen cost).

  • Hermes Agent Inside Excel — Task Pane + Custom Functions via the API Server — Walkthrough (tonbistudio / @tonbistudio, same author as the multi-agent workflow template) of running the full Hermes agent — tools, memory, skills — inside Microsoft Excel two ways: a docked chat task pane and Hermes itself as custom cell functions (=HERMES.SUMMARIZE, .CLASSIFY, .EXTRACT, .FORMULA_HELP, recomputing live as referenced cells change). Both ride Hermes’ OpenAI-compatible API server (the full agent), not the model-only “proxy” — so one agent’s memory persists across sessions and even across separate Hermes projects. Setup: three .env lines (API_SERVER_ENABLED=true + SERVER_KEY + CORS ORIGINS), a Caddy reverse proxy for the HTTPS that Office add-ins require, and a yo office “Excel Custom Functions using shared runtime” scaffold sideloaded into Excel. The task pane reads/writes ranges, makes sheets, formats, and builds charts but proposes changes and only edits after approval (demo: cleaned a messy NFT P&L, ~45 changes + 4 charts). Guardrails: never write to a cell other than its own (infinite-loop risk), avoid volatile inputs (every recompute is a billed agent call), built-in cache for repeats. Open-sourced, Windows-first, at tostudio/hermes-office.

  • Hermes Architecture Explained — Memory, Context, Gateways — code-level walkthrough (HuggingFace explainer video) of the agent loop with its memory-update step, markdown-based context construction + 50%-threshold context compression, the asyncio gateway + session manager, the three memory layers (markdown + SQLite transcripts + external providers), and cron as its own tick loop reading jobs.json. The architecture-overview entry point to this topic.

  • Supabase — Team Garage walkthrough: one always-on Hermes agent (“Admiral”) self-hosting live web apps + a self-evolving wiki (agentwikis.com) on a single ~$6 droplet, using Caddy auto-TLS + git-as-database + two cron multi-agent loops (maintenance + a privacy-preserving “demand loop”), each Telegram-gated. Concrete cheap-self-host deployment pattern.

  • MLX) — Community-consensus reference (r/hermesagent megathread) for running Hermes locally on a Mac: model-by-RAM picks (16GB floor = Qwen3.5-9B; 32GB+ default = Qwen3.6-35B-A3B MoE), the backend landscape (llama.cpp / MLX-LM / Ollama / LM Studio / Rapid-MLX), and the afternoon-wasting pitfalls — MTP is a net loss on Metal, tool-calling breakage is usually the backend not the model, memory bandwidth > chip generation, the Hermes agent context tax, and KV-cache quantization. Hybrid local + cheap-cloud-fallback is the consensus. Time-stamped June 2026 — verify against Nous’s official local-LLM-on-Mac doc.

  • Hermes Models, Providers & Plans (June 2026 community snapshot) — the cloud/paid counterpart to the Apple-Silicon local-models guide: a community-maintained r/hermesagent megathread (31+ threads / 290+ comments) mapping cloud APIs, subscription plans, and provider/routing choices for running Hermes. Community picks include DeepSeek v4 Pro/Flash (orchestrator/worker split), OpenCode Go (20), owL-alpha (free via OpenRouter), Minimax token plans, and GLM-5.2; plus six routing patterns (two-tier+fallback, OpenRouter fallback pool, profile-level, event-driven, LiteLLM). All prices/plans/picks are community-reported June-2026 snapshots — verify before committing (the thread regenerates monthly).

  • Hermes tldraw-offline Skill — Driving a Desktop Whiteboard by Local HTTP API — first-party optional skill (v1.0.0, MIT, “Teknium + Hermes Agent”) announced 2026-07-23, three days after v0.19.0 and shipped as a skill install rather than a version bump. Install hermes skills install official/creative/tldraw-offline. Reads, edits, and scripts a canvas in the tldraw offline desktop app. The load-bearing detail is the mechanism: the SKILL.md explicitly rules out computer-use/GUI clicking and direct .tldraw file editing, driving the app instead through its own local HTTP API on port 7236 (Bearer token from server.json, platform-specific path, re-read on every shell call) with plain curl. Two workflows — transient POST /api/doc/{DOC}/exec against a live editor object, versus script/main.js document scripts embedded in the file so a saved .tldraw opens with interactive buttons and preserved state after the agent is gone. Gotchas are re-entrancy gotchas (scripts rerun every load → createShapeIfMissing with stable IDs; store.listen fires a tick after commit; detach listeners on signal abort; editor.run(fn, {history:'ignore'}) to stay out of undo). Generalizable lesson: check whether a desktop target already speaks HTTP on localhost before reaching for computer use — determinism over generality.

  • learn — Turn Any Source into a Skill — the /learn command (announced 2026-06-23, post-v0.17): point it at a URL, PDF, code/doc directory, video, X post, or a procedure you just performed, and the agent gathers the material with its existing tools and authors a standards-compliant SKILL.md — no hand-writing. Sourcing is live in-agent (no separate ingestion engine), so it works identically across CLI/TUI/dashboard/gateways; on a VPS it falls back to yt-dlp transcripts. Saved via skill_manage (respects the skills.write_approval gate). Load-bearing pattern: treat the generated skill.md as a PRD handed to a coding agent. Community refinement (@jumperz): add a “Learnables” research-review space before saying “learn this.”

  • A Hermes “Digital Nervous System” — 28 Crons, 30+ Self-Built Skills — one power user’s (u/HolmeBengt) end-to-end build: 28 cron jobs + 30+ single-file self-built skills running student/business/health/finance ops. Standouts: Dreaming (nightly conversation→structured-summary written to an auto-loading session-start file — the lesson is where the summary lands), Mail Gatekeeper (on-device Ollama judge, no send endpoint exists, evening false-positive watchdog), a self-improving writing loop (corrections → weekly pattern analysis → Hermes edits its own system prompt), and a build discipline of one-file/one-job/no-dependencies skills (“self-built beats downloaded”). Single-creator self-report.

  • AI Signal Engine — a Hermes-Driven Agentic News Map — MattVidPro open-source build: a persistent Hermes agent on a VPS scans AI news and POSTs scored JSON signal-events into a separate dashboard it does not otherwise control. The reusable bit is the security boundary — agent on its own VPS, dashboard behind a user-set password, agent gated by a separate ingest token, no-destructive-actions/no-publishing + per-claim verification flags in the prompt. Model-agnostic (demoed with GPT-5.5 via OpenRouter). Medium confidence (single-creator).

Computer control

  • Hermes Computer Use + Venice API — Private macOS Control Tutorial — YouTube tutorial walkthrough (creator unnamed but Venice-affiliated per closing Discord CTA) of installing Hermes against Venice’s zero-data-retention model surface — Venice custom endpoint https://api.venice.ai/api/v1, Diem-token-staking returns 0.85/6.25/$37.50) / DeepSeek v4. Self-cleanup pattern — the agent edits its own skill manifests under a custom role prompt (“be my computer manager”) and cuts the system prompt from 5.2 MB to 160 KB (97%). Hermes Computer Use (NEW) activated via the Kua driver on macOS with dual permission grants (screen recording + accessibility, terminal relaunch between each); known screenshot context-window-overload bug that the agent can patch in its own code. Apple Reminders + cron-job daily-check-in workflow; theoretical Xcode-built desktop widget bounded by macOS’s read-only widget restriction. Privacy-vs-capability trade-off explicitly disclosed — open-source models on Venice are cheaper and zero-retention, less capable than Opus 4.7 or GPT 5.5 for agentic computer control.

Releases

  • Hermes Agent v0.19.0 — The Quicksilver Release — Latest release (2026.7.20), from the official GitHub release notes (fetched at ingest). Theme = speed: first-turn TTFT cut ~80% on every platform (4.3s→0.9s example), reasoning streams live by default, a ~20-PR desktop overhaul (14x faster streaming markdown, virtualized diffs, snappy session switching), incremental TUI markdown. Around that spine: manage your Nous subscription from the terminal (/subscription + /topup), Bitwarden/1Password SecretSource integration, smart approvals (LLM per-command verdicts, /deny) on by default, tail -f live subagent transcripts, and a durable state.db delivery ledger so a finished response survives a gateway crash. ~2,245 commits / ~1,065 PRs / 450+ contributors since v0.18.0; rolls up the v0.18.1/.2 patch tags. Successor to the v0.18 Judgment Release.
  • Hermes Agent v0.18.0 — The Judgment Release — Released 2026.7.1, confirmed against the official GitHub release notes (cross-checked 2026-07-02). A P0/P1 backlog clean sweep (949 issues + 998 PRs closed over 12 days; ~692 were the P0/P1 subset, 1,720 commits / 370+ contributors) plus Mixture-of-Agents promoted to a first-class moa model provider — and self-verification against evidence, /goal completion contracts, /learn + /journey, a scale-to-zero gateway, desktop coding projects + a playable memory graph, background subagents, and Vertex AI as a provider. Successor to the v0.17 Reach Release.
  • Hermes Agent v0.17 — The Reach Release — Released 2026-06-19. Theme = reach across channels and memory: native iMessage + official WhatsApp + Raft messaging surfaces, atomic batch memory operations, background subagents, image-to-image generation, and a Skills Hub rehaul with per-skill security scanning. Successor to the v0.16 Surface Release.
  • Hermes Agent v0.16 — The Surface Release — Major release (2026-06-05; 874 commits / 542 PRs / 399 issues closed / 170 contributors since v0.15.2). Theme = real surfaces beyond the terminal: a native desktop app (macOS/Linux/Windows, one-click install + in-app self-update, Cmd+K palette, remote-gateway connect), a feature-complete web dashboard admin panel (MCP catalog toggles, channels, credentials, webhooks from the browser), “Tool Search” / progressive tool disclosure (agents load only the tools they need), Quick Setup via Nous Portal, /undo [N] + /title, a skills overhaul (environments: relevance gate, NVIDIA Skills Hub tap, usage tracking), new models (MiniMax-M3 1M-ctx, deepseek-v4-flash, qwen3.7-plus, gemini-3.5-flash), Kanban goal_mode, username/password + self-hosted OIDC auth, and a CVE-2026-48710 patch + 16 security fixes. Official changelog confirms several creator-reported v0.15 increments. Successor to the v0.15 Velocity Release.
  • Hermes Agent v0.15 — The Velocity Release — Architecture-and-speed release bundled from two weeks of incremental rollouts. Headline: core refactor of the main loop (run_agent.py 16K → 3,800 lines across 14 modules) so hermes update stops breaking things; startup --version 700→258ms; per-turn overhead 399K→213K calls; session search rebuilt without an LLM (90s → 20ms) + full verbatim session resume; Kanban Swarm (root task → parallel workers + verifier + synthesizer, worktree-per-task, claim TTL, retry fingerprinting); brainworm/prompt-ware blocked at 3 choke points (tool output / recalled memory / stored skills) + 15 threat patterns; Notify (23rd channel), Korea image-gen, Bitwarden secrets, the MCP Catalog. Creator-reported figures (verify vs official changelog). Builds on the v0.14 Foundation Release.
  • Hermes Agent v0.14.0 (v2026.5.16) — Foundation Release — Placeholder article for the May 16, 2026 Foundation Release. Reddit-announcement summary captures the delta-over-v0.13.0 scale (808 commits / 633 PRs / 1,393 files / 165k insertions / 545 issues closed / 215 contributors) and the “installs and runs anywhere” tagline. Refreshed 2026-05-20 with the YT walkthrough’s 6 headline features (XAI OAuth Grok/X access / macOS Computer Use / native Windows / Teams integration / hermes update + debloat / video integrations) plus a 7th — Skill Bundles (slash-command-driven multi-skill YAML bundles like /release-prep, /incident-response, /research-sprint; sourced to hermes-agent.nousresearch.com/docs, Reddit signal r/hermesagent 2026-05-20). Full GitHub release notes still pending an ai-research pull.

OpenClaw is the adjacent agent framework Hermes is most often compared and migrated from — see user stories for the documented OpenClaw → Hermes shadow-mode migration path, and Jay’s 15-minute intro for the Claude Code / OpenClaw / Hermes side-by-side.

For end-to-end agent infrastructure context, see Agents & Agentic Systems.

Graph View

Backlinks