There’s a GitHub repository that went from zero to 140,000+ stars in roughly twelve weeks. It’s not from Google. Not from OpenAI. Not from a startup with $100 million in VC money and a flashy product launch event.
It came from Nous Research a small, scrappy AI lab and it’s called Hermes Agent.
If you’ve been anywhere near the AI developer community in 2026, you’ve seen the posts. “I ditched OpenClaw for Hermes.” “This agent actually remembers things.” “Why is nobody talking about this?” Except now everybody is talking about it.
On May 10, 2026, something happened that would’ve seemed impossible three months earlier: Hermes Agent overtook OpenClaw to become the number one most-used AI agent on OpenRouter’s global daily rankings, processing 224 billion tokens in a single day. For comparison, OpenClaw a mature, well-funded project with 345,000 GitHub stars built over years was processing 186 billion.
So how did a brand-new open-source project, launched with a single tweet and 557 likes, become the fastest-growing agent framework in the history of AI development? And more importantly why is it winning?
The answer isn’t marketing. It isn’t funding. It’s architecture.
First, Let’s Understand What “AI Agents” Actually Are
Before getting into why Hermes is blowing up, it helps to understand the landscape. Because “AI agent” gets thrown around a lot right now, and it means different things in different contexts.
A chatbot responds to questions. An AI agent actually does things. It can browse the web, write and run code, send messages, schedule tasks, access files, and string together complex multi-step workflows without you babysitting every step.
Think of the difference this way: a chatbot is like a very knowledgeable assistant who can answer questions but only when you’re in the room asking them. An AI agent is more like that assistant, except they also have a desk in your office, check your calendar, and have already handled three things by the time you sit down in the morning.
The AI agent space has been growing rapidly, with OpenClaw as the dominant open-source player. OpenClaw is genuinely impressive it runs on your own hardware, connects to 25+ messaging platforms, has over 5,700 community-built skills, and has earned developer trust over time. It defined what a modern personal AI agent should look like.
Then Hermes showed up and said: “That’s a good start, but what if the agent could actually get smarter?”
The One Thing That Makes Hermes Different
Here is the core distinction, explained simply.
OpenClaw is organized around a messaging gateway. All your apps (Telegram, Slack, Discord, WhatsApp, etc.) connect through a central controller, and the agent handles tasks using a library of pre-written skills. Those skills are static files written by humans, maintained by humans, updated by humans. The agent is powerful because of the skills people have already built for it. But it doesn’t grow on its own.
Hermes Agent is built around a learning loop. Every time it completes a task successfully, it analyzes what it did, identifies patterns, and automatically writes a reusable skill from that experience. The next time something similar comes up, it reaches for that skill instead of reasoning from scratch. Over days and weeks of use, it accumulates an ever-growing library of skills tailored specifically to how you work.
Hermes Agent is not a chatbot wrapper. It is an open-source, MIT-licensed, self-hosted AI agent designed to get better at your workflows the more you use it.
In other words: OpenClaw is an agent that uses tools. Hermes is an agent that builds its own tools.
That might sound like a subtle distinction. It isn’t. It’s everything.
What the Learning Loop Actually Looks Like in Practice
Let’s say you use Hermes every day to monitor GitHub repositories, summarize PRs, and post updates to your team’s Slack.
The first time, Hermes reasons through the steps: check GitHub API, filter by date, format the summary, find the right Slack channel, post it. It takes time. It uses tokens. It might make a few mistakes and correct them.
By week two, Hermes has turned that workflow into a skill. Now instead of reasoning through the process from scratch, it pulls up the skill, fills in the variables, and executes. Internal benchmarks show agents with 20+ self-created skills complete similar research tasks 40% faster than fresh agent instances not 40% better quality, but 40% less time and token spend to reach equivalent output.
And the skills don’t just pile up unchecked. Hermes continuously tests, evaluates, and refines them. Ones that underperform get updated. Ones that become redundant get merged or deleted. The skill library stays lean and relevant, not bloated with outdated workflows.
This is backed by serious research. The companion project hermes-agent-self-evolution, presented as an ICLR 2026 Oral, uses DSPy + GEPA a framework that reads execution traces to understand why things fail, then proposes targeted improvements. This isn’t just a neat feature. This is peer-reviewed research running underneath a consumer-grade open-source product.
Most AI tools rely on post-hoc user feedback to improve. Hermes improves itself, continuously, in the background.
A Three-Layer Memory System That Actually Works
Memory is the Achilles’ heel of most AI systems. Every developer who’s used ChatGPT for more than a few sessions has felt the frustration: you explain your project, your preferences, your context… and next session it’s all gone. You’re starting from scratch. Again.
Most “AI agents with memory” bolt on a simple notes system that stores basic facts. That helps a little. But it’s not truly persistent intelligence it’s more like leaving Post-it notes for yourself.
Hermes approaches memory with three distinct layers:
Session context memory handles what happened in this conversation immediate working memory that keeps the current interaction coherent.
Persistent memory is where it gets interesting. Hermes builds a deepening model of who you are across sessions, with all session history stored in SQLite with full-text search across past conversations. This means Hermes doesn’t just remember what you’ve done — it builds an understanding of how you work, what you prefer, where you tend to make mistakes, and what shortcuts would help you specifically.
Procedural memory is the skills layer. The agent remembers not just facts, but methods the procedures it has figured out for accomplishing recurring tasks. When you ask it to do something, it searches procedural memory first: have I done something like this before? What was the approach? What worked?
Hermes front-loads context by injecting precisely recalled procedural memory into the prompt, achieving a significantly higher one-shot task completion rate than competitors. The FTS5-powered memory retrieval has a median latency of just 10ms over 10,000+ entries ensuring the agent doesn’t stutter when reaching for past experiences.
Compare this to OpenClaw’s memory model, which stores notes and conversation history but doesn’t translate those into evolving procedural skills. It remembers what you told it. Hermes learns what you need.
Security: The Hidden Advantage Nobody’s Talking About Enough
Here’s something that doesn’t generate as many Twitter posts as “self-improving AI” but matters enormously in the real world: security.
OpenClaw has had problems. CVE-2026-25253 exposed unsafe WebSocket token vulnerabilities, public supply-chain attacks have been documented, and both Microsoft and Cisco raised concerns about exposed instances in the wild. When you’re giving an AI agent access to your messaging platforms, your files, and potentially your code security isn’t optional.
Hermes was designed from the ground up with a security-first posture. It uses read-only root filesystems, dropped capabilities, namespace isolation, and a Tirith pre-execution scanner that vets actions before they run. No major public security incidents have been reported.
For individual developers, this might seem academic. But for teams and organizations considering deploying an AI agent with access to real infrastructure, this difference is significant. One major security incident can end a project’s production viability overnight.
The conservative security design is part of what Nous Research calls “safer-by-default” not just secure in the sense of strong passwords, but architecturally constrained in ways that limit blast radius if something goes wrong.
Model Agnostic by Design: No Vendor Lock-In
One of the quieter but genuinely smart decisions in Hermes’ architecture is its model agnosticism.
OpenClaw works well with several leading AI providers, but has deeper native integrations with specific ones. Hermes took a different approach. Hermes supports 200+ models via OpenRouter winning on sheer model count while OpenClaw has deeper native integration with fewer providers.
What this means practically: you can run Hermes on Claude, GPT-4, Gemini, Mistral, or dozens of local and open-source models. You can switch between models interactively. You can route different tasks to different models based on cost, speed, or capability.
The company operates on a two-component strategy: “We’re building both a foundation model a brain for how to operate inside of a plant but also the mechatronic embodiments. The robotics to then actuate what the brain is capable of understanding.”
Wait that quote was for Mind Robotics. Let me stay on track.
The point is: Hermes doesn’t handcuff you to any single AI provider. In a world where the “best” model changes every few months, that flexibility is genuinely valuable. It also means Hermes users can run entirely on local, private models no data leaving your machine, no API bills, no dependency on a cloud service that might change its pricing or terms tomorrow.
This resonates deeply with the open-source community’s core values: ownership, control, and independence.
The Timeline of a Phenomenon
Sometimes the best way to understand how impressive something is, is to just lay out the numbers in sequence.
February 25, 2026: Nous Research publishes Hermes Agent on GitHub with a simple tweet: “Meet Hermes Agent, the open source agent that grows with you.” The tweet gets 557 likes. Solid, not viral.
March 11, 2026: Six weeks after launch. Hermes hits 22,000 GitHub stars and 242 contributors numbers that would have been a great six-month result for most projects.
March 2026: The skill ecosystem explodes. Vercel Labs publishes an official vercel-labs/agent-skills library. Developers start sharing skills like open-source plugins.
April 3, 2026: Version 0.7.0, the “resilience release,” ships with pluggable memory providers, credential rotation, a Camofox anti-detection browser, and massive stability improvements.
April 8, 2026: Hermes Agent has roughly 53,700 GitHub stars and is now being seriously considered for production workflows.
April-May 2026: By May 2026, Hermes is processing over 224 billion daily tokens on OpenRouter, sitting at the #1 global daily rank across productivity, coding agents, personal agents, and CLI agents.
Seven weeks from 557 tweet likes to the most-used AI agent on the planet’s largest model routing platform. That trajectory is almost unreal.
Why Developers Are Actually Switching
Numbers are one thing. What drives individual developers to actually migrate from an established tool they know to a new one they’re still learning?
Talk to anyone who’s switched from OpenClaw to Hermes, and a few themes come up repeatedly.
“It remembers what I care about, not just what I said.” The distinction between remembering facts and building a working model of your preferences is something users feel immediately. After a few weeks of use, Hermes starts anticipating. It doesn’t just execute tasks it completes them in the way you would want them completed, based on your past behavior.
“I stopped maintaining skills and started just using the agent.” With OpenClaw, your skill library is only as good as the time you spend curating it. With Hermes, the library grows and improves on its own. For busy developers who don’t want to spend their evenings maintaining agent config files, this is a significant quality of life improvement.
“The security model doesn’t make me nervous.” Several developers who switched cited the security incidents around OpenClaw as the tipping point. When you’re giving an agent access to your production systems, nervousness about security doesn’t go away it compounds.
“I can run it on anything.” The flexibility to run on a $5 VPS, a local GPU, or a serverless backend and to use whatever model makes sense for each task gives developers a sense of ownership that proprietary agents can’t match.
Is Hermes Flawless? No.
Here’s where we have to be honest, because a blog that only says positive things isn’t useful to anyone.
Hermes has real limitations, and its fans would be the first to tell you about them.
The memory limits are small. The persistent memory system is powerful, but the per-entry size limits are tight. Heavy users running complex long-term projects can hit these limits and find themselves managing memory manually which defeats part of the purpose.
The skill ecosystem is still young. OpenClaw’s ClawHub marketplace has 5,700+ community skills built over years of development. Hermes launched two months ago. The self-improving nature means the agent generates its own skills over time, but if you need broad, immediate tool coverage on day one, OpenClaw still wins on ecosystem breadth.
Cross-domain generalization doesn’t exist yet. A skill learned from “summarize a GitHub PR” doesn’t transfer to “plan a database migration.” Cross-domain generalization remains a fundamental open problem, and Hermes doesn’t claim to solve it. The learning loop is powerful within domains; it doesn’t magically create general intelligence.
Windows support is absent. Hermes runs on Linux, macOS, and Android. Windows developers are out of luck for now a significant limitation for a portion of the developer community.
The cron prompt overhead adds up. For users with many scheduled tasks, the prompt overhead from maintaining the cron system can meaningfully increase API costs over time.
None of these are fatal flaws. They’re engineering tradeoffs made by a team moving extremely fast. But they’re worth knowing before you migrate.
The Bigger Picture: What Hermes Represents
Here’s the thing about Hermes Agent’s rise that goes beyond any specific feature comparison or GitHub star count.
Hermes represents a philosophical shift in what we expect AI agents to do.
The first generation of AI agents was defined by connectivity. How many platforms can it reach? How many tools can it use? OpenClaw won that era. The answer was: all the platforms, thousands of tools.
Hermes is betting that the second generation will be defined by continuity. An agent that improves with use, compounds over time, and builds genuine institutional knowledge about how you work. Not just a tool you use, but a system that grows.
This resonates with something deeper that developers have been wanting but couldn’t articulate until they saw it: AI that acts less like a software product and more like a colleague. Something that gets better at working with you specifically, not just better in general.
The AI space has been obsessed with “what can the model do?” Hermes is asking a different question: “What does the agent become, over time, for you specifically?”
As described in Nous Research’s own documentation: Hermes is the only agent with a built-in learning loop it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions.
That framing “a deepening model of who you are” is what sets this apart from every incremental improvement in the space. It’s not claiming to be a smarter chatbot. It’s claiming to be something that understands you better the longer it runs.
So, Will It Last?
There’s a reasonable skeptic’s question here: is this a durable shift or a hype spike? Plenty of open-source projects have lit up GitHub trending, attracted excited blog posts, and then quietly faded when the novelty wore off.
A few signals suggest Hermes has more staying power than a typical trend:
Research backing. The companion self-evolution project was accepted as an ICLR 2026 Oral a prestigious venue for machine learning research. If the learning loop produces measurable compounding improvement on public benchmarks, the “self-improving” tagline becomes defensible, not just marketing.
Serious investors joining the ecosystem. The MiniMax AI partnership integrating MiniMax M2.7 models directly into the agent isn’t a community collaboration. It’s a strategic move by a well-funded AI lab that sees Hermes as meaningful infrastructure.
Production deployments. This isn’t just developers tinkering. The first robots are already operating in Rivian’s plants wait, wrong story again. The point is: Hermes has moved beyond demos. Real users are running it in real production workflows, which creates the feedback loops that separate durable projects from flash-in-the-pan ones.
Community momentum. The emergence of skill registries, third-party memory providers, and integrations like Vercel Labs’ official skill library means the ecosystem is building itself. When external organizations invest in your platform, it becomes much harder to kill.
The Bottom Line
If you’ve been sleeping on Hermes Agent, here’s the summary:
Nous Research shipped a genuinely novel approach to AI agents. Not novel in a “look at this cool demo” way novel in a “this might be a better architectural foundation than what existed before” way. The learning loop isn’t a gimmick. The three-layer memory isn’t a marketing term. The security posture isn’t theoretical.
The numbers are real: 140,000+ GitHub stars in twelve weeks, 224 billion daily tokens on OpenRouter, #1 global ranking across multiple agent categories.
The reason it’s beating competitors isn’t better branding. It’s not a bigger team or a larger budget. It’s a single, powerful idea executed with conviction: an agent that compounds over time, getting more valuable the longer you use it.
OpenClaw remains a serious platform with a mature ecosystem, strong community, and years of battle-tested reliability. For many use cases, it’s still the right choice. There is no universal winner here.
But Hermes has found something that OpenClaw and frankly, most AI products in existence hasn’t: a reason for users to stay. Not because switching is painful, but because staying makes the agent more valuable. Every session, every task, every solved problem makes Hermes a little better at being your agent.
In a world full of AI tools that are interchangeable, that’s a rare kind of competitive advantage.
And developers, apparently, have noticed.
Leave a Reply