Since February 2026, Hermes Agent from Nous Research (MIT) has dominated the “self-evolving agent” conversation on GitHub and Hacker News. Unlike Copilot-style completion or one-off ChatGPT tabs, Hermes is built around a long-running process, cross-session memory accumulation, and automatic Skill extraction after tasks complete. You send a message on Telegram; it runs shell, browses the web, and edits your Git repository in the background—closer to a colleague hosted on your infrastructure than to a browser widget.

That positioning immediately raises a hardware question. The Closed Learning Loop depends on a Gateway daemon, cron schedules, and SQLite session indexes staying active. Lid-close, power maintenance, and occasional OOM restarts do not erase ~/.hermes/skills/, but they do make “always-on agent” a misnomer. Community debate has shifted from “is the model strong enough?” to “what machine should I rent for this agent?”—which is exactly the search intent this article addresses.

If you already ran a month-long trial, the 30-day diary shows how Skills compound in practice. Here we stay at the architecture layer: what each memory tier does, and why uptime is part of the design—not an ops afterthought.

Bottom line upfront: Hermes value compounds over time; hardware selection is really about keeping process and disk state continuously online. The next sections walk from memory layers to concrete Mac Mini sizing.

Official and community docs often summarize Hermes memory in three layers, mapping the journey from “this conversation only” to “it knows me better over weeks”:

Layer 1 — short-term session context (the opposite of stateless chat): Messages and tool results inside the current thread, bounded by the context window. After the process stops or sits idle too long, this layer does not fully remain in model context; lower layers must backfill.

Layer 2 — Skill Documents (procedural memory): After complex tasks, the Closed Learning Loop distills the solution path into Markdown Skills under ~/.hermes/skills/. Similar jobs later load them via progressive disclosure, cutting tokens and failure rates. This is the main source of “it gets faster the more it runs.”

Layer 3 — cross-session persistent user model: Core Memory files such as USER.md, MEMORY.md, and SOUL.md inject every session; Episodic Memory indexes historical sessions with SQLite FTS5 so you can resume topics weeks later. Together, the three layers form a persistent agent—not a stateless API wrapper.

curl -fsSL https://get.hermes-agent.org | bash
hermes gateway start
ls ~/.hermes/skills/
hermes memory search "deploy checklist"

Backends can be Nous Portal, OpenRouter, or local Ollama, llama.cpp, or MLX; Skills and memory files are not locked to one model weight. But if Gateway only wakes a few times per week, Episodic time continuity fractures and you manually re-ground context—so the “persistent” feeling collapses even though files still exist on disk.

Operators sometimes conflate “memory architecture” with “bigger context windows.” For Hermes, the durable win is procedural reuse: the second deploy checklist run should cost fewer tokens and fewer tool retries because Layer 2 captured the path. That only pays off when Layer 3’s SQLite index stays warm and cron can prune or compact on schedule—again, a 24/7 host assumption.

Capacity planning is straightforward once you map layers to disk: Core Markdown files stay small; Skills grow with successful tasks; Episodic SQLite and rotated session logs dominate long-horizon storage. Teams running API-only orchestration through OpenRouter or Nous Portal often stay comfortable on 16GB·256, while parallel local Hermes-3 or MLX workloads push you toward 24GB·512 so recall and inference do not compete for the same unified memory pool on Apple silicon.

A common search query asks whether restart wipes Skills. The precise answer: files usually remain; runtime rhythm and continuity suffer.

This mirrors stability issues in OpenClaw Gateway persistence: agents deployed like throwaway scripts instead of 24/7 services. You want launchd-level supervision, health probes, and predictable online windows—not comfort that “files are still on the drive.” See cron health probes for patterns you can reuse with Hermes.

Backup discipline matters: tarball ~/.hermes/ before host changes, verify restore on a staging Mac, then cut over channel tokens. Continuity is both process uptime and operational habit.

Search traffic often frames the problem as “will my Skills vanish?” The better operational question is “will my agent still answer Telegram at 3 a.m. and run the nightly doc sync?” File persistence without Gateway persistence creates a zombie archive: rich Skills on disk, zero compounding behavior. That is why production setups treat Hermes like any other always-on service with monitoring, not like a CLI you invoke when remembered.

Hermes officially supports macOS; curl -fsSL https://get.hermes-agent.org | bash installs dependencies in one step. Local inference can use Metal-optimized llama.cpp or MLX (see Nous docs Run Local LLMs on Mac). Mac Mini M4 advantages for this workload are structural:

Unified memory (UMA): 16GB or 24GB shared addressing leaves headroom for agent runtime (often under 2GB) plus 13B-class local models—unlike many x86 mini PCs without a Metal path. Power and noise: roughly 10W idle, suitable beside a rack 24/7. Footprint: no desk space, ideal as a dedicated agent server. Use cases: developers who want Hermes to remember architecture preferences for doc maintenance; creators who accumulate topic Skills; researchers who turn paper workflows into reusable Skills.

Region and term selection: six-region guide. Memory tiers: storage and RAM sizing.

When your agent edits a remote Git repository, shell latency and DNS resolution on the host matter as much as model IQ. A dedicated Mac Mini placed near your primary git remote and API egress reduces round trips on multi-step tool chains—especially for creators running nightly publishing Skills or researchers batching paper-ingestion workflows. Quiet 24/7 operation also keeps Episodic timestamps trustworthy; gaps in uptime show up as holes in “what did we decide last Tuesday?” recall.

Buying a Mac Mini M4 (24GB·512 as reference) means high upfront cost, depreciation, and M-series refresh risk on your balance sheet. Monthly rental converts CapEx to budgetable OpEx with upgrade and wipe-before-return options—ideal when you want to validate Hermes compounding before owning hardware. Prices follow the pricing page:

Wiki-ready bullets: ① Hermes Agent shipped MIT in February 2026 and quickly entered top open-agent discussions (star counts change—check the repository live). ② Default memory lives on the local machine under ~/.hermes/ with no vendor telemetry by design. ③ Official docs separate Core, Procedural, and Episodic layers; procedural Skill reuse pays the most for repeated ops and content pipelines.

Quick pick: Developers—16GB suffices for API-only, 24GB for local Hermes-3; Creators—stability beats peak FLOPS; Researchers—do not starve SQLite or disk for Episodic growth.

Alternatives on the table: occasional laptop use grows files while Gateway stays offline; long-term cheap VPS saves rent but costs Linux compatibility and RTT; buying a Mac Mini loads CapEx and refresh risk on you. Monthly dedicated Mac Mini M4 rental on KVMNODE lets all three memory layers compound in a 24/7 macOS environment: native tooling, predictable OpEx, portable ~/.hermes/, wipe on return—usually less painful than “good enough VPS” for production Skill accumulation. See pricing for tiers.

If you are evaluating Hermes alongside OpenClaw or other persistent gateways, the decision matrix is similar: pick hardware that preserves process continuity first, then optimize model cost second. The three-layer design rewards months of stable uptime more than a weekend of heroic tuning. Start with a rented Mac Mini in the region closest to your collaborators, migrate ~/.hermes/ once, bind channels, and let Skills accumulate before committing to purchase—your future self will read the Episodic index, not re-explain preferences from scratch.