The state of Hermes Agent — July 2026

TL;DR

The May report ended with Hermes Agent at 165,033 GitHub stars, 27,160 forks, 123 Atlas-tracked ecosystem projects, and a thesis: the Curator → Tenacity → Foundation run had turned Hermes from a fast-moving agent harness into infrastructure you could actually install and trust.

Eight weeks later, the story is different again. Hermes did not just get bigger. It got a surface area.

As of July 17, 2026:

• 216,354 stars on the core repo (+51,321 since May 24)
• 40,502 forks (+13,342)
• v0.18.2 is the latest release; v0.15 → v0.18.2 added roughly 6,000 commits and 3,700+ merged PRs across four major releases plus patch tags
• 203 Atlas-tracked projects (+80) with 1,174,854 combined GitHub stars (~3.0x since May)
• Workspaces & GUIs exploded from 11 repos / 28.7K stars to 19 repos / 200.7K stars
• Skills & Skill Registries became the largest Atlas category by stars: 34 repos / 377.4K stars, driven by obra/superpowers, open-design, Anthropic/NVIDIA-style skill libraries, and the broader agentskills.io-compatible ecosystem
• Memory & Context kept growing, but no longer owns the whole story: 30 repos / 177.5K stars
• Hermes now has a native desktop app, a browser admin panel, richer Telegram rendering, official WhatsApp Business support, ntfy, Photon iMessage, Raft, image editing, background subagents, automation blueprints, first-class Mixture-of-Agents, /learn, /journey, and completion contracts for /goal
• The v0.18 “Judgment” release cleared 100% of open P0/P1 items and reframed the roadmap around verification: “done” should mean evidenced, not asserted

The shorthand: May was about installability. July is about usability and judgment. Hermes is no longer just the agent that grows with you. It is becoming the agent you can give work to, watch, correct, govern, and eventually trust as part of a team workflow.

1. Eight weeks of delta

May 24 figures are quoted from the prior report. July figures were polled live from GitHub and the Atlas repository data on July 17, 2026. Atlas counts refer to quality-filtered, Hermes-relevant projects — not a generic agent-tools directory.

Two things changed since May.

First: the ecosystem crossed the million-star line. Some of that is category mix — large adjacent projects now have explicit Hermes compatibility or integrations — but the direction matters. Hermes is increasingly showing up not as a standalone repo, but as a compatibility target: workspaces, skill systems, memory engines, coding tools, and orchestration frameworks want to be usable from Hermes.

Second: Memory stopped being the only breakout category. In May, Memory & Context was the story. In July, the breakout is surface area: desktop, web workspaces, cross-CLI managers, browser admin, skill browsers, and coding cockpits. That is a healthier ecosystem shape. Memory is infrastructure. Surfaces are distribution.

2. The release arc: Velocity → Surface → Reach → Judgment

The last report covered the Curator → Tenacity → Foundation trilogy. This window has its own arc.

v0.15 “Velocity” — the codebase got smaller, the agent got faster

v0.15 was the “make the machine easier to improve” release.

The headline was the run_agent.py refactor: the 16,083-line heart of the agent loop collapsed to 3,821 lines, with behavior-preserving forwarders and 14 cohesive agent/* modules. That is not glamorous in a demo, but it matters: the easier the core loop is to understand, the faster Hermes can keep compounding.

Other important pieces:

• Kanban matured into a real multi-agent platform across 104 PRs: task decomposition, swarm topology, gated verifier/synthesizer, per-task model overrides, worktrees, scheduled starts, claim TTLs, retry fingerprinting, and worker visibility endpoints
• session_search was rebuilt from an aux-LLM summarizer into a direct SQLite/FTS5 tool: ~20ms discovery, ~1ms scroll, no LLM cost, no hallucinated session summaries
• Promptware defenses landed against Brainworm-class attacks: threat-pattern scanning on memory/tool/skill surfaces and explicit delimiters around untrusted tool output
• Bitwarden Secrets Manager support moved credentials toward one bootstrap token instead of plaintext API sprawl
• ntfy became the 23rd platform, giving Hermes a lightweight push-notification surface
• Skill bundles made multi-skill workflows loadable with one slash command
• The Nous-approved MCP catalog gave users a trusted server picker instead of “go search GitHub and hope”

Velocity was not about one shiny feature. It was about reducing friction in every layer: startup, search, skills, secrets, multi-agent coordination, and the core code path itself.

v0.16 “Surface” — Hermes got a real app

v0.16 is the release future users will probably remember more clearly than insiders do.

Hermes Desktop arrived as a native macOS / Linux / Windows app: chat UI, streaming, session list, drag-and-drop files, model picker, command palette, multi-profile sessions, self-update, and remote gateway connection over OAuth or username/password.

That changes the funnel. Before v0.16, telling someone to try Hermes usually meant convincing them that a CLI agent with a gateway was worth the setup. After v0.16, the pitch is much easier: install the desktop app, connect your provider, talk to the same agent core.

v0.16 also turned the web dashboard into an admin panel: MCP catalog management, messaging channels, credentials, webhooks, memory configuration, gateway controls, and system diagnostics from the browser. Combined with Quick Setup via Nous Portal, Hermes started looking less like a hacker tool and more like software.

Other important changes:

• Full Simplified Chinese desktop translation
• Leaner default skill set; heavier/niche skills moved optional
• NVIDIA/skills joined the trusted Skills Hub taps
• Fuzzy model picker across desktop, web, TUI, and CLI
• /undo [N] across surfaces
• Security fixes including Starlette CVE pinning, SSRF off-loop hardening, and subprocess credential stripping

Surface is the moment Hermes stopped requiring users to live in the terminal.

v0.17 “Reach” — more places, richer work, fewer blocked chats

v0.17 extended Hermes outward.

The visible additions:

• Photon iMessage without a Mac relay: hermes photon login, device-code auth, managed line pool
• Raft as a gateway channel for agent-network wakeups
• Official WhatsApp Business Cloud API support alongside the existing Baileys bridge
• Rich Telegram rendering via Bot API 10.1
• Image-to-image editing in image_generate, not just text-to-image generation
• Automation Blueprints so recurring jobs can be configured by answering questions instead of writing cron syntax

The deeper additions:

• Background / async subagents: delegate long-running work and keep talking; results re-enter later as a new turn
• Dashboard profile builder: create a complete Hermes profile — model, skills, MCP servers — from the browser
• Skills Hub rehaul with connected hubs, featured skills, previews, and security scans
• Atomic memory batch operations: add/replace/remove in one call against the final budget, so the agent can free space and save the new fact without a fragile multi-step dance
• Curator cost optimization: routine stale-skill pruning is free; LLM-powered consolidation is opt-in
• Managed scope: admin-pinned, user-immutable config and secrets from root-owned /etc/hermes
• Multiplex all profiles over one gateway process and pluggable cron scheduler groundwork

Reach is the release where Hermes started to feel less like “my agent session” and more like “my agent service.”

v0.18 “Judgment” — done means proven

v0.18 is the most strategically important release of the window.

The headline was operational: the team resolved 100% of open P0/P1 items across the repo. The release notes cite roughly 692 highest-priority issues/PRs resolved in the sweep and about 1,950 total issues and PRs closed during the window.

But the product story is bigger than backlog closure. v0.18 reframed Hermes around judgment.

Key pieces:

• Mixture-of-Agents as a first-class selectable model — named MoA presets appear under a moa provider in model pickers
• Reference-model reasoning is visible — you can read each model’s output before the aggregator synthesis streams in
• Verification evidence for coding work — Hermes records what checks actually ran and can use that evidence to decide whether work is complete
• /goal completion contracts — you state what “done” means; the loop judges completion against evidence, not vibes
• /learn <anything> — turn a directory, URL, or freshly taught workflow into a reusable skill
• /journey — a timeline of what Hermes has learned about you, with edit/delete affordances
• Desktop memory graph — a playable radial timeline of memories and skills
• Background fan-out — delegate multiple subagents in parallel without blocking the chat
• First-class desktop Projects — per-profile project sidebar, coding rail, review pane, git worktree management, and project-aware agent tools
• Scale-to-zero and drain coordination — gateway dormancy, quiesce-before-restart, and safer hosted/team deployments
• Cheaper background review — the self-improvement fork can route to an auxiliary model, digest context, and adapt cadence
• Google Vertex AI provider with short-lived OAuth token refresh for Gemini through GCP

This is the release where Hermes starts attacking the thing every agent demo lies about: completion. Not “the agent says it’s done.” Not “the final message sounds confident.” Actual evidence. Checks. Contracts. A record of what happened.

That is the right problem.

3. The strategic shift: from harness to operating surface

The May report’s thesis was that Hermes was becoming the subscription bus for the AI stack: one agent runtime that can route across the model subscriptions and tool providers you already pay for.

That thesis still holds. But July adds a second layer: Hermes is becoming an operating surface.

You can now approach Hermes through:

• CLI / TUI for power users
• Native desktop app for daily work
• Web dashboard for admin and setup
• Telegram / Discord / Slack / Teams / WhatsApp / Signal / Email / SMS / Matrix / Mattermost / Feishu / WeCom / Weixin / QQ / Yuanbao / LINE / ntfy / Raft / IRC / browser surfaces
• Kanban boards for durable multi-agent work
• Cron and Automation Blueprints for recurring workflows
• MCP, skills, plugins, and provider profiles for extension
• Desktop Projects for coding workflows

That is not “one chat app.” It is a personal agent operating layer.

The important part is that these surfaces share the same underlying agent: same sessions, same memory, same skills, same gateway, same tools. Hermes Desktop is not a separate product pretending to be Hermes. It is the same Hermes core exposed through a better interface.

That architectural choice matters. Many agent products fragment into separate apps, wrappers, cloud runtimes, and plugin systems. Hermes is trying to keep the core loop coherent while expanding the number of places you can touch it.

If it works, the surface-area expansion becomes a moat. Every new channel is another place the same agent can be useful. Every new skill or memory provider improves the same agent. Every new dashboard/admin affordance reduces the setup tax for the next user.

4. The ecosystem at 203 curated projects

Updated Atlas category breakdown as of July 17:

The category winners tell the story.

Skills became the largest category

The surprising line item is Skills & Skill Registries: 20 → 34 repos, 15.6K → 377.4K stars.

That is partly because obra/superpowers is enormous, but the broader pattern matters. Hermes’ bet on portable procedural memory now sits inside a wider shift toward skills as a standard interface for agent behavior. OpenAI, Anthropic, HuggingFace, NVIDIA, community registries, and agentskills.io-compatible projects are converging on the same shape: reusable instructions, scripts, references, and workflows that an agent can load when needed.

Hermes is well-positioned here because skills are not an afterthought. They are part of the learning loop.

Workspaces & GUIs are the adoption layer

Workspaces & GUIs went from 28.7K to 200.7K stars. The category now includes cross-agent CLI managers, web UIs, desktop companions, and coding workspaces that make Hermes easier to operate.

The strongest signal is not any one repo. It is the fact that people are building front doors for agents. That usually happens when a system is powerful enough to need usability layers.

Memory kept compounding, but normalized

Memory & Context is still strong: 30 repos, 177.5K stars. mem0, supermemory, OpenViking, gbrain, hindsight, honcho, byterover, and others continue to define the category.

But memory is no longer the only lens for Hermes. That is good. A memory-only agent is interesting. A memory-enabled agent with desktop, dashboard, skills, projects, kanban, verification, and messaging surfaces is a product platform.

5. The big new axis: evidence

The most important word in the v0.18 release notes is not “MoA” or “desktop” or “P0.” It is evidence.

Agents fail in a predictable way: they claim completion before reality agrees. They say tests passed when they did not run tests. They say a file exists when they did not read it back. They call a plan “implemented” when only the happy path was touched.

Hermes is now building primitives that fight that failure mode directly:

• Verification evidence ledger for coding work
• Completion contracts for /goal
• pre_verify hooks
• Check-aware stop loops
• PR-style diffs and review panes in desktop
• Kanban verifier/synthesizer patterns
• Background fan-out with consolidated returns
• Journey/memory/skill visibility so learning can be audited

This is the right direction because agent reliability will not come from better vibes. It comes from systems that make it easier to prove work happened.

That also creates a cleaner line between demos and production. A demo can stop at the final answer. Production needs evidence: logs, tests, diffs, screenshots, artifacts, approvals, and rollback paths.

Hermes is moving toward the production side of that line.

6. May predictions — scored honestly

The May report ended with three things to watch through the end of Q2. Here is how they held up.

1. The Foundation release tail

Prediction: v0.14 was big; the follow-up release would show whether packaging, lazy deps, Windows, and the OAuth proxy survived contact with users.

Verdict: mostly shipped. v0.15.1 and v0.15.2 were exactly the kind of patch tail you expect after a large release: dashboard reload loop, Docker insecure opt-in, MCP command resolution, bundled plugin manifests in wheels/sdists, and related cleanup. Then v0.15 and v0.16 pushed forward instead of stalling. The Foundation tail existed, but it did not consume the roadmap.

2. Multi-agent durability getting tested

Prediction: Kanban needed real-world pressure; expect either case studies or a long bug list.

Verdict: the infrastructure deepened faster than the public case studies. Kanban gained swarm topology, task decomposition, worktrees, verifiers, scheduled starts, dashboards, file attachments, board isolation, and worker lifecycle controls. Background subagents and background fan-out also arrived. The public “here is a company replacing X with Hermes Kanban” story is still early, but the substrate is much stronger than it was in May.

3. The first credible “I replaced X with Hermes” piece

Prediction: The infrastructure was becoming sufficient for a team/dept case study.

Verdict: not yet in the public narrative. The pieces are closer — desktop, profile builder, managed scope, scale-to-zero, drain coordination, richer auth, official WhatsApp, Teams, project surfaces — but the market still needs a crisp public adoption story. The likely first version is not “Fortune 500 replaces support with Hermes.” It is more likely: a small team running Hermes as an internal ops/coding/research agent across Telegram, desktop, kanban, and cron.

7. What to watch in Q3

Three calls for the next report.

1. v0.19 and the post-Judgment consolidation

v0.18.1 and v0.18.2 were patch tags, and the release notes say the full curated notes for the post-v0.18.0 window will ship with v0.19. That makes v0.19 the next important signal. Does Judgment become an operating discipline, or was it a one-time sweep?

Watch for whether P0/P1 actually stay near zero and whether verification contracts become default user behavior rather than a power-user feature.

2. Desktop adoption vs. CLI identity

Hermes now has a real desktop app. The question is whether the community embraces it as the default front door or treats it as a nice wrapper around the “real” CLI.

If desktop becomes the default, Hermes’ addressable user base expands dramatically. If the CLI remains the culture center, Hermes stays powerful but narrower.

The best outcome is both: CLI for operators, desktop for daily users, dashboard for admins, all sharing the same core.

3. Skills as the public distribution layer

The Atlas category data says skills are now the largest visible ecosystem bucket. The question is whether that turns into a real distribution loop:

• Users teach Hermes workflows with /learn
• Curator keeps personal libraries clean
• Trusted taps provide high-quality public skills
• Agentskills-compatible projects make skills portable across agents
• The best skills become de facto workflows people share, fork, and improve

If that loop works, Hermes’ self-improvement story becomes visible outside one user’s machine.

4. Hosted/team Hermes

Scale-to-zero, managed scope, profile multiplexing, secure dashboard login, drain coordination, and desktop remote-backend support all point in the same direction: Hermes as a hosted or team service.

The open question is product shape. Is it a self-hosted team appliance? A managed Nous offering? A reference architecture for agencies/internal ops teams? A marketplace of agent workspaces?

The technical pieces are arriving. The packaging is the thing to watch.

About this report

Methodology: Synthesized from the May 2026 State of Hermes report, the live Hermes Agent GitHub release notes for v0.15.0 through v0.18.2, the official Hermes documentation, the live Hermes Atlas repository data, and fresh GitHub polling on July 17, 2026.

Data freshness: Core repo stars/forks were polled from GitHub on July 17, 2026. Atlas category totals were computed from the current ksimback/hermes-ecosystem main-branch data/repos.json, then refreshed against GitHub GraphQL for live star counts. Release statistics are quoted from official release notes; approximate counts remain approximate where the release notes use ~.

Companion to: The State of Hermes Agent — May 2026 and The State of Hermes Agent — April 2026.

Not affiliated with: Nous Research. Hermes Atlas is an independent community project celebrating and mapping the Hermes ecosystem.

Corrections welcome: Open an issue.