Hermes Agent Skills: The Complete Guide

Hermes Agent skills are modular instruction files (SKILL.md format) that extend your AI agent's capabilities without touching the core code. They're the difference between a general chatbot and a purpose-built tool that can email, schedule, research, build, and improve itself. The catch: they only work if properly configured and integrated with your agent's memory system.

What Are Hermes Agent Skills? (And Why They Matter)

A Hermes Agent skill is a discrete, reusable set of instructions written in SKILL.md format. It tells your Hermes instance how to perform a specific task: send a Slack message, query a database, summarize a PDF, create a GitHub issue, or retrieve real-time weather data. Skills live in the Hermes Skills Hub--90,881 skills across 12 registries at last count--so you don't have to write them from scratch.

The Hermes Agent project, maintained by Nous Research, has 259.5K GitHub stars and 61,002 commits (the activity is real, not archived). Within Hermes, skills are one of five architectural pillars alongside Memory, Soul, Crons, and Self-Improvement. That layering matters. Skills alone won't make an agent useful. They need memory (context of what the agent learned), a soul (personality and decision rules), crons (24/7 scheduling), and self-improvement loops (the agent learns from experience and refines its own skills).

Why skills matter: they're the execution layer. Without skills, your Hermes instance can talk brilliantly but do nothing. With the right skills wired to memory and crons, it becomes an autonomous worker. You hand it a goal--"monitor my GitHub PRs and notify me of security issues"--and it breaks the goal into skill invocations, chains them together, and runs that logic 24/7.

Two kinds of skills exist: auto-created (the agent invents them as it learns) and manually installed (you grab them from the Skills Hub). The difference is critical and worth a separate section.

Auto-Created Skills vs Manually Installed: Where the Learning Loop Matters

Hermes' self-improvement pillar is genuinely novel. Unlike Claude Code or ChatGPT (which forget every session), Hermes can create its own skills when it encounters a task it can't solve with existing ones. Watch what happens:

You ask Hermes: "Send an SMS to my team when the deploy finishes." Hermes checks its installed skills. No SMS skill exists. Hermes invents a temporary skill (a set of instructions it creates and saves to disk). Next time you ask something similar, Hermes remembers the skill and reuses it. If you feed that skill back into an LLM with more training data, it gets better.

This is the self-improvement loop. It's powerful but fragile.

Auto-created skills have a major weakness: they disappear or regress if not anchored to memory. Reddit users report a common pain point: "Hermes forgets to invoke installed skills after a few days." The root cause is usually a memory gap. Skills only persist if they're stored durably (SKILL.md files committed to a Git repo or database), indexed in your agent's vector database (so it can retrieve them during inference), and paired with episodic memory (Hermes remembers which skills worked before).

Manually installed skills from the Skills Hub are pre-tested and stable. They don't disappear. But they're inflexible: you can't easily customize them for your exact workflow. Your best approach is hybrid: start with 3-5 community skills for core needs (email, calendar, research), then let Hermes auto-improve around them.

The 12 Must-Have Hermes Agent Skills (Ranked by Use Case)

Not all skills are equal. Here's the curated list of what actually works, organized by what you'll use it for.

Productivity & Communication (Install These First)

1. Email Skill (Gmail/Outlook integration): Reads, drafts, sends, and manages emails. Install via skill add email-gmail-native from the Nous registry. Use this when delegating email triage, auto-responding during off-hours, or routing tickets to Slack. Reddit consensus: "Essential. Saves 2 hours a day."

2. Calendar Skill: Checks availability, proposes meetings, syncs across Cal.com and Google Calendar. Hermes books its own meetings and avoids conflicts. Trade-off: requires OAuth tokens and careful permission scoping. Setup takes 15 minutes; the payoff is real.

3. Slack/Teams Integration: Posts messages, threads, creates channels, and polls the team for decisions. Use Hermes as a workflow coordinator, notifying humans of decisions it made. Real use case: agent deployed, finishes a task, Slacks your CTO with a summary.

Research & Content Generation

4. Web Search Skill (SearXNG or Perplexity): Searches the web, retrieves current news, fact-checks claims in real-time. Install SearXNG self-hosted (free) or use Perplexity API ($15/mo). Use this when your agent needs live data; you're running a research loop or building a document. Reddit beloved: "Pairs with Hermes' memory for a proper second brain."

5. Document Summarization: Ingests PDFs, long-form articles, YouTube transcripts, condenses to bullet points. Install via skill add pdf-summarize or firecrawl-integration. Use this when your agent ingests a 20-page spec and you get the key decisions in 30 seconds. Firecrawl API costs approximately 0.01 USD per page crawled.

6. Obsidian Vault Integration: Reads and writes markdown notes from your Obsidian vault (or any local wiki). Install via skill add obsidian-native or local-repo-clone. Hermes becomes your note-taking assistant; you keep a wiki of decisions, it updates it. Setup: Git clone your vault, Hermes reads it as a local directory.

Engineering & DevOps

7. GitHub Skill: Opens issues, comments on PRs, creates branches, reviews code changes, triggers CI/CD. Install via skill add github-native. Hermes triages bugs, auto-responds to test failures, opens a PR with a fix. Trade-off: requires careful permission scoping (don't give it admin on production repos). Use fine-grained tokens.

8. Docker & Kubernetes Knowledge Base: Your agent consults Docker docs and Kubernetes API reference without browsing the web. Install via skill add local-docs-loader, then point it to docker-docs and kubernetes-docs repos. Git clone the official docs, Hermes indexes them as markdown files. When the agent debugs a container issue with official docs, it's 100x faster than web search.

Personal & Creative

9. Hyperframes Video Generation: Scripts, generates, and edits short-form video clips (faceless video, slideshows, etc.). Install via skill add hyperframes-api. Use this when you need social-media content at scale; Hermes drafts, generates, posts. Cost: Hyperframes is approximately 50 USD per month for 100 videos per month. Emerging use: Hermes as a content-generation loop (auto-improve copy based on engagement).

10. Genealogy (Grampsweb): Manages a family tree, queries ancestors, enriches records with sources. Install via skill add grampsweb-native. Niche but powerful--family history research, genealogy websites. Setup: run Grampsweb locally or in a container, Hermes queries it via API.

11. Home Automation (Home Assistant): Turns lights on/off, adjusts thermostats, triggers scenes, checks sensor data. Install via skill add homeassistant-native. "Hermes, it's 6pm, start my evening routine" (lights, music, coffee maker). Setup: Home Assistant plus API token; Hermes talks to the hub.

12. Note-Taking & Memory Plugins (Honcho, Mnem, Mempalace): Hermes reads and writes structured notes, storing memories in a vector DB. Install via skill add honcho-memory-client or mnem-memory-plugin. THIS IS NOT OPTIONAL. Every Hermes instance should have this. Without memory integration, all of Hermes' learning is lost on restart.

How to Install and Activate Skills: Step-by-Step

Step 1: Find Your Skill. Visit the Hermes Skills Hub at hermesatlas.com/lists/top-skills or the Nous Research GitHub skills catalog. Use the "Top Skills" filter to see ranked by community usage. Read the SKILL.md frontmatter (author, requirements, permissions).

Step 2: Install from CLI. Run hermes skill add github-native (substitute your skill name). The Hermes CLI downloads the skill, validates the SKILL.md structure, and stores it in ~/.hermes/skills/ (or your custom directory).

Step 3: Configure Secrets. Most skills need API keys or tokens. Hermes looks for them in environment variables (GITHUB_TOKEN, SLACK_TOKEN), a.env file in your Hermes config directory, or secrets passed via hermes config set github.token YOUR_TOKEN. Never commit tokens to Git. Use an env file or secrets manager.

Step 4: Activate the Skill. Add the skill to your Hermes config (hermes.yml or hermes.json):

skills:
  - name: github-native
    enabled: true
  - name: email-gmail-native
    enabled: true

Step 5: Test Invocation. Run hermes skill test github-native. If successful, Hermes outputs "Skill loaded and ready." If it fails, check: Is the token valid and not expired? Does the API endpoint respond? Does the skill SKILL.md have a required field you're missing?

Step 6: Monitor & Debug. Watch Hermes logs: hermes logs --tail -f | grep "skill". Look for "skill invoked" (good) or "skill failed: permission denied" (bad). Common failures: skill requires an OAuth scope you didn't grant; skill expects a response format your API doesn't return; skill calls a third-party service and that service is down.

Common Pitfalls and How to Avoid Them

Pitfall 1: Skill Naming Collisions. Your local folder has an email-skill.md. You install email-gmail-native from the Hub. Hermes gets confused: which one should it use? Solution: one skill per use case. If you build a custom email skill, name it email-custom-acme (your company name). Use the Hub version as your base and extend it.

Pitfall 2: Silent Skill Failures. You install a skill. It doesn't error. But Hermes never invokes it. Cause: the skill is loaded, but your prompt doesn't mention it or the agent doesn't recognize the task as requiring that skill. Solution: test manually. Give Hermes a clear instruction: "Use the github-native skill to open an issue titled X." If it still doesn't work, check the skill's prompt (in SKILL.md)--is it clear? Does it match your phrasing?

Pitfall 3: Token Budget Bloat. You install 20 skills. Hermes' context window fills with skill descriptions, and it has no room for your actual task. It starts dropping skills mid-execution. Solution: curate ruthlessly. Start with 5 skills. Add skills one at a time and measure latency. If your invocation time jumps from 2 seconds to 8 seconds after adding a skill, that skill is expensive. Archive it or refactor.

Pitfall 4: Missing Memory Integration. This is the #1 Reddit pain point. Hermes performs great for one session, then "forgets" the skills it used. You ask it the same question two weeks later, and it rebuilds everything from scratch. Root cause: skills live on disk, but Hermes' in-memory skill registry doesn't persist across restarts. Solution: pair every Hermes instance with a memory backend: Honcho (free, self-hosted), Mnem (paid SaaS), or Obsidian vault (local, free). Without this, you have a brilliant AI that resets every session.

Pitfall 5: Permissions Creep. You grant Hermes a GitHub token with admin:repo and admin:org scopes. Now if Hermes is compromised (or a skill has a bug), it can delete your entire org. Solution: use fine-grained personal access tokens. Grant the minimum: repo:read (for reading code, not deleting), issues:write (for opening issues, not deleting), pull_requests:read (for reviewing, not merging). Test each permission in isolation before going live.

Self-Hosting vs Managed Opsily: The Skill Infrastructure Trade-off

You can run Hermes two ways: on your own infrastructure (EC2, Docker, your laptop) or on Opsily's managed platform.

Self-Hosted: You Own the Ops. Pros: Hermes is MIT licensed (free software); you have full control; no vendor lock-in. Cons: you manage skill persistence (if you restart the container, you need Git or a database to restore skill state); skill sync across devices is your problem; backup complexity (skills are code needing version control, memory is data needing a DB, crons are scheduling logic needing a daemon); latency varies with your internet uptime.

Managed on Opsily. Pros: skills are managed for you (install, version, replicate across instances--Opsily handles persistence); memory-skill integration is automatic (you don't configure Honcho or Mnem; Opsily bundles it); EU data residency (your skill code, memory, and agent state live in EU data centers, relevant under GDPR); 24/7 uptime and skill availability (if a cloud provider API times out, Opsily retries and caches); one bill covering managed infrastructure (5-65 EUR per month depending on traffic) plus integrated memory. Cons: less control (you work within Opsily's API); higher managed costs than DIY upfront; vendor dependency (you need to migrate skill state if you leave, though Opsily exports everything).

The Honest Trade-off. DIY works if you have DevOps skills and 10+ hours per month for ops, your team is small (1-3 people), you're okay with occasional downtime, and you're happy debugging "Hermes skill mysteriously not triggering" at 2am. Managed (Opsily) works if you want to focus on skills, not infrastructure; you have multiple team members running Hermes in different places; you need EU compliance or uptime SLAs; or you want memory plus skills plus crons pre-integrated and tested.

If you're self-hosting, our guide to Hermes agent pricing covers software, hosting, and LLM API costs. If you choose managed, check Opsily's pricing page to see the all-in cost.

Next Steps: From Skills to Autonomy

Once you've mastered skills, the Five Pillars framework tells you what's next. Skills handle the "how" (execution). Memory handles the "why" (context and learning). Soul handles the "who" (personality and guardrails). Crons handle the "when" (24/7 autonomy). Self-Improvement handles the "iterate" (the agent refines itself).

A well-tuned Hermes instance uses all five: you install a GitHub skill and a Slack skill; memory captures what issues are critical (reads your GitHub issue history, learns patterns); soul decides when to notify (personality: proactive, not spammy); cron checks every 2 hours (24/7, while you sleep); self-improvement refines the decision logic (after 100 runs, Hermes learns your false-positive rate and gets smarter).

Model choice matters here. Claude Opus handles skill chaining better than Claude Haiku (more reasoning steps before tool use). For autonomous Hermes, we recommend Opus or GPT-4. Haiku and GPT-4o mini are good for low-latency, single-skill invocations.

Read our deep-dive on the best model for Hermes Agent to understand the Claude vs. GPT cost/performance tradeoff and decide which LLM makes sense for your skill stack.

Frequently Asked Questions

What are the best Hermes Agent skills? The top 3 by community usage are GitHub integration (for development teams), email/calendar (for personal assistants), and web search plus document summarization (for research). After those, it depends on your use case. Start with 5 skills, measure latency, and add one more every two weeks.

How do I install Hermes Agent skills? Run hermes skill add <skill-name> from the CLI. Hermes fetches the skill from the Skills Hub, validates its SKILL.md structure, and stores it locally. Then add it to your config (hermes.yml) and restart Hermes.

What is the Hermes Skills Hub? It's the central registry of community-built skills. Over 90,881 skills exist across 12 registries (Nous Research, GitHub, and third-party curators). Visit hermesatlas.com/lists/top-skills to browse ranked by popularity and read reviews from other users.

How do I create custom Hermes Agent skills? Write a SKILL.md file (YAML frontmatter plus markdown instructions plus optional scripts). Publish it to GitHub or the Nous Skills Hub. The Hermes Agent documentation has skill-authoring tutorials. Start by copying an existing skill and modifying it.

What skills come built-in with Hermes Agent? Hermes ships with no skills by default. You start with zero and install what you need. This is intentional: Hermes' architecture expects skills to be modular and pluggable. The upside: you only pay for what you use (no bloat).

Do I need a memory plugin for Hermes skills to work? Technically no, but practically yes. Without memory, Hermes forgets which skills worked before, and every session starts from scratch. Pair Hermes with Honcho or Mnem (memory layer) so the agent learns and skills persist.

How does Hermes differ from Claude Code when it comes to skills? Claude Code is stateless: you run it, it codes, it forgets. Hermes is stateful: it learns skills, remembers them, and auto-improves. Claude Code is a coding specialist; Hermes is a general agent that happens to code. For skill-based autonomy, Hermes is the better fit. See our comparison of Hermes Agent vs Claude Code for details on autonomy, stateful learning, and use-case fit.

The Bottom Line

Hermes Agent skills are how your AI goes from chat to execution. They're the difference between "the agent understands the task" and "the agent completes the task and remembers what worked."

You have two paths: manually install pre-built skills from the 90,000-plus available, or let Hermes auto-create skills as it learns. The truth: you need both. Start with 5 proven community skills (email, calendar, GitHub, web search, memory), then step back and let Hermes innovate around them.

The operational challenge isn't skills--it's infrastructure. Managing skill state, keeping memory persistent, ensuring availability, and handling API integrations across multiple devices is grunt work. That's where managed hosting solves the problem.

Get started free on Opsily and stop worrying about skill persistence, memory sync, and backup complexity.