The state of Hermes Agent — September 2026

TL;DR

The July report ended with Hermes Agent at 216,354 GitHub stars, 40,502 forks, 203 Atlas-tracked projects, and a thesis: Hermes was becoming an operating surface built around evidence.[7]

Two months later, the surface did not merely expand. It became continuous, conversational, and multi-agent.

As of September 18, 2026:

• 246,755 stars on the core repo (+30,401 since July 17, +14.1%)[7][8]
• 51,729 forks (+11,227, +27.7%)[7][8]
• v0.21.3 is the latest tagged release; 13 release tags landed after the July data cutoff, from v0.19.0 through v0.21.3[8][13]
• 250 Atlas-tracked projects (+47) with 1,412,024 combined GitHub stars (+237,170, +20.2%)[4]
• Skills & Skill Registries remains the largest Atlas category: 48 repos / 448,398 stars[4]
• Memory & Context was the fastest-growing large category: 38 repos / 240,354 stars, up 35.4%[4][7]
• Workspaces & GUIs reached 24 repos / 232,812 stars[4]
• v0.19 cut first-turn startup latency by roughly 80%, made background delegation durable, and introduced live subagent transcripts[9]
• v0.20 brought real-time voice, barge-in, wake words, A2A v1.0, signed outbound webhooks, grounded citations, mid-turn steering, and self-recovering tools[10]
• v0.21 made Bot Mode a built-in desktop experience, added bot-to-bot messaging, gave cron jobs memory and continuity, made subagents steerable while running, and turned MCP management into a first-class control surface[11]
• v0.21.2 then exposed the cost of that pace: a dedicated state.db reliability campaign closed 44 issues after session-store regressions in v0.21.0/0.21.1[12]

The shorthand: July was about evidence. September is about continuity and coordination. Hermes is moving from “an agent you can trust with a task” toward a persistent society of agents you can talk to, schedule, steer, and inspect.

That is a more ambitious product—and a harder systems problem.

§1 — Eight weeks of delta

July figures are quoted from the prior report. September core figures were polled live from GitHub; Atlas category totals were computed from the September 18 main branch and live-refreshed through GitHub GraphQL. One unavailable repository retained its stored Atlas star count.[4][7][8]

Three signals matter.

First: growth slowed, but it broadened. Core stars grew 14.1% while the curated ecosystem grew 20.2%.[4][7][8] Hermes is no longer in launch-week hypergrowth; the more important signal is that the surrounding stack continues to outpace the center.

Second: forks are growing almost twice as fast as stars. Stars rose 14.1%; forks rose 27.7%.[7][8] Forks are an imperfect proxy, but this is directionally consistent with a community moving from attention toward modification, deployment, and integration.

Third: the gains are concentrated in the layers that make agents reusable. Skills, memory, and workspaces added 165,941 stars—70% of the Atlas-wide increase.[4][7] Those are the layers that preserve know-how, preserve context, and give people somewhere to operate the system.

The core repo now represents only about 17.5% of tracked Atlas stars.[4][8] Some of the remainder comes from large adjacent projects that explicitly support Hermes rather than being Hermes-exclusive. That distinction matters: the Atlas measures compatibility and ecosystem surface, not direct Hermes adoption.

§2 — The release arc: Quicksilver → Herald → Pantheon → Hardening

The July report described Velocity → Surface → Reach → Judgment. The next three major releases form a cleaner product arc:

1. Quicksilver: make the system fast and durable enough to stay in the loop.
2. Herald: let it speak to people, agents, and external systems.
3. Pantheon: turn many agents into an understandable, persistent team.
4. Hardening: make that team safe enough to keep running.

v0.19 “Quicksilver” — speed became a product feature

v0.19 cut cold submit-to-dispatch latency from roughly 4.3 seconds to 0.9 seconds, an approximately 80% reduction across CLI, gateway, TUI, desktop, and cron. The desktop received a parallel performance wave: 14× less streaming-markdown splitter CPU, virtualized large diffs, less layout thrash, and lower per-token rendering cost.[9]

That performance work matters because latency compounds. A personal agent is not used once; it is interrupted, redirected, resumed, and consulted dozens of times a day. Every second of friction taxes the habit loop.

But Quicksilver was also a durability release:

• Finished responses gained a delivery-obligation ledger so a gateway crash between generation and platform delivery no longer silently loses the answer.[9]
• Background subagent results became durable across process restarts.[9]
• Live transcript files made delegated work inspectable while it ran.[9]
• One gateway could route different servers, channels, or threads to isolated profiles.[9]
• Bitwarden and 1Password became pluggable secret sources.[9]
• Smart approvals became the default, with user deny rules and reasoned rejections.[9]

The strategic shift is subtle: Hermes was no longer optimizing only the model turn. It was optimizing the whole operational loop around the turn—startup, approval, delegation, delivery, and recovery.

v0.20 “Herald” — the agent gained a voice and a protocol surface

v0.20 is the broadest release in this reporting window. Its headline was real-time conversational voice: streaming TTS, voice interruption during generation and playback, on-device wake words, and platform-aware speech across the CLI, desktop, and audio-capable gateway channels.[10][18]

The deeper theme was communication in every direction:

• Human ↔ agent: streaming voice, barge-in, wake phrases, and hands-free stop.[10]
• Agent ↔ agent: a bundled A2A v1.0 plugin.[10][19]
• Agent → systems: signed outbound lifecycle webhooks.[10][20]
• Agent → reader: grounded citations with evidence-checked quotes and a fact-checking mode.[10]
• User → active agent: mid-turn redirects that preserve work already in flight.[10]
• Tool → agent: self-recovery hints, full-output spill files, verified writes, and better failed-search recovery.[10]

This is where the July “evidence” thesis became productized beyond coding checks. Research acquired a provenance layer.[10] Webhooks made agent activity externally observable.[10] Tools became better at reporting their own failure state instead of making the model infer what went wrong.[10]

The desktop app also crossed another line. Artifacts gained sandboxed live previews; a plugin SDK shipped with Kanban as the founding plugin; quick-entry, multiple windows, and SSH remote backends pushed Desktop from client toward workbench.[10]

Herald’s real contribution was not voice by itself. It gave Hermes interfaces between systems: speech, A2A, webhooks, citations, plugins, and steerable turns.

v0.21 “Pantheon” — multi-agent became legible

Multi-agent systems are usually sold as architecture diagrams: routers, supervisors, workers, tools. Pantheon made the concept look like software normal people already understand.

Bot Mode now ships as a bundled desktop experience.[11][14]

Profiles become named agents with identities and avatars.[11]

Users can create group rooms, mention individual bots, inspect attributed messages, and maintain durable bot-to-bot conversations.[11]

hermes peer extends the same model across profiles and gateways.[11]

That is not cosmetic. The chat metaphor gives multi-agent work three things infrastructure diagrams do not:

• Identity: which agent owns this role?
• Addressability: who should receive this request?
• Inspectability: what did the agents tell each other?

Pantheon also made the agents more continuous:

• Cron jobs can load and update persistent memory.[11][15]
• continuity=true carries prior run output into the next run.[11][15]
• Monitor-mode jobs suppress the model entirely when their source has not changed.[11]
• Each job gets a durable scratchpad.[11]
• Cron output can enter a bot’s canonical chat, where the bot can continue the conversation.[11]

And delegation became orchestration rather than dispatch. A parent can list running children, steer one mid-flight, stop it while preserving partial work, validate outputs against JSON Schema, and inspect per-delegation cost.[11][16]

This is the release where Hermes’ multi-agent story became less about “spawning workers” and more about operating a team.

Hardening — the reliability bill arrived

Pantheon’s ambition came with a real regression.[12] v0.21.0 rewrote session-store connection handling; v0.21.2’s own release notes say that some installs saw second writers cancelling locks, healthy databases classified as corrupt, and malformed rows breaking session listings.[12] The patch’s six-PR state.db campaign closed 44 issues and hardened profile isolation, WAL handling, FTS degradation, row coercion, and safe read-only opens.[12]

This belongs in the report because it changes the interpretation of the release velocity.

Hermes is shipping at extraordinary speed—v0.21 alone reports roughly 5,800 commits, 2,475 merged PRs, and 2,100 issues closed since v0.20.0.[11] That pace creates capability quickly, but it also increases integration risk in the stateful layers users trust most: sessions, memory, profiles, and delivery.

The encouraging part is the response: root-cause fixes, explicit recovery tooling, and a release note that names the failure class plainly. The caution is equally clear: as Hermes becomes an always-on personal and team system, state integrity matters more than feature count.

§3 — The strategic shift: from operating surface to agent society

The July thesis was “harness → operating surface.” September adds a third state:

harness → operating surface → agent society

“Society” is not a claim of autonomy or sentience. It is a product architecture:

• Multiple persistent identities
• Explicit roles and profiles
• Direct agent-to-agent communication
• Shared rooms with human participation
• Durable histories
• Recurring responsibilities
• Memory across runs
• Mid-flight supervision
• Cost and health visibility
• External protocols for other systems

Before this window, Hermes could run many agents. After this window, users can increasingly understand those agents as a coherent team.

That matters because the scaling problem in agents is not just intelligence. It is coordination. A single capable agent can become a bottleneck. Ten opaque workers become chaos. The product opportunity is the layer in between: identities, routing, continuity, observability, permissions, and a familiar interface for directing the group.

Hermes is assembling that layer from both ends:

• From the infrastructure side: profiles, multiplex gateways, A2A, MCP, cron, webhooks, Kanban, delegation, schemas, approvals, and persistent state.
• From the human side: Desktop, Bot Mode, group chat, inline pickers, live transcripts, artifacts, browser control, voice, and quick entry.

The risk is fragmentation. Hermes now spans a terminal agent, desktop workbench, web admin surface, messaging gateway, automation engine, multi-agent runtime, plugin host, and protocol client. The thesis works only if those remain views into one coherent system—not separate products sharing a logo.

So far, shared sessions, profiles, memory, skills, and gateway infrastructure keep the center intact. The next reports should watch whether that coherence survives continued expansion.

§4 — The ecosystem at 250 curated projects

Counts and stars are computed from the current Atlas data/repos.json with live GitHub star refresh. Category-count decreases reflect Atlas curation/removal or recategorization, not necessarily project shutdowns.[4]

Skills stayed on top

Skills & Skill Registries added 14 projects and nearly 71,000 stars. It now accounts for 31.8% of all tracked Atlas stars.[4]

The raw number is inflated by very large cross-agent projects, especially obra/superpowers, but the compatibility story is the point.[4] Skills are becoming a portable distribution format across agent runtimes, and Hermes remains unusually well positioned because skills sit inside its own learning and curation loop.

The harder next step is quality signal. Registries can count repositories and installs; they are worse at answering whether a skill reliably improves outcomes. Hermes now has pieces that could close that gap—verification evidence, schemas, advisory linting, Curator reports, and session exports—but the ecosystem still lacks a widely accepted “this skill works” layer.

Memory accelerated again

Memory & Context grew from 177,482 to 240,354 stars, a 35.4% increase—the fastest growth among the four largest categories.[4][7]

That rebound fits the core roadmap. Cron continuity, Bot Mode identities, long-lived profiles, and agent-to-agent handoffs all increase the cost of forgetting.[11] Multi-agent systems need more than user memory; they need role memory, task continuity, shared context, and boundaries between identities.

The category’s next question is not “can the agent retrieve an old fact?” It is “which agent should know what, for how long, with whose permission?”

Workspaces became the operating layer

Workspaces & GUIs reached 24 tracked projects and 232,812 stars.[4]

The category is no longer just wrappers around a terminal process.[4] It now includes cross-agent managers, desktop companions, browser workspaces, session browsers, and control surfaces.[4] Hermes Desktop’s own acceleration puts pressure on community projects to differentiate through cross-agent compatibility, specialized workflows, or better fleet operations.

That is healthy competition. The official app can optimize deeply for Hermes; community workspaces can optimize for heterogeneous stacks.

Plugins grew by count, not yet by weight

Plugins & Extensions expanded from 33 to 44 projects, the largest absolute repo gain after Skills, but the category still totals only 5,589 stars.[4]

This is early infrastructure. v0.20’s desktop plugin SDK, v0.21’s unified Plugins page, pip-discoverable model providers, security scanning, and a curated pinned plugin index all reduce the friction.[10][11][17] The next signal is whether plugin authors build durable products rather than one-off adapters.

§5 — The big new axis: continuity

July’s key word was evidence. September’s is continuity.

Continuity appears across the stack:

• A finished answer survives a gateway crash.[9]
• A delegated result survives a process restart.[9]
• A cron job remembers what it reported last time.[11]
• A bot has a canonical chat and durable identity.[11]
• A subagent can be redirected without restarting its work.[11]
• A spoken turn can be interrupted without abandoning the conversation.[10]
• A session can move across CLI, desktop, and gateway surfaces without becoming a different agent.[9][10][11]
• An external system can receive signed lifecycle events instead of polling.[10]

These are not flashy in isolation. Together they define whether an agent feels like a persistent collaborator or a sequence of disconnected model calls.

Continuity also creates obligations. The more the system remembers and acts across time, the more it must protect:

• state integrity,
• profile isolation,
• credential boundaries,
• delivery guarantees,
• auditability,
• and user control over what persists.

The v0.21.2 database campaign is therefore not a side note. It is the stress test for the entire thesis. A persistent agent is only as trustworthy as the state it preserves.

§6 — July predictions, scored honestly

1. v0.19 and the post-Judgment consolidation

Prediction: Judgment would either become an operating discipline or fade as a one-time priority sweep.

Verdict: directionally right, but not cleanly won. v0.19 extended durability and approvals; v0.20 shipped grounded citations, tool self-recovery, and stronger fact-checking; v0.21 added a verify subsystem with run-recipe detection.[9][10][11] Evidence remained part of the product architecture.

But the state.db regression shows the other side of judgment: correctness cannot be confined to task completion. The system itself has to preserve evidence, sessions, and state reliably. The response was strong; the incident means the verdict stays open.

2. Desktop adoption vs. CLI identity

Prediction: Desktop might become the default front door, or remain a wrapper around the “real” CLI.

Verdict: product convergence, adoption unproven. Desktop gained artifacts, a plugin SDK, quick entry, multiple windows, SSH backends, Bot Mode, browser control, MCP management, and diagnostics. The CLI simultaneously gained shell mode, project initialization, diff/context/focus commands, fuzzy palettes, richer status, and terminal pets.[10][11]

The best-case “both” architecture is happening. What public data still does not show is which surface users actually choose most often.

3. Skills as the public distribution layer

Prediction: /learn, Curator, trusted taps, and portable skill standards would create a visible distribution loop.

Verdict: ecosystem growth confirmed; outcome quality still unmeasured. The Atlas added 14 skill/registry projects and 70,981 category stars.[4] Core shipped new productivity skills, advisory linting, Hub fallback behavior, stacked skill invocation, and continued Curator work.[9][11]

Distribution is real. A public quality/reliability benchmark is still missing.

4. Hosted/team Hermes

Prediction: Scale-to-zero, managed scope, profile multiplexing, and remote desktop support pointed toward a hosted or team product shape.

Verdict: substantially shipped, still taking shape. Hermes Cloud connection mode, SSH remote backends, profile-based routing, fleet controls, remote MCP management, Bot Mode, and peer messaging all advanced.[9][10][11]

v0.21.2 separately hardened multi-profile isolation.[12]

The likely shape is now clearer: not one enterprise chatbot, but a managed fleet of profile-scoped agents operated through desktop, gateway, chat, cron, and protocols.

§7 — What to watch through the end of 2026

1. State integrity becomes a release gate

Hermes can survive occasional UI bugs. It cannot normalize regressions that risk sessions, memory, or profile boundaries.

Watch for database migration tests, multi-writer stress tests, recovery drills, real-filesystem CI, and whether future major releases spend less patch-window energy repairing state regressions. The standard should become simple: a release is not stable because it boots; it is stable because long-lived state survives concurrency, updates, crashes, and profile multiplexing.

2. Bot Mode proves—or fails to prove—the “agent society” thesis

Bot Mode is the most legible multi-agent interface Hermes has shipped. The question is whether it changes real workflows or remains a compelling demo.

The proof would look like durable patterns:

• a research bot feeding a writing bot,
• an ops bot escalating to a human and a specialist,
• scheduled agents maintaining shared rooms,
• profile-scoped permissions that hold under pressure,
• and clear attribution when agents disagree.

The failure mode is equally clear: too many personalities, duplicated context, and expensive conversations that are harder to manage than one good agent.

3. Cron becomes the compounding layer

Cron memory, continuity, monitor-mode suppression, durable scratchpads, and bot-chat delivery turn recurring jobs into long-lived agents rather than stateless prompts.[11]

This may be more important than Bot Mode. The most valuable agent work is often repetitive and quiet: monitor, compare, summarize only what changed, remember what was already said, and escalate when needed.

Watch for templates and public case studies that show this loop operating for weeks, not screenshots of a single run.

4. Skill quality gets a measurable trust layer

The skills category is large enough. The bottleneck is confidence.

Watch for reproducible skill tests, sandboxed evaluations, provenance, dependency/security attestations, version compatibility, and success-rate telemetry that does not compromise user privacy. The ecosystem does not need another giant list; it needs a way to distinguish a useful skill from a plausible Markdown file.

5. Interoperability moves from protocol support to cross-agent work

A2A, MCP, signed webhooks, provider plugins, remote gateways, and cross-agent workspaces are all present.[9][10][11] The next test is whether people build workflows where Hermes is one component in a heterogeneous system—and whether those workflows remain debuggable.

Protocol support is the entry ticket. Shared identity, traceability, retries, permissions, and failure semantics are the product.

About this report

Methodology: This draft compares the July 2026 State of Hermes report with live GitHub repository data and the current ksimback/hermes-ecosystem main-branch data.[4][7][8]

The release arc uses official notes for v0.19.0, v0.20.0, v0.21.0, v0.21.2, and v0.21.3.[9][10][11]

The current release pointer was cross-checked against Atlas data.[3][13]

This report treats v0.21.3 as the released boundary; post-v0.21.3 changes on main are not described as shipped.

Data freshness: Core stars and forks were polled from GitHub on September 18, 2026. Atlas category totals were computed from 250 entries in data/repos.json and live-refreshed against GitHub GraphQL on September 18. One unavailable repository (Perseus-Computing-LLC/perseus) retained its stored Atlas star count. Release notes are treated as the source for commit, PR, issue, and contributor counts; approximate figures remain approximate.

Scope note: Atlas includes Hermes-native projects and larger adjacent projects with explicit Hermes compatibility. Combined ecosystem stars measure the reach of that compatibility surface, not unique Hermes users, installs, or exclusive adoption.

Companion to: The State of Hermes Agent — July 2026, May 2026, and 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.

Stay current

The Hermes Atlas newsletter covers the releases, projects, and patterns between full reports.

→ Subscribe at hermesatlas.com — free, 1–2× per month.

— Kevin · x.com/ksimback

Sources

• [3] https://raw.githubusercontent.com/ksimback/hermes-ecosystem/main/data/latest-release.json
• [4] https://raw.githubusercontent.com/ksimback/hermes-ecosystem/main/data/repos.json
• [7] https://hermesatlas.com/reports/state-of-hermes-july-2026
• [8] https://github.com/NousResearch/hermes-agent
• [9] https://github.com/NousResearch/hermes-agent/releases/tag/v2026.7.20
• [10] https://github.com/NousResearch/hermes-agent/releases/tag/v2026.8.3
• [11] https://github.com/NousResearch/hermes-agent/releases/tag/v2026.8.31
• [12] https://github.com/NousResearch/hermes-agent/releases/tag/v2026.9.11
• [13] https://github.com/NousResearch/hermes-agent/releases/tag/v2026.9.14
• [14] https://hermes-agent.nousresearch.com/docs/user-guide/bot-mode
• [15] https://hermes-agent.nousresearch.com/docs/user-guide/features/cron
• [16] https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation
• [17] https://hermes-agent.nousresearch.com/docs/user-guide/features/plugin-catalog
• [18] https://hermes-agent.nousresearch.com/docs/user-guide/features/voice-mode
• [19] https://hermes-agent.nousresearch.com/docs/user-guide/messaging/a2a
• [20] https://hermes-agent.nousresearch.com/docs/user-guide/messaging/webhooks