This is a submission for the Hermes Agent Challenge: Write About Hermes Agent

Most AI agents have a dirty secret: they forget everything the moment the session ends.

You explain your project once. Then again next time. And again. The agent never gets better at your workflow — it just stays a general-purpose tool that happens to be smart.

Hermes Agent is built differently. It ships with two systems that together form something closer to a genuine long-term memory: a Skills System and a Persistent Memory layer. This post digs into how they actually work — not the marketing summary, but the mechanics.

The Problem With Stateless Agents

Before getting into Hermes, it's worth understanding what problem this solves.

Standard LLM-based agents operate inside a context window. Everything the agent knows during a session lives in that window. When the session ends, it's gone. The next time you open a conversation, you're talking to an agent with no memory of you, your codebase, your preferences, or the workflows you've developed together.

Some tools patch this with naive "memory" — they dump a text blob of past conversations into the system prompt. This works up to a point, but it's not selective, it gets expensive as context grows, and it doesn't help the agent get better at tasks — just recall facts.

Hermes takes a different approach with two distinct systems serving different purposes.

System 1: The Skills System (Procedural Memory)

Skills in Hermes aren't plugins you install. They're on-demand knowledge documents — markdown files the agent loads when it needs them, and more importantly, creates on its own when it discovers something worth remembering.

The SKILL.md Format

Every skill is a structured markdown file with a YAML frontmatter header:

---
name: deploy-runbook
description: Our deployment runbook — services, rollback, Slack channels
version: 1.0.0
metadata:
  hermes:
    tags: [deployment, runbook, internal]
    requires_toolsets: [terminal]
---

# Deploy Runbook

## When to Use
Trigger conditions for this skill.

## Procedure
1. Step one
2. Step two

## Pitfalls
- Known failure modes and fixes

## Verification
How to confirm it worked.

The structure is deliberate. It teaches the agent when to use the skill, how to execute it, what can go wrong, and how to verify success. That's not documentation — that's an executable procedure.

Progressive Disclosure: How Skills Load Efficiently

Here's where it gets clever. Skills don't get dumped into the context window all at once. They use a progressive disclosure pattern across three levels:

Level 0: skills_list()          → [{name, description, category}, ...]   (~3k tokens)
Level 1: skill_view(name)       → Full content + metadata                 (varies)
Level 2: skill_view(name, path) → Specific reference file                 (varies)

The agent first sees just names and descriptions — a light index. It only loads the full skill content when it actually needs to. And within a skill, supporting reference files are only fetched at level 2 when specifically required.

This means you can have 50+ skills installed and the token overhead is minimal — only what's relevant gets loaded per task.

The Agent Creates Its Own Skills

This is the most underrated part. Hermes automatically creates new skills through the skill_manage tool when:

• It completes a complex task (5+ tool calls) successfully
• It had to recover from errors and found the working path
• You corrected its approach mid-task
• It discovers a non-trivial multi-step workflow

The skill_manage tool has targeted actions:

In practice, this means the agent gets better at your specific environment over time. If you have a particular deployment process, a quirky internal API, or a custom build system — after you walk through it once, the agent writes that down as a skill. Next time, it just uses the skill.

Slash Commands: Skills as First-Class UX

Every installed skill is automatically available as a slash command:

/deploy-runbook                    # loads the skill and asks what you need
/github-pr-workflow create a PR for the auth refactor
/plan design a rollout for migrating our auth provider

You can invoke them from the CLI, Telegram, Discord — any platform Hermes is connected to.

The Skills Hub: A Community Ecosystem

Beyond agent-created skills, there's a whole ecosystem of installable skills from multiple sources:

hermes skills search kubernetes
hermes skills install openai/skills/k8s
hermes skills install well-known:https://mintlify.com/docs/.well-known/skills/mintlify
hermes skills install https://sharethis.chat/SKILL.md   # direct URL

Supported sources include skills.sh (Vercel's directory), well-known endpoints, GitHub repositories, ClawHub, LobeHub, and browse.sh (200+ site-specific browser automation skills for Airbnb, Amazon, arXiv, etc.).

All hub-installed skills go through a security scanner checking for data exfiltration, prompt injection, and destructive commands before installation.

Skill Bundles: Task Profiles

When you always need the same set of skills together, bundle them:

hermes bundles create backend-dev \
  --skill github-code-review \
  --skill test-driven-development \
  --skill github-pr-workflow \
  -d "Backend feature work — review, test, PR workflow"

Then /backend-dev refactor the auth middleware loads all three skills at once. You can ship team-wide task profiles by checking the bundle YAML into a shared dotfiles repo.

System 2: Persistent Memory (Episodic + Semantic Memory)

Where the Skills System handles how to do things, the Memory System handles what it knows about you and your context.

Hermes uses FTS5 full-text search with LLM summarization for cross-session recall. But the more interesting part is how it decides what to remember.

The Curator: Selective Memory Formation

Not every conversation detail is worth persisting. Hermes has a "Curator" component that periodically reviews recent interactions and decides what's actually worth storing long-term. This is closer to how human memory consolidation works — important, repeated, or explicitly notable information gets retained; noise gets discarded.

The agent also nudges itself to persist knowledge — meaning it's not purely passive. When it recognizes it's learned something worth keeping, it actively writes a memory entry rather than waiting for the Curator's next pass.

Honcho: Dialectic User Modeling

The third piece of the memory architecture is integration with Honcho, which Hermes uses for what the docs call "dialectic user modeling."

Rather than just storing facts about you as a flat list, Honcho builds a structured model of who you are — your working style, your preferences, the kind of errors you typically make, what you care about. This model updates through interaction, not just through explicit "remember this" commands.

The practical result: the agent's responses adapt to you over time without you having to constantly re-explain your context.

Why This Architecture Matters

Here's what separates this from "we added memory" marketing:

1. Skills are inspectable and editable. They're markdown files in ~/.hermes/skills/. You can read them, edit them, delete them. There's no black box — you can see exactly what procedural knowledge the agent has built up.

2. The agent improves on the right signal. It creates skills after complex multi-step tasks, after errors, after corrections — not after every conversation. This keeps the skill library focused on non-trivial knowledge.

3. Memory and skills serve different purposes. Skills are for procedures and workflows. Memory is for facts, preferences, and context. Mixing them up is a common mistake in agent design. Hermes keeps them separate.

4. The ecosystem is open. The agentskills.io standard means skills are portable across compatible agents. Publishing a tap is just pushing to a GitHub repo. No lock-in.

The Real Test: Does It Actually Get Better?

The honest answer is: it depends on how you use it.

If you just ask one-off questions, you won't see much difference from a stateless agent. The memory and skills systems only compound value over repeated, complex interactions where procedures are worth encoding.

But if you're using Hermes for a real project — deploying code, managing a workflow, running research pipelines — the self-improving loop starts to show up. After a week of use, the agent's skills directory fills with your actual workflows, not generic templates.

That's the bet Nous Research is making with Hermes: that the future of useful AI agents isn't a smarter model, it's an agent that gets smarter at your specific context over time.

Whether that bet pays off depends on how much the skills and memory systems can actually automate the knowledge capture process — reducing the burden on you to explicitly teach the agent things. Based on the architecture, the foundation is sound. The proof is in extended use.

Getting Started

# Install (Linux / macOS / WSL2)
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Setup with Nous Portal (covers model + web search + image gen + TTS)
hermes setup --portal

# Browse available skills
hermes skills browse

# Start a session and ask Hermes to teach itself your workflow
hermes chat

Full documentation: hermes-agent.nousresearch.com/docs

If you found this breakdown useful, the Skills Hub is worth exploring — the community ecosystem is growing fast.