Hermes: The AI Agent That Teaches Itself New Skills (2026)

TL;DR Hermes is a self-improving AI agent from Nous Research that doesn't just use tools — it learns to create new ones. Give it a task it can't do, and it writes the skill, tests it, and adds it to its toolkit. In 2026, it's the closest thing to an agent that actually gets smarter as it works. I've been running it for two months. Here's what that looks like in practice.

The Problem: Your Agent Can't Do the Thing

Last week I asked an AI agent to scrape a website that used Cloudflare protection. The agent said it didn't have access to a web scraper tool. So I installed one.

Then I asked it to process the scraped data into a specific JSON format. It couldn't do that either. Another installation. Another configuration.

This is how most AI agents work in 2026. They have a fixed set of tools. When they hit a wall, you stop and install something new. The agent doesn't learn anything. Next time it hits the same wall, same problem.

The research team at Nous Research noticed something interesting. What if the agent could write its own tools?

What Hermes Actually Does

Hermes starts with a base set of capabilities — reading files, running code, making API calls. When it encounters a task it can't complete, it doesn't ask for help. It analyzes what skill is missing, writes the code for that skill in actual Python, tests it, and adds it to its toolkit.

This loop runs autonomously. You don't intervene. The agent figures out what it needs and builds it.

I've watched Hermes create skills I didn't ask for. I asked it to analyze some CSV files. It wrote a CSV validation skill first — something to check for malformed data before processing. I never thought of that. It just added it because it made the task easier.

The Learning Loop: How It Works

The self-improvement cycle has three parts. First, Hermes gets a goal and tries to accomplish it using existing tools. If a task fails, it analyzes why and identifies the specific capability missing — not just "I can't do this" but "I need X to do this." Then it writes code to fill the gap. The code gets tested. If it works, it's saved. If it doesn't, Hermes iterates.

The key difference from regular agents: Hermes remembers. Each new skill stays in its toolkit. The next time you give it a similar task, it already has what it needs.

What I've Used It For

I gave Hermes a task last month: monitor my project's GitHub issues and alert me when something looks urgent. I didn't have a GitHub monitoring tool set up. Hermes wrote a GitHub API integration skill, created an issue classifier that detects urgency signals, and built a notification system that sends me alerts on Slack. All without me writing any code or configuring any tools.

Another example: I asked Hermes to help me research a topic by reading multiple PDF papers. It created a PDF text extraction skill, then a paper summarization skill, then a comparison skill that highlights contradictions between papers. Three skills I didn't have. All created in one session.

Hermes vs OpenClaw: Honest Comparison

I've used both. OpenClaw is faster for known tasks. You tell it what to do, it uses its tools efficiently, it gets it done. But it's limited to what it knows. New capability needed? You add it manually.

Hermes is slower initially. The first time it encounters a task, it might spend 10 minutes writing and testing a new skill. But the second time? It's instant. The skill already exists.

The trade-off: Hermes costs more in compute during the learning phase. You're paying for it to figure things out. But you're paying once, not every time. For tasks you do repeatedly, Hermes wins. For one-off tasks, OpenClaw might be faster.

The Trade-offs: What's Not Great

Being honest about the limitations.

• •Slow first run — when Hermes encounters something new, it takes time. Writing code, testing, fixing. Budget for 5-15 minutes of learning time for new task types.
• •Not all skills are useful. Hermes creates what it thinks it needs. Sometimes it builds something redundant or over-complicated. You end up with a bloated toolkit that needs cleanup.
• •Local model support is rough. Hermes works best with frontier models like Claude or GPT-4. Running it on local models works but the skill quality drops.
• •No skill sharing yet. Every Hermes instance learns separately. There's no marketplace or shared toolkit. If three people ask Hermes to do the same new thing, it writes the same skill three times.
• •Debugging is tricky. When Hermes writes bad code, you have to figure out why. It tries to fix itself, but sometimes the fix makes things worse.

Who Should Use Hermes

Hermes makes sense when you're working on a domain where tasks repeat but vary slightly, when you want an agent that adapts without constant hand-holding, and when you're okay paying extra compute upfront to save time later.

It's probably overkill when you need predictable, consistent performance now, when your tasks are all one-offs with no repetition, or when budget is tight and you need to minimize compute costs.

Getting Started

You'll need an API key for a frontier model, basic comfort with Python for reviewing generated skills, and about 30 minutes for initial setup.

1pip install hermes-agent
2hermes init my-agent
3cd my-agent
4hermes config set model claude-3-opus
5hermes start

Then give it a task. Watch it work. If it hits something it can't do, watch it learn. The first few sessions will be slow. That's normal. It's building its toolkit.

When to Call a Professional

You can run Hermes yourself. But get help when the generated skills are breaking things in production, when you need to integrate Hermes with sensitive systems like payments or user data, or when the toolkit has grown unmanageable and needs auditing.

What we can help with:

• •Hermes deployment and configuration
• •Security review of generated skills
• •Custom skill development
• •Ongoing maintenance and toolkit cleanup

Further Reading

• •GitHub: github.com/NousResearch/hermes
• •Paper: "Self-Improving AI Agents Through Autonomous Skill Acquisition"
• •Discord: Active community discussing Hermes implementations
• •Weekly updates from Nous Research team

Hermes isn't just another agent. It's an agent that grows. The first time it sees a problem, it struggles. The second time, it handles it. For work that repeats and evolves, that trade-off — slow now, fast later — might be exactly what you need.