211K Stars and the Hermes Revelation: How to Fix Claude Code's Memory Shortcomings

Why an Agent with a "Good Memory" Can Rack Up 210K Stars in Five Months

In a Chinese-subtitled video posted on Bilibili by an overseas tech blogger, a counterintuitive conclusion is put forward: Hermes Agent went from zero to 211,000 GitHub stars in five months, and it wasn't integrations or self-building skills that got it there—it was the ability to remember everything. Someone analyzed 1,300 Reddit comments about users migrating from OpenClaw^Ad to Hermes, and about 30% of migrants explicitly cited "memory defaults" as their reason for switching.

One frequently quoted comment: "Remembering context is worth more than a thousand integrations." This hits a sore spot in current Agent products—connecting a bunch of tools you never really needed is far less valuable than remembering a business rule you set three months ago.

The video's author breaks Hermes's memory system into three reusable concepts: storage, injection, and recall. Storage addresses "how and where to store important things"; injection addresses "what to automatically load at the start of each session"; recall addresses "how to find old things when asked, and how accurately." This triad is exactly a practical yardstick for evaluating any Agent memory solution.

Claude Code's Memory Status Quo: A Gap the Market Is Targeting

As of the video's release (July 2026), Claude Code's built-in memory is indeed weak. It writes what it deems important into a memory.md index, and during injection it almost only loads code.md and this index, while recall traverses session files from the past 30 days and matches by keyword.

This means: if you originally discussed "Stripe" and later asked about "payment processing," the system likely won't find that conversation. No keyword overlap means the memory effectively doesn't exist. The market's response is direct—a batch of open-source or paid frameworks has grown up specifically around this pain point, and Hermes is the fastest-growing among them.

Interestingly, Hermes's real competitor is the "session model" itself. Its core proposition: the next layer of value lies in continuity, not just the intelligence level of a single conversation. Model capabilities can keep improving, but whether historical conversations can be accurately retrieved is a separate moat.

Hermes's Three Merits and Three Real Flaws

The video's author doesn't accept Hermes wholesale. He distills three designs worth copying and points out three limitations that give pause.

Merit one: frozen snapshot. Information like pricing, active customers, and current decisions shouldn't be looked up from long-term memory every time; it should be silently injected at session start. Hermes maintains a memory.md with a character limit (the author's own implementation caps at 2,500 characters) to prevent context bloat.

Merit two: the Agent decides what to store. Users shouldn't have to manually judge which sentence is worth remembering. Hermes self-prompts to persist knowledge after each turn; the author's approach is to attach a hook that judges each turn whether there's a "persistent fact" worth keeping—decisions, price changes, personal preferences—and writes it to the snapshot after deduplication.

Merit three: full retention. Hermes stores every session in a local database, keeping raw messages rather than summaries, so any point in time can be traced back. The author goes further: generate a summary each turn while retaining the full transcript, with summaries archived as long-term memory and transcripts used for precise citation.

Flaw one: the self-rewriting loop. Hermes's most famous self-editing skill is also its biggest risk. Multiple reports show it overestimates results when editing its own skills, overwriting originally correct information. Community users have had to add approval gates and rollback features as a safety net.

Flaw two: separate runtime. It's a completely different process from Claude Code, running on a server or VPS with its own model billing, security surface, and update cycle—maintenance costs are not negligible.

Flaw three: hard memory cap. Character limits compress or even replace entries, and some users have written plugins specifically to stop resident instructions from being repeatedly forgotten.

What is FTS5: FTS5 (Full-Text Search 5) is a full-text search extension module built into SQLite. It accelerates text matching via an inverted index and supports boolean queries, phrase search, and prefix matching. Its advantages are zero dependencies, lightness, and extremely fast queries, making it suitable for embedded scenarios; its limitation is that it's still fundamentally lexical matching—synonyms, paraphrases, and cross-language expressions cannot be automatically aligned. So when a user searches for "payment processing" against a conversation that originally used "Stripe" as a keyword, FTS5 returns empty results because the word forms don't overlap. This is also the structural ceiling of Hermes's recall capability; only an external vector search (such as mem0, honcho) can fill in the semantic layer.

Rebuilding Inside Claude Code: Semantic Recall Is the Key Divide

The author's approach is to rebuild in place inside Claude Code, for three reasons: files live in a folder and can migrate across interfaces like Claude Code and Codex; no VPS or second model billing is needed, everything runs on the existing subscription; data stays local, with no extra security surface.

What really makes the difference is the recall step. Hermes uses SQLite's FTS5 for full-text search, which is still essentially keyword matching. An open issue on its GitHub explicitly states: session search relies entirely on FTS5 keyword matching, and a query must contain the exact words from the conversation to hit.

The author switched to PG vector for vector embeddings, supporting both semantic and keyword retrieval, reranking results, and expanding context to neighboring conversations. He admits Hermes can compensate by plugging in mem0, honcho, and other plugins, but that's yet another service requiring ops.

Beyond recall, the author added three things Hermes lacks: source citation (when citing, state the exact words, decision-maker, and date; admit when you don't know); history import (a single command scans existing Claude Code sessions, summarizes with Haiku, then embeds into long-term memory while retaining full transcripts for later retrieval); and team isolation (each memory is tagged by ownership, queries are filtered by asker—one shared brain, each sees their own).

Vector embeddings and semantic retrieval: Vector embedding maps a piece of text into a high-dimensional numerical vector, where semantically similar texts are closer in vector space. At retrieval time, the query is also embedded as a vector, and nearest neighbors are found via cosine similarity or inner product, thereby hitting historical conversations that are "phrased differently but mean the same thing." PG vector (pgvector) is a vector extension for PostgreSQL that can store both relational data and embedding vectors in the same database, supporting IVFFlat/HNSW indexes to accelerate approximate nearest neighbor queries. Compared to pure keyword matching, it solves the problem of recalling synonymous paraphrases and cross-expression statements; combined with reranking and context window expansion, recall precision can be further improved. The cost is the need for embedding model calls and vector storage ops.

Consensus and Divergence Across Multiple Perspectives

This analysis is not a lone data point. The video cites Kilo's statistics on 1,300 Reddit comments and also quotes direct feedback from multiple users, forming cross-validation with the author's own horizontal breakdown of three memory systems. On the point that "memory matters more than integrations," multiple sources are highly consistent, which can be regarded as a general consensus among current Agent users.

The divergence lies in the choice of path. One camp believes using Hermes out of the box is easier, accepting its self-rewriting risk and separate ops cost; the other camp, like the author, insists on holding the memory layer in their own hands, trading for portability and controllability with files plus a local vector store. The former wins on speed to start; the latter wins on long-term maintainability—it depends on whether you fear "configuration hassle" or "memory being overwritten" more.

What needs to be flagged as a single source is the "team OS" part: it's a beta feature being tested within the author's community, with no third-party verification, so readers should treat it as directional reference rather than a mature solution.

Sample limitations of the migration analysis: The 1,300 Reddit comments cited in the article are a self-selected sample—only users with strong feelings about migrating will post, so the 30% figure reflects "the proportion among those who speak out," not the actual migration rate of all users. In addition, the phrase "memory defaults" in the comments may simultaneously cover multiple sub-dimensions such as injection strategy, storage limits, and recall precision, so the statistical scope is not uniform. The value of such community data lies in revealing demand direction and pain point distribution, not in providing precise quantitative conclusions; cross-validating it with the author's own horizontal breakdown is more reliable than relying on either alone.

What This Means for Ordinary Users

For individual developers, the most practical action is to check what your Agent actually remembers. Open memory.md and see whether the entries are still accurate; ask it about a decision from three months ago and see whether it can reproduce the source. If recall relies only on keywords, you'll eventually hit the frustration of "I clearly said it, but it can't find it."

For teams, memory ownership and isolation will become the next must-have. One shared brain, filtered by project and member, reduces repetitive communication more than simply stacking integrations.

Hermes proves that the need for memory is real, but it doesn't prove you must migrate to Hermes to get that memory. Breaking the logic into three layers—storage, injection, recall—and implementing it with your own controllable files and local retrieval is another equally valid path—and in the long run, the assets on that path truly belong to you.

One-line Summary

Hermes gained 210K stars in five months thanks to memory, but the semantic recall gap makes a self-built solution preferable.

Paragraph Summary

The article analyzes why Hermes Agent racked up 211,000 GitHub stars in five months, pointing out that the core is not the number of integrations but memory capability, with about 30% of migrating users citing memory defaults as the main reason for switching. The author breaks the memory system into three layers—storage, injection, recall—as an evaluation yardstick, noting that Claude Code's built-in memory is weak: it only loads the memory.md index, and recall relies on keyword matching within 30 days, so no word overlap equals forgetting. Hermes's merits include frozen snapshot injection, Agent-decided storage, and full retention of raw transcripts; its flaws are that self-rewriting may overwrite correct information, the ops cost of a separate runtime, and a hard character cap on memory. The author chooses to rebuild in place inside Claude Code, using PG vector for semantic recall, and adds three capabilities: source citation, history import, and team isolation. The result is a consensus that "memory matters more than integrations," but there is a divergence of paths between migrating to Hermes and building your own memory layer.