If you have spent any serious time developing with AI assistants over the past two years, you know the frustration of the amnesiac loop. You open a terminal, spend twenty minutes walking an agent through your build quirks, debug a gnarly linker issue, teach it your repository conventions, and feel a momentary surge of productivity. Then you close the shell. The next morning, you open a fresh session—and you are back at square one, re-explaining the exact same idiosyncrasies to an agent that has forgotten everything you ever did together.
Most agent frameworks treat persistence as an afterthought—perhaps an append-only JSON file dumped into a scratch directory or an unwieldy vector database that drowns simple instructions in noisy embeddings. When I started experimenting with Hermes Agent several months ago, I expected another short-lived weekend toy.
Instead, Hermes became an integral part of my daily engineering toolkit. Why? Because it approached agent design from a fundamentally different premise: treating long-term memory, procedural playbooks, and autonomous skill evolution as first-class architectural primitives.
After months of relying on Hermes in production and authoring custom workflows for it, I found myself facing a different bottleneck — the quality and reliability of community skills. To solve that, I built and open-sourced a new repo on GitHub: hermes-skills-foundry.
Before diving into what the foundry provides, let’s look at why Hermes Agent is architecturally distinct.
What Hermes Agent Actually Is
In May 2026, tech writer and engineer Akshay Pachaar published an excellent deep dive titled Hermes Agent Masterclass (which I highly recommend reading). As Akshay detailed, Hermes crossed 90,000 GitHub stars within just two months of release—not because of marketing fanfare, but because developers were quietly setting up personal agents capable of compounding knowledge over time.
Drawing from Akshay’s comprehensive breakdown, Hermes centers on several core engineering pillars:
1. A Single, Synchronous Core Agent
Unlike complex multi-agent orchestrations that splinter into unmanageable asynchronous state machines, Hermes drives everything through a single, synchronous AIAgent ReAct loop inside run_agent.py. Whether you invoke it from the CLI, hook it into a messaging gateway like Telegram, trigger batch runs, or integrate it into an IDE, the execution loop remains uniform and deterministic. It enforces a strict budget (a hard cap of 90 turns per task), ensuring runaway tool delegation loops cannot silently drain your API balances.
2. Hand-Authored Identity via SOUL.md
Before memory or skills load, Hermes defines who the agent is through SOUL.md. Placed deliberately in slot #1 of the system prompt, this hand-crafted, static Markdown document establishes the agent’s baseline temperament, critical reasoning style, and hard boundaries. Memory and learned playbooks are constantly interpreted through the lens of this identity.
3. Three-Tier Memory Architecture
Hermes abandons monolithic context dumping in favor of a three-tiered approach:
- Tier 1 (Working Context): Two concise Markdown files (
MEMORY.mdcapped at 2,200 characters for project and environment facts, andUSER.mdcapped at 1,375 characters for user preferences). Both load as frozen snapshots at session start. When memory reaches ~80% capacity, the agent consolidates entries into denser summaries. - Tier 2 (Searchable Recall): Every conversational exchange across CLI and gateways is indexed in a local SQLite database with FTS5 full-text search, allowing on-demand querying over weeks of dialogue.
- Tier 3 (External Integrations): Pluggable providers running alongside native memory to prefetch memories before turns and extract takeaways at session completion.
4. Self-Evolving Skills and the Curator
Facts live in memory, but procedural workflows live in skills—modular Markdown files with YAML frontmatter. Skills employ progressive disclosure: level 0 displays metadata to keep the prompt lean, level 1 loads procedural instructions on demand, and level 2 exposes deep reference files.
Hermes can author its own skills via skill_manage when solving non-trivial tasks. To keep this library from bloating into hundreds of redundant fragments, Hermes includes The Curator: an offline maintenance pass (triggered by inactivity, not a blunt cron daemon) that evaluates agent-authored skills, archives unused ones to .archive/, and snapshots the entire directory beforehand so rollbacks are trivial. Crucially, the Curator never touches bundled or hub-installed skills.
For rigorous offline prompt optimization, Nous Research also introduced GEPA (Genetic-Pareto Prompt Evolution), an evolutionary search engine that uses real execution traces and rubric-based evaluations to refine skills without requiring expensive weight fine-tuning.
5. Multi-Agent Isolation via Profiles
Hermes supports first-class profiles (one can build a new profile via command line in one shot withhermes profile create <name> --clone), enabling completely isolated instances—each with its own SOUL.md, memory tiers, skills, and messaging gateway tokens.
A clean framing from the Kilo blog, highlighted in Akshay’s analysis, summarizes the design philosophy perfectly:
“Hermes packages a gateway around a learning agent. OpenClaw packages an agent around a messaging gateway.”
The Problem: Quantity vs. Verifiable Evidence
As Hermes gained popularity, the community quickly spun up registries and skill hubs. But as any software engineer knows, package repositories that optimize purely for catalog size quickly degrade into a minefield of broken promises.
When exploring community skill collections, I kept hitting the same recurring issues:
- Untested procedures: Prompts that sound persuasive to an LLM but invoke nonexistent CLI flags, outdated APIs, or broken regexes.
- Hidden environmental dependencies: Skills that secretly depend on an external proprietary code assistant, specialized cloud accounts, or undeclared local binaries.
- Version mismatches: Skills written against older Hermes runtime assumptions that silently fail or degrade the prompt cache on newer releases.
- Zero attribution: Community forks copying upstream skills without retaining licenses or noting what was modified.
Generic skill collections celebrate having hundreds of skills. But when an agent is executing shell commands against your repositories, count is meaningless without evidence of correctness. You don’t need 500 unvetted prompt files; you need confidence that the skill actually works, runs cleanly on your installed version of Hermes, and won’t hallucinate halfway through a refactor.
Introducing Hermes Skills Foundry
To solve this, I created hermes-skills-foundry: an independent, MIT-licensed community repository dedicated to curated, verifiable Hermes skills.
The foundry is designed around answering three pragmatic questions before a skill ever touches your machine:
- Does it work?
- Where did it come from?
- Will it run on my Hermes version?
┌────────────────────────────────────────────────────────┐│ The Foundry's Four Gates │├─────────────────┬──────────────────────────────────────┤│ 1. Structure │ Schema & lint validation via script ││ 2. Behaviour │ Executable eval fixture & pass rate ││ 3. Provenance │ Upstream license & NOTICE changelog ││ 4. Compatibility│ hermes_requires range & no lock-in │└─────────────────┴──────────────────────────────────────┘The Four Gates
Every skill admitted to the foundry must clear four mandatory gates:
- Structure Gate: Validated automatically by
scripts/validate.py. Frontmatter structure, metadata fields, directory organization, andreferences/layouts must strictly adhere to the specification. - Behaviour Gate: Every skill must carry an evaluation fixture in
evals/. We require measured pass rates where an objective test is meaningful, or an honest, transparentpendingstatus where current benchmarks cannot reliably discriminate performance. - Provenance Gate: Any ported skill must include an explicit attribution header, preserve the original upstream license, and supply a
NOTICEfile documenting exact modifications. - Compatibility Gate: Each skill must declare a tested
hermes_requiresversion constraint range and operate strictly engine-agnostic—no mandatory dependencies on proprietary external code assistants.
The Real Product: The Standard
While the repository ships ready-to-use skills, its primary contribution is the standard documented in docs/standard.md. It codifies the contract for what a robust Hermes skill looks like: YAML frontmatter schemas, progressive disclosure patterns, reference file structuring, licensing boundaries, and evaluation design.
Licensing is managed cleanly on a per-skill basis: the foundry itself is MIT-licensed, while ported skills preserve their upstream licensing (for example, the hermes-skill-creator skill retains its upstream Apache-2.0 license).
What’s Inside Today
The foundry launches with two battle-tested skills:
hermes-profile-creator: A dedicated skill for designing and scaffolding isolated Hermes profiles andSOUL.mdpersonas. It handles profile scaffolding, persona definition, and distribution packaging so you can spin up tailored agents cleanly.hermes-skill-creator: The foundational meta-skill for creating, testing, and iteratively refining Hermes skills. Ported fromanthropics/skills(under Apache-2.0) and adapted for Hermes, it manages initial drafting, comparative evaluation runs (with and without the skill active), benchmarking, and generating an HTML review viewer to inspect results. It is fully engine-agnostic: no external code assistants are required to run it, though you can optionally incorporate one if desired.
How to Install and Inspect Skills
Because the repository conforms to Hermes’s native skill resolution and is indexed on skills.sh, installing a skill directly from the foundry requires a single command:
hermes skills install sentenza/hermes-skills-foundry/skills/<skill-name>For instance, to install the profile creator:
hermes skills install sentenza/hermes-skills-foundry/skills/hermes-profile-creatorIf you prefer to inspect the skill’s instructions, frontmatter, and references before pulling it down, use the preview command:
hermes skills inspect sentenza/hermes-skills-foundry/skills/hermes-profile-creatorJoin the Foundry
If you have been treating LLM agents as ephemeral chat widgets, I encourage you to spend a week using Hermes Agent with persistent memory and custom profiles. Once you experience an agent that remembers your corrections and leverages curated playbooks, it is difficult to go back.
Check out the repository, try the skills, read docs/standard.md, and consider contributing your own battle-tested skills through our four-gate pipeline:
👉 Repository: https://github.com/sentenza/hermes-skills-foundry
Whether you are porting high-utility community skills or building new meta-workflows from scratch, let’s build an ecosystem where skills are proven to work before they ever run in your shell.