skillsmemoryintermediateself-improvement

Skills: Teaching Your Agent to Learn

By Hermes Agent· · 5 min read

Hermes Agent's skills system lets your agent remember how to do things, get better over time, and build a personal playbook of expertise.

TLDR: Skills are reusable, versioned, self-improving procedures that Hermes Agent writes, uses, and maintains. They’re stored as markdown files with YAML frontmatter in ~/.hermes/skills/. Load them with /skill name or hermes -s "name". The curator subsystem manages their lifecycle (active → stale → archived, but never deleted). Skills are what make Hermes fundamentally different from other AI agents — they give it procedural memory that compounds over time.

Key Takeaways

  • Skills are markdown documents with structured frontmatter — the agent reads them as system prompt context
  • Any procedure that takes 5+ tool calls is worth saving as a skill
  • The curator (hermes curator) auto-manages skill lifecycle
  • Skills compose — load multiple for complex tasks
  • Hub at hermes skills search for community skills

What Is a Skill?

A skill is a markdown document with YAML frontmatter. It lives in ~/.hermes/skills/ and gets loaded into the agent’s system prompt when activated.

---
name: my-skill
description: "What this skill does"
version: 1.0.0
platforms: [linux, macos, windows]
---
# Skill Title

Instructions, code examples, pitfalls, and verification steps.

Think of it as a README for a specific task — written by the agent, for the agent. Unlike memory, which stores facts, skills store procedures.

How Skills Work

When you start a session with skills loaded, the agent reads each skill’s content as part of its system prompt. It can then:

  • Follow the numbered steps in the skill
  • Reference the exact commands and examples
  • Apply known pitfalls and edge cases
  • Update the skill when it discovers something new

Loading Skills

Four ways to load a skill:

# 1. Preload on startup
hermes -s "my-skill"

# 2. Load mid-session
/skill my-skill

# 3. Load multiple
hermes -s "my-skill" -s "another-skill"

# 4. Search and install from the hub
hermes skills search "debugging"
hermes skills install "systematic-debugging"

What Makes a Good Skill

QualityWhy it matters
Clear trigger conditionsTell the agent when to use this skill
Numbered stepsAgents execute procedurally — step-by-step works best
Exact commandsNo placeholders or guesswork
Pitfalls sectionThe most valuable part — captures mistakes so they never repeat
Verification stepsHow to confirm the procedure worked

Template

---
name: deploy-docker
description: "Deploy a Docker Compose stack with zero-downtime rolling updates"
version: 1.0.0
platforms: [linux]
---

# Deploy Docker Compose

Trigger when: user says "deploy", "release", or "ship the stack"

## Steps

1. Pull latest images
   ```bash
   docker compose pull
  1. Deploy with rolling update 
    docker compose up -d --no-deps --build --scale app=2
  2. Verify health 
    curl -f http://localhost:8080/health

Pitfalls

  • If port 8080 is in use, check docker compose ps for conflicts
  • Do NOT run docker compose down — that’s downtime

Verification

  • docker compose ps shows all services as Up
  • Health endpoint returns 200

## The Skill Lifecycle

The **curator** subsystem (`hermes curator`) manages skill evolution automatically:

1. **Active** — the skill is regularly used
2. **Stale** — hasn't been used in a while, flagged for review
3. **Archived** — removed from active set but **preserved forever** (never deleted)
4. **Pinned** — excluded from auto-archiving

```bash
hermes curator status         # See all skills and their state
hermes curator pin my-skill   # Protect from archiving
hermes curator run            # Run maintenance cycle now

Creating Your First Skill

Let’s create one manually:

mkdir -p ~/.hermes/skills/

cat > ~/.hermes/skills/my-first-skill.md << 'EOF'
---
name: my-first-skill
description: "A template skill to get started"
version: 1.0.0
---

# My First Skill

## Steps
1. Do something
2. Verify it worked
EOF

Or just ask the agent during a session: “Save this workflow as a skill so you can do it again.”

Skills vs Memory

MemorySkills
Facts about you, preferences, environmentReusable procedures and workflows
”User prefers concise responses""How to deploy the app”
Injected every session automaticallyLoaded on demand
Small, factualStructured, actionable
Updated by agentCreated/patched by agent

Save to memory when: user preference (“I use pnpm”), environment fact (“Running on Arch Linux”), correction (“Don’t use apt for this”).

Save as skill when: complex workflow completed (5+ tool calls), tricky error fixed, non-trivial workflow discovered.

The Skills Hub

Community skills are searchable and installable:

hermes skills search "testing"              # Find test-related skills
hermes skills install "systematic-debugging"  # Install from hub
hermes skills publish ~/my-skill.md         # Publish your own
hermes skills tap add github.com/user/repo  # Add a custom repo source

Available hub skills include: systematic debugging, test-driven development, code review, DSPy, vLLM, GitHub PR workflow, and many more.

FAQ

Q: How many skills is too many? The curator auto-archives stale skills. Focus on quality over quantity — a well-maintained skill is worth more than 10 dusty ones. Pin your most important skills with hermes curator pin.

Q: Can skills reference other skills? Not directly, but you can load multiple skills together: hermes -s "skill-a" -s "skill-b". The agent sees all loaded skills in its system prompt.

Q: What happens to deleted skills? The curator never deletes skills — maximum destructive action is archive. Archived skills remain in ~/.hermes/skills/.archive/ and can be restored with hermes curator restore.

Next Steps