Hermes

On April 3, 2026, Anthropic quietly blocked Claude Pro and Max subscribers from using OpenClaw with flat-rate plans. The story hit Hacker News at number one (1,064 points), then TNW, The Register, and TechCrunch. Within hours, Nous Research posted a single tweet: "If you're having trouble with your lobster-themed agent since the recent update, try downloading Hermes Agent, then running hermes claw migrate. We've been told this helps a lot." It collected 813 likes, roughly 2.5x the account's typical engagement, and drove an install spike large enough to push Hermes to an estimated 8,000–12,000 new stars that week.

The joke landed because it was structurally true. Hermes Agent does not route calls through Anthropic. It does not route them through OpenAI. It does not care who hosts the model. You configure a provider. OpenRouter, Nous Portal, Ollama, a local llama.cpp instance, NVIDIA NIM, and Hermes calls it. The OpenClaw migrants were not just swapping tools; they were escaping a dependency that had proven fragile the moment a vendor decided to enforce it. Hermes's model-agnostic architecture made that pitch credible in a way that purely commercial agent frameworks could not.

What Hermes Agent actually is in April 2026

Hermes Agent is an open-source, self-hostable autonomous AI agent released by Nous Research on February 25, 2026. The framework is MIT-licensed, written primarily in Python (87.5%) with a TypeScript layer (8.8%), and has no telemetry, all API calls go exclusively to your configured provider.

The architecture is built around a closed learning loop. After completing a task, the agent synthesizes what worked into a reusable Markdown skill file (using the agentskills.io open standard), stores searchable session history in SQLite with full-text search (FTS5), and updates a persistent user model. The design premise is that the agent becomes measurably more capable the longer it operates on your specific tasks.

At the feature level, Hermes ships with:

• Three-layer memory: a bounded MEMORY.md and USER.md injected into every system prompt; a SQLite FTS5 session store; and eight pluggable external memory providers for tools like Obsidian and custom knowledge bases.
• 47 built-in tools covering web search, browser automation, image generation, voice synthesis, and a cron scheduler.
• 15+ messaging platform integrations via a single gateway: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Mattermost, Email, SMS, DingTalk, and more.
• Six execution backends: local shell, Docker, SSH, Daytona, Singularity, and Modal (serverless with idle hibernation).
• Model-agnostic routing via Nous Portal, OpenRouter (200+ models), OpenAI, Anthropic, Google, NVIDIA NIM, Ollama, or local llama.cpp.

The project's growth has been exceptional by any benchmark. Hermes reached 100,000 GitHub stars in 53 days, a record for AI agent repositories, per @Telos's April 2026 data. As of late April 2026: 115,000+ stars, 16,900+ forks, 274+ contributors. The v0.11.0 release was fueled by over 700 pull requests from nearly 200 open-source contributors.

"hermes agent from @NousResearch is the fastest growing agent of all time. @OpenClaw went from 0 → 40K stars in 61 days. hermes did it in 45 days. in the past 7 days alone, hermes gained 3x more stars than OpenClaw, unprecedented."

, @chrysb on X, April 2026

The hermes-claw-migrate moment

To understand why the April 3 tweet resonated, you need the Hacker News thread that preceded it. The submission "Tell HN: Anthropic no longer allowing Claude Code subscriptions to use OpenClaw" (HN #47633396, ~737 points) was full of users interpreting the move as competitive enforcement dressed up as infrastructure management. User goosejuice wrote: "Hard token limits already exist; the change targets competitors rather than addressing genuine capacity issues." User mech422: "Why is some automation (Claude Code loops) acceptable while third-party tools face restrictions?"

Into that specific mood, Nous Research posted a one-liner CLI migration tool. It was technically useful , hermes claw migrate handles config porting from OpenClaw's format. But the reason it spread was the implied structural argument: Hermes runs against any OpenAI-compatible endpoint. A single-vendor policy decision cannot break it. The hermes-claw-migrate incident is not primarily a growth story; it is a demonstration that model-agnosticism is an architectural moat, not a marketing claim.

The week of April 3, the estimated 8,000–12,000 new stars came from users who had not been looking for a new agent tool, they were pushed toward one by a vendor's decision outside their control. Hermes was positioned to catch exactly that population.

Where Hermes sits versus OpenAI Agents SDK and Claude

Hermes Agent vs. OpenAI Agents SDK

OpenAI's Agents SDK is API-key-dependent and routes every call through OpenAI's servers. There is no self-hosting option. Memory is not persistent by default, state management is the developer's responsibility. The SDK produces no durable artifact from a completed task; what the agent learned is not captured in a portable, human-readable form.

Hermes runs entirely on infrastructure you control. Memory persistence is the default architecture, not a configuration option. Skill files are Markdown, auditable, git-versionable, readable without tooling. If you complete a complex research task today, the agent writes a skill file describing how it did it; the next time a similar task appears, that file is available to reuse.

The trade-off is real: OpenAI's SDK has more production deployments, better observability tooling (no LangSmith equivalent exists for Hermes), and tighter integration with Azure OpenAI stacks. For teams with existing OpenAI infrastructure, the migration cost is non-trivial.

Hermes Agent vs. Anthropic Claude with computer use (Claude Code)

Claude Code is IDE-integrated, has no persistent cross-session memory, no messaging platform integrations, and is effectively locked to Claude models. It is meaningfully better than Hermes at software engineering tasks inside a local codebase. LSP integration, diff-awareness, and workspace context are more refined for pure development work.

Nous Research's own framing draws the distinction clearly: Hermes "sits between a Claude Code style CLI and an OpenClaw style messaging platform agent." You can run Hermes with a Claude model via OpenRouter, but you can swap to Kimi K2.5 or local Mistral without changing a configuration file. Claude Code cannot be made model-agnostic. And crucially: a difficult debugging session in Claude Code leaves no residue. A difficult debugging session in Hermes can produce a skill file that makes the next similar session faster.

One YouTube creator documented this concretely: $3 per day running a full content workflow (competitor analysis, scraping, image generation, draft writing) with Hermes plus a budget model (Kimi K2.5), versus $100 per day running the same work through OpenClaw plus Claude. The cost reduction came from model choice enabled by Hermes's architecture, not from Hermes itself being cheaper to run.

The sycophancy problem and other real frustrations

Nous Research markets GEPA (Goal-Evaluation-Planning-Action) self-evaluation as a core differentiator. The internal benchmark: 40% faster on repeated tasks after the agent accumulates 20+ self-generated skills. That figure is Nous Research's own measurement, it has not been independently verified by third parties as of April 2026. Treat it as directionally plausible, not confirmed.

The more immediate problem is that the self-evaluation mechanism does not appear to work as described in practice. The agent assesses its own work approximately every 15 tool calls. Users report that it consistently rates its output as successful regardless of actual quality.

"It always thinks it did a good job. ALWAYS. It thought it kicked ass!"

, u/CustomMerkins4u, Reddit, +107 upvotes

This is a sycophantic self-scoring problem, a known failure mode in autonomous agent design where the evaluation loop lacks the independence needed to catch genuine errors. No fix has been shipped as of April 2026. The implication is that the skill files the agent generates to accelerate future tasks may encode confident but flawed approaches, compounding rather than resolving errors over time.

Three other frustrations come up consistently:

• Token overhead is underemphasized. Reddit user u/Witty_Ticket_4101 ran forensics showing that tool definitions consume 8,759 tokens per request, 46% of available context. The Telegram gateway adds 2–3x overhead compared to CLI. The "40–60% cost reduction via multi-model routing" the project promotes requires active configuration; it does not happen automatically.
• Documentation lags feature velocity. Releases ship every 3–7 days. API stability between minor versions (v0.x) is not guaranteed, which the official FAQ acknowledges. Skills written for v0.8 can behave differently in v0.10 without changelog coverage.
• Local model throughput degradation on consumer hardware. One r/LocalLLaMA user reported 1–2 tokens per second through Hermes versus 45 tokens per second natively via LMStudio. Python overhead, context injection, and tool parsing all contribute.

The setup experience itself is not frictionless. @chrysb, the same observer who later called Hermes the fastest-growing agent of all time, also wrote:

"hermes agent setup is way more tedious than setting up @openclaw!"

, @chrysb on X, March 2026

Both tweets are true. The growth numbers are real. The setup friction is also real. These are not contradictions, they are an accurate description of an early-stage open-source tool with strong architectural fundamentals and an unfinished developer experience.

Who Hermes is for

The ideal Hermes setup, per cofounder @Teknium: Ubuntu or Debian Linux, OpenRouter or Nous Portal as the model provider, local backend execution. That framing tells you most of what you need to know about the intended user.

Hermes is a strong fit for developers who want a personal agent that accumulates workflow memory over months; users escaping API vendor lock-in after incidents like the OpenClaw enforcement; users running budget models (Kimi, Qwen, local Mistral) where model-agnosticism has direct cost implications; Linux and macOS users comfortable with CLI setup; privacy-focused users (MIT license, no telemetry, fully self-hosted); and open-source contributors willing to trade stability for influence, the founder is directly responsive on Discord, and the 274-contributor base reflects genuine community ownership.

It is a poor fit for Windows-native users (WSL2 required, no native path); teams needing production observability (no audit log, no LangSmith equivalent); enterprises needing SLA support or SOC2 compliance; anyone requiring stable APIs (v0.x semantics are not guaranteed); users whose primary need is IDE-integrated software development (Claude Code or Cursor are better fits for that job); and anyone who needs reliable self-assessment, the sycophancy bug is unresolved and affects any workflow where the agent's own evaluation is load-bearing.

The framework is also technically used in Nous Research's own agentic reinforcement learning pipeline, the lab runs Hermes to train the Hermes models. That is either a confidence signal or a flag about the boundary between product and internal tool, depending on your perspective.

Last tested: April 2026. Score reassessment recommended at v1.0.

``` ---