Most AI agents are stateless. They solve a problem, forget how they solved it, and start from scratch next time. Hermes Agent is different — it writes down what it learns as skills, reusable knowledge documents that make it faster and more accurate over time.

Skills are the core of Hermes's self-improving learning loop. After completing a task, the agent extracts reusable patterns, writes them as skill documents, and loads them the next time a similar task appears. As of v0.10.0, Hermes ships with 118 bundled skills and the ability to create, refine, and share custom skills.

This guide covers everything about skills: the format, how auto-creation works, writing manual skills, the refinement loop, the bundled skills library, progressive disclosure for token efficiency, and patterns for production skill development.

1What Are Hermes Skills?

Skills are on-demand knowledge documents that teach Hermes how to handle specific tasks. Think of them as procedural memory — not just facts, but how to do things. A skill might describe how to deploy a Next.js app to AWS, how to write a specific type of SQL query, or how to format a weekly report for your team.

Unlike traditional agent plugins that require code changes, skills are plain markdown files. You can create them manually, let the agent create them automatically, or install community-shared skills. No code changes to Hermes are needed — drop a file in the skills directory and it's available immediately.

The key insight is that skills compound. A fresh Hermes installation starts with 118 bundled skills. After a week of use, it might have 130. After a month, 160+. Each skill makes the agent faster and more accurate at the tasks you actually do, creating a personalized AI that gets better the longer you use it.

2The agentskills.io Standard

Hermes skills follow the agentskills.io open standard, which defines a portable format for agent knowledge documents. The standard ensures skills are compatible across different Hermes installations and can be shared with the community.

A skill file is a markdown document with YAML frontmatter. The frontmatter contains metadata (name, description, triggers), and the body contains the actual instructions. Here's the basic structure:

---
name: deploy-nextjs-aws
description: Deploy a Next.js static export to AWS S3 + CloudFront
triggers:
  - deploy next.js
  - aws s3 cloudfront
  - static site deployment
version: 1
---

# Deploy Next.js to AWS S3 + CloudFront

## Prerequisites
- AWS CLI configured with appropriate IAM permissions
- Next.js project with `output: "export"` in next.config.ts
- S3 bucket created with static website hosting disabled
  (CloudFront handles serving)

## Steps

1. Build the static export:
   ```bash
   npm run build
   ```

2. Sync to S3:
   ```bash
   aws s3 sync out/ s3://your-bucket-name --delete
   ```

3. Invalidate CloudFront cache:
   ```bash
   aws cloudfront create-invalidation \
     --distribution-id YOUR_DIST_ID \
     --paths "/*"
   ```

## Common Issues
- If pages return 403, check the CloudFront Origin Access Control
- If CSS/JS doesn't load, verify the S3 bucket policy allows
  CloudFront access
- Cache invalidation takes 1-2 minutes to propagate globally

3How Auto-Creation Works

The closed learning loop is what makes Hermes unique. Here's how it works step by step:

1. Task completion — You ask Hermes to do something (e.g., "set up a PostgreSQL backup cron job")
2. Pattern extraction — After completing the task, Hermes analyzes the conversation and identifies reusable patterns
3. Skill generation — The agent writes a skill document capturing the workflow, commands, and decision points
4. Skill storage — The skill is saved to ~/.hermes/skills/ with appropriate triggers
5. Future loading — Next time a similar task appears, Hermes loads the skill and follows the documented approach instead of reasoning from scratch

The agent doesn't create a skill for every conversation. It uses heuristics to determine when a task is worth preserving: Was it multi-step? Did it involve tool calls? Did the user confirm the result was correct? Trivial questions ("what time is it?") don't generate skills.

4Writing Manual Skills

While auto-creation handles most cases, you can write skills manually for workflows you want the agent to follow precisely. Manual skills are useful for:

• Company-specific processes (deployment procedures, code review checklists)
• Compliance requirements (data handling rules, security protocols)
• Personal preferences (coding style, communication tone, report formats)
• Complex multi-tool workflows that need exact sequencing

Create a new file in ~/.hermes/skills/ with a descriptive filename:

# Create a new skill file
touch ~/.hermes/skills/weekly-standup-report.md

The skill is available immediately — no restart needed. Hermes scans the skills directory on each session start and indexes new files automatically.

5Skill Format & Structure

Effective skills share common structural patterns:

• Clear triggers — Use specific phrases the agent can match against incoming requests
• Prerequisites section — What needs to be true before the skill applies
• Step-by-step instructions — Numbered steps with exact commands or actions
• Decision points — If/then branches for common variations
• Common issues — Known failure modes and their fixes
• Verification — How to confirm the task was completed correctly

Keep skills focused. A skill that tries to cover "everything about AWS" is too broad. A skill that covers "deploy a static Next.js site to S3 + CloudFront" is specific enough to be useful and general enough to apply across projects.

6Progressive Disclosure & Token Efficiency

One concern with skills is token usage. If Hermes loaded every skill into the system prompt, it would burn through context window and money. The solution is progressive disclosure:

1. Skill index — Only skill names and descriptions are loaded into the system prompt (a few tokens each)
2. On-demand loading — When the agent decides a skill is relevant, it loads the full content
3. Context-aware matching — Hermes uses the triggers and description to determine which skills to load for each task

This means having 200 skills costs almost nothing in tokens until one is actually used. The skill index might add 500-1,000 tokens to the system prompt, but the full content of each skill (which could be thousands of tokens) is only loaded when needed.

7The Skill Refinement Loop

Skills aren't static. Hermes refines them during use through a feedback loop:

1. Agent loads a skill for a task
2. During execution, it encounters a case the skill doesn't cover
3. After completing the task, it updates the skill with the new information
4. The skill version number increments

For example, a "deploy to S3" skill might initially not mention CloudFront cache invalidation. After the agent encounters a stale cache issue and resolves it, it adds the invalidation step to the skill. Next time, the skill includes that step from the start.

This refinement happens automatically. You can also manually edit skills at any time — they're just markdown files. The agent respects manual edits and won't overwrite them unless you explicitly ask it to refine a skill.

8The 118 Bundled Skills

Hermes v0.10.0 ships with 118 bundled skills covering common development and automation tasks. These are maintained by the Nous Research team and community contributors. Categories include:

Bundled skills are stored separately from user skills and are updated with each Hermes release. Your custom skills always take priority over bundled skills with the same triggers.

9Sharing & Community Skills

Since skills are plain markdown files, sharing them is trivial:

• Git — Keep your skills directory in a Git repo and sync across machines
• Copy — Drop a .md file into ~/.hermes/skills/ on any machine
• Team sharing — Maintain a shared skills repo that all team members pull from
• Community — Share skills on GitHub, forums, or the Hermes community channels

The agentskills.io standard ensures compatibility. A skill written on one machine works on any other Hermes installation without modification.

10Production Skill Patterns

Here are patterns that work well in production deployments:

Pattern 1: Onboarding Skills Pack

Create a set of skills that encode your team's processes: deployment procedures, code review standards, incident response playbooks. New team members get a Hermes agent pre-loaded with institutional knowledge from day one.

Pattern 2: Domain-Specific Skills

For specialized domains (healthcare compliance, financial regulations, legal document formatting), write detailed skills that encode domain expertise. The agent becomes a domain expert that never forgets the rules.

Pattern 3: Skill Versioning

Use Git to version your skills directory. This gives you a history of how your agent's knowledge has evolved, the ability to roll back bad refinements, and a clear audit trail for compliance-sensitive environments.

11Why Lushbinary for Hermes Skill Development

Building a skills library that actually improves your team's productivity requires understanding both the technology and your workflows. Lushbinary develops custom Hermes skill packs for clients — encoding deployment procedures, compliance requirements, and domain expertise into skills that make the agent genuinely useful from day one.

❓ Frequently Asked Questions

Sources

• Creating Skills — Hermes Agent Docs
• Working with Skills Guide
• TokenMix.ai Hermes Agent Review
• Hermes Agent Documentation

Content was rephrased for compliance with licensing restrictions. Technical details sourced from official Nous Research documentation as of April 2026. Features may change — always verify on the official documentation.