Skills, MCP, and the Self-Authoring Loop

Hermes approaches external capabilities differently from OpenClaw. Instead of downloading thousands of pre-authored skills from a central marketplace, Hermes ships with a small set of robust built-ins and is designed to generate new skills from its own successful task trajectories.

This lesson covers all three capability layers: built-in tools, Model Context Protocol (MCP) servers, and the self-authoring skill loop.

The Three Layers

Layer 1: Built-in Tools

Out of the box, Hermes has 47 tools spanning:

• Filesystem: read_file, write_file, edit_file, list_directory, search_files
• Shell: run_command, run_background, kill_process
• Web: web_fetch, web_search
• Git: git_status, git_diff, git_log, git_commit
• Code: run_python, run_javascript, format_code
• Memory: memory_save, memory_recall, memory_summarize

These cover ~80% of what you'll ever ask the agent to do. See /tools in the TUI for the full list.

Layer 2: Model Context Protocol (MCP)

MCP is the open protocol Anthropic introduced for connecting AI agents to external tool providers. Hermes is a first-class MCP client.

Install an MCP server from the registry:

uv run hermes mcp install @upstash/context7-mcp
uv run hermes mcp install @modelcontextprotocol/server-filesystem
uv run hermes mcp install @cloudflare/mcp

Each server exposes a set of tools that become available inside the TUI as if they were built-in. Type /tools to see them merged into the list.

Remove with hermes mcp remove <name>. List with hermes mcp list.

Layer 3: Skills (agentskills.io)

A skill is a self-contained folder with procedural instructions and optional scripts. Hermes adopts the agentskills.io open spec, which standardizes the folder layout:

my-skill/
├── SKILL.md        # operational manual — the required file
├── scripts/        # optional helper scripts (any language)
└── examples/       # optional reference inputs/outputs

The SKILL.md contains everything Hermes needs to invoke it: metadata, natural-language instructions, expected inputs, example outputs.

Installing a Community Skill

uv run hermes skill install nextjs-upgrade

This pulls from the community skill registry, validates the manifest, runs the skill through the Hermes threat scanner, and drops it into ~/.hermes/skills/.

Writing a Skill by Hand

Create a folder under ~/.hermes/skills/:

mkdir -p ~/.hermes/skills/screenshot-diff
cd ~/.hermes/skills/screenshot-diff

Minimal SKILL.md:

---
name: screenshot-diff
description: Diff two screenshot PNGs pixel-by-pixel and output a visual diff image.
inputs:
  before: Path to the "before" screenshot.
  after:  Path to the "after" screenshot.
output: Path to the generated diff PNG.
---

# Screenshot Diff

## Procedure

1. Run `scripts/diff.sh {before} {after}` to generate `/tmp/diff.png`.
2. Return `/tmp/diff.png` as the output path.
3. If either input doesn't exist, refuse and report the missing path.

## Example

Input: `before=/tmp/a.png after=/tmp/b.png`
Output: `/tmp/diff.png`

Any time you ask Hermes something like "diff the screenshot I took yesterday with today's", the agent scans ~/.hermes/skills/ and sees this SKILL.md as a ready-made procedure — no reasoning from scratch.

Layer 3a: The Self-Authoring Loop

This is the feature that separates Hermes from everything else.

When Hermes finishes a non-trivial task, it enters a structured reflection phase:

1. It reviews the trajectory of tool calls it just made.
2. It identifies the steps that worked.
3. It discards the dead-ends.
4. It writes the distilled procedure as a new SKILL.md in ~/.hermes/skills/.
5. It categorizes the skill for future retrieval.

The next time a similar pattern appears, Hermes loads the self-generated skill instead of re-reasoning from scratch.

Watching the Loop

Enable reflection logging:

uv run hermes config set reflection.log true

Now after every task you'll see:

› Reflection complete.
  ├── Analyzed 8 tool calls over 47 seconds.
  ├── Promoted procedure to: ~/.hermes/skills/docker-compose-debug/
  └── Estimated speedup on similar tasks: 2.4×

Community benchmarks show repetitive structured tasks execute 2-3× faster after 10-20 iterations once the skill is promoted. Over time the agent rewrites its own operational parameters — you end up with a specialized digital worker that you didn't have to hand-write.

Pruning Old Skills

Self-generated skills accumulate. Periodically:

uv run hermes skill audit

This lists skills by last-used date and execution count. Delete the ones that never fire again — they waste context assembly cycles.

Progressive Disclosure

One architectural detail worth knowing: Hermes doesn't inject every SKILL.md into the prompt on every turn. It injects a compacted index (one-line descriptions), and only loads the full SKILL.md body when the reasoning model flags the skill as relevant.

This is called progressive disclosure. It's why Hermes can have 100 skills installed without bloating the context window the way OpenClaw does with its 13,000-skill marketplace.

What's Next

In the last lesson you'll take this single-machine Hermes and deploy it to production — Docker sandboxes, SSH remotes, and Modal serverless. You'll also see the cost trade-offs that make Hermes uniquely cheap for intermittent workloads.