Hermes Agent Skills: How to Create and Manage Custom Skills

Hermes Agent skills are procedural memory — reusable capabilities that the agent creates from experience and improves through continued use. After completing a complex task involving 5 or more tool calls, the agent can autonomously generate a structured SKILL.md file capturing the procedure, pitfalls, and verification steps. This self-improving loop is the core differentiator of Hermes Agent's architecture: the more you use it, the better it gets at recurring tasks.

How Skills Work

Skills in Hermes Agent function as procedural memory — the agent equivalent of knowing how to ride a bike. Once a skill is created, the agent can apply that procedure to similar tasks without re-learning the steps from scratch.

The self-improving loop works in three phases:

1. Experience: The agent completes a complex task (typically 5+ tool calls) and recognizes the workflow could be reusable.
2. Creation: The agent generates a SKILL.md file documenting the procedure, common pitfalls, and verification steps.
3. Refinement: Each time the skill is used, the agent can update it with new edge cases, improved procedures, or better verification steps discovered during execution.

This is what Nous Research means by "the agent that grows with you." Unlike static automation scripts, Hermes skills evolve as the agent encounters new scenarios. A skill created for deploying a Node.js app might start simple and gradually add handling for environment variables, Docker configurations, and CI/CD integration as those situations arise.

For context on how this compares to other agent frameworks, see our AI agent frameworks comparison.

The SKILL.md Format

Every Hermes Agent skill is a markdown file with YAML frontmatter followed by structured instruction sections. The format is designed to be human-readable and agent-executable without any code.

Frontmatter Structure

---
name: deploy-nodejs-app
description: Deploy a Node.js application to a VPS with Docker
version: 1.0.0
author: Your Name
license: MIT
platforms: [linux, macos]
metadata:
  hermes:
    tags: [DevOps, Deployment, Docker]
    related_skills: [docker-compose-setup]
    requires_toolsets: [terminal]
    requires_tools: [run_terminal_cmd]
    required_environment_variables:
      - name: DEPLOY_HOST
        prompt: "Enter your server hostname"
        help: "The SSH-accessible hostname of your deployment target"
        required_for: "SSH deployment"
---

Body Sections

The markdown body after the frontmatter contains the skill instructions. According to the official developer guide, the recommended sections are:

Put the most common workflow first. Edge cases and advanced usage should go at the bottom. This matters because the full SKILL.md body is loaded into context when the skill activates — keeping instructions under 5,000 tokens minimizes context window consumption.

Creating Custom Skills

There are two ways to create skills: let the agent generate them from experience, or write them manually.

Agent-Generated Skills

The most natural approach is to let the agent create skills organically. After completing a complex task, Hermes may propose creating a skill. You can also explicitly request it:

hermes chat -q "Create a skill from what we just did"

The agent will generate a SKILL.md file based on the conversation history, extracting the procedure, identifying potential pitfalls from any errors encountered, and defining verification steps.

Manually Created Skills

For workflows you already know well, create a SKILL.md file directly in the skills directory:

# Create a new skill directory
mkdir -p ~/.hermes/skills/my-custom-workflow

# Create the skill file
cat > ~/.hermes/skills/my-custom-workflow/SKILL.md << 'EOF'
---
name: my-custom-workflow
description: Automate weekly report generation
version: 1.0.0
author: Your Name
license: MIT
---

## When to Use
Use this skill when the user asks for a weekly report or status update.

## Procedure
1. Check the project directory for recent changes
2. Summarize commits from the past 7 days
3. Format as a markdown report with sections for changes, issues, and next steps

## Pitfalls
- Always check that git is initialized in the target directory
- Handle repositories with no commits in the past week gracefully

## Verification
- Report contains at least the three required sections
- All dates are accurate and within the 7-day window
EOF

Verify the skill loads correctly:

hermes chat --toolsets skills -q "What skills do you have?"

Skill Categories and Distribution

Hermes Agent organizes skills into three categories based on scope and audience, each with its own distribution path.

Install community skills from the Skills Hub:

hermes skills install skill-name

Bundled skills ship with every Hermes Agent installation and are organized by category within the skills/ directory. Each skill contains a SKILL.md file (required) and an optional scripts/ directory for helper scripts and a references/ directory for supporting documentation.

For a comparison of how this differs from OpenClaw's skill ecosystem, see our guide to OpenClaw.

Managing and Testing Skills

Skill management involves listing, testing, updating, and configuring skills through the Hermes CLI and configuration files.

Listing Installed Skills

# Ask the agent about available skills
hermes chat --toolsets skills -q "What skills do you have?"

# Show a specific skill's details
hermes chat --toolsets skills -q "Show me the deploy-nodejs-app skill"

Testing a Skill

Run a skill directly and verify the agent follows the instructions:

hermes chat --toolsets skills -q "Use the my-custom-workflow skill to generate a report"

Skill Configuration

Settings for skills are stored under skills.config in your config.yaml. When a skill loads, its resolved configuration values are injected into the context so the agent knows the configured values automatically — no manual environment variable passing needed during execution.

Skills that require environment variables (like API keys for external services) declare them in the frontmatter's required_environment_variables section. The agent will prompt for these values the first time the skill is activated.

Limitations and Tradeoffs

The skills system has constraints that affect practical use.

• Context window consumption. Each activated skill loads its full SKILL.md body into the agent's context. Large skills or many simultaneous activations can consume significant context space, potentially crowding out conversation history.
• No version control built in. Skill refinement happens in place — the agent overwrites the SKILL.md file when improving it. If a refinement makes the skill worse, there is no built-in rollback. Use version control (Git) on your skills directory to maintain history.
• Quality varies in community skills. Community-contributed skills from the Skills Hub are not vetted with the same rigor as bundled skills. Review the SKILL.md content before installing, especially skills that require elevated permissions or API access.
• Autonomous creation is not always accurate. Agent-generated skills sometimes capture unnecessary steps or miss important edge cases. Review generated skills and edit them manually when needed.
• Platform-dependent skills. Skills that use terminal commands may not work across operating systems. Check the platforms field in the frontmatter before relying on a skill in a different environment.

Related Guides

• What Is Hermes Agent?
• OpenClaw vs Hermes Agent
• OpenClaw Skills: Complete Guide
• How to Build an AI Agent from Scratch

Frequently Asked Questions

How does Hermes Agent create skills automatically?

After completing a complex task (typically involving 5 or more tool calls), Hermes Agent can autonomously create a skill — a structured markdown document capturing the procedure, common pitfalls, and verification steps. The agent recognizes when a workflow is reusable and proposes creating a skill from the experience. Over time, skills are refined as the agent encounters edge cases and improvements during repeated use.

What is the SKILL.md format?

SKILL.md is a markdown file with YAML frontmatter containing metadata (name, description, version, author, license, platform support, required environment variables) followed by structured sections: When to Use, Quick Reference, Procedure, Pitfalls, and Verification. The full body is loaded when the skill activates, so keeping instructions under 5,000 tokens is recommended to minimize context usage.

Can I install community skills from the Skills Hub?

Yes. Community-created skills are available through the Hermes Skills Hub. Install them with hermes skills install followed by the skill name. Community skills cover specialized use cases like MLOps, API integrations, and domain-specific workflows that are too niche for the bundled skill set.

How are Hermes Agent skills different from OpenClaw skills?

Both use markdown-based SKILL.md files, but the creation process differs. Hermes Agent creates skills autonomously from experience and refines them through continued use — the self-improving loop. OpenClaw skills are typically created manually by developers or downloaded from the marketplace. Hermes skills also include built-in metadata for platform requirements and environment variables, while OpenClaw skills focus more on direct procedural instructions.

How many skills can Hermes Agent have installed?

There is no hard limit on installed skills. However, only activated skills consume context window space. The agent loads the full SKILL.md body when a skill is triggered, so having many large skills active simultaneously could consume significant context. In practice, the agent selectively activates skills based on the current task rather than loading all of them at once.