Have You Been Using Hermes for Three Months and Still Reintroducing Yourself?

Many people have been using Hermes for a while and still feel it doesn’t truly “get” them. The issue often isn’t the model, but that experience hasn’t been captured. After reading this, you’ll at least be able to judge one thing: what you should write into projects, Skills, and memory, so you don’t have to cold-start every conversation.

Among the people I know, those who have genuinely used Hermes for three full months can be counted on one hand. More people just install it, hook up a model, ask a few questions, think it’s okay, and leave it running in the background. A few days later, they open it again and ask another question. A few days after that, they’re back starting from scratch—explaining what project they’re working on, where the directory is, what tone they prefer, where they got stuck last time. This works, of course, but after three months of this, the relationship between Hermes and the user hasn’t changed at all. Every answer is still a cold start, just like the day it was installed.

If You Didn’t Set Up the Entry Points Well, Three Months Is Just a Repeat of Cold Starts

This is arguably a silent waste. Because what makes Hermes valuable isn’t necessarily how smart any single answer is. Models get better every day; tomorrow’s will be stronger. What can genuinely stay local is the ability to let effective interactions accumulate through daily use, turning your repeatedly taught experience into reusable capabilities. As an acquaintance put it: spending three months talking to it, and yet it knows you less than a colleague you’ve known for two weeks—this can’t all be blamed on Hermes.

The entry points were never properly set up.

Explicit Accumulation: Write What You Keep Teaching It into the System

It took me a while to figure this out. There are roughly two types of accumulation with Hermes: explicit and implicit. The explicit type is the easiest to understand. How a project runs goes into AGENTS.md; the tone you want it to use goes into SOUL.md; tasks you do every week—like summarizing Feishu meeting notes, turning X messages into topic briefs, or checking for AI traces after writing a draft—become Skills. No need to type out “cd to backend, run pnpm install, then…” every time in the dialog. The third time you say something like that, it should already be in a file. By the twentieth time, it only shows that humans are more forgetful than machines.

Explicit accumulation and implicit accumulation are the two paths to making Hermes feel more natural over time.

In my own wenyuan configuration, I now have 195 Skills attached. Writing articles, managing Feishu, making videos, searching papers, processing images, running release pipelines—each has its own operation manual and list of “don’ts.” They weren’t written in one marathon session, nor are they just there to make the toolbox look pretty. Over three months, every time I hit a pain point, noticed a recurring process, or got corrected with “don’t do this next time,” I stuffed that little bit of experience into a Skill or project file. The benefit is simple: no need to teach it again next time.

Implicit Accumulation: Old Conversations Shouldn’t Vanish When They End

The implicit type is easier to underestimate. Hermes’s long-term memory, USER.md, MEMORY.md, sessionsearch, /save—these sound like scattered features, but they actually do something different. The commands someone has used, the files they’ve modified, the solutions they’ve discussed, the wrong answers they’ve corrected, or even the casual mention of hating certain titles or endings—this information shouldn’t evaporate when the session ends. Especially sessionsearch, which isn’t just sitting in a history list waiting to be browsed. It can pull out the truly useful piece from an old conversation when you need it.

This path isn’t as precise as Skills, nor as controllable as AGENTS.md. But over time, it changes the quality of the first exchange. After three months, you only need to say half a sentence in the same project, and it knows where you left off, roughly what you don’t want, which commands have worked on this machine before, which providers failed due to missing keys or permissions. Its first suggestions get shorter and more accurate. Saving a few words of nonsense is sometimes a qualitative leap.

What You Really Save Isn’t Time, It’s Mental Energy

I’ve been through that “starting over every time” phase myself. With the same content production project, I kept telling Hermes: the project path is in the fixed content production directory, articles go through brief, draft, final, artwork, and release stages, certain detection steps are paused, don’t open old pages, don’t misuse image ratios for WeChat and X. Saying this once is fine; twenty times is ridiculous. Eventually, I put it into AGENTS.md and project context files. Now, every time I start in that directory, the background comes in automatically, and I don’t need to spend half a page of preamble in the first message.

The gap after three months often isn’t about answer length—it’s about whether the cold start exists.

What you save isn’t just seconds. It’s mental energy.

GBrain as Supporting Evidence: An Agent Needs a Knowledge Base Behind It

Most people aren’t sensitive to this friction, because each re-explanation is too small. Repeating a project path doesn’t immediately cause pain. Pasting a bit of background doesn’t feel like a flaw in the workflow. But by month three, when project complexity increases, context grows, collaborators multiply, and past decisions build up, the Hermes that always cold-starts will force you to reassemble yourself from scratch every time you open it. Meanwhile, someone who has already documented projects, preferences, processes, and failed experiences opens it to something that feels less like a Q&A box and more like an assistant who’s already been in the office for three months.

The clearer your personal knowledge base, the closer the agent’s first answer is to your real needs.

Others are validating this gap in a different way. YC President Garry Tan’s open-source GBrain has over 16,000 stars on GitHub. Its approach is straightforward: store emails, calendars, meeting notes, tweets, personal notes, chat logs—all as Markdown. Then use Postgres and pgvector for hybrid retrieval, so the AI agent reads relevant background before answering. In a week, he accumulated over 10,000 Markdown files, 3,000+ person profiles, 13 years of calendar data, and 280+ meeting notes. GBrain achieved a 97.6% recall rate in long-term memory benchmarks like LongMemEval. That number doesn’t mean everyone should copy his system, but it proves a practical point: an agent’s capability is largely determined by whether it has a retrievable personal knowledge base behind it.

Hermes and GBrain aren’t the same thing, and I don’t want to force a comparison. GBrain is more of a retrieval system built around personal archives. What makes Hermes more useful for ordinary users is that it integrates working directories, Skills, memory, and conversation search into daily operations. You don’t have to design a grand personal knowledge base first. Just do a little extra sedimentation after each use—write what you’ll repeat next time into the right place—and the system starts to grow.

How to Tell If a Hermes User Is Really Using It

This isn’t sexy. It’s not as immediately rewarding as switching to a more expensive model, nor as fresh as installing a new plugin. Writing AGENTS.md, organizing Skills, saving session snippets, correcting memory—all small, tedious actions. But real working capability has never been sustained by occasional flashes of insight; it relies on the reuse of countless little judgments. The same goes for an assistant.

So now, when I judge whether a Hermes user is genuinely using it, I don’t look at whether they’ve chased the latest model or can name ten slash commands. I first look at whether their project directory has an AGENTS.md, whether they’ve turned repetitive workflows into Skills, whether their memory contains corrected personal preferences, whether they’ll check session_search before tackling an old problem. If none of these exist, they’re still using a temporary hired answerer—smart, but gone when the session ends.

That also explains why some people use Hermes for a while and still feel “it doesn’t seem to understand me better.” That feeling is probably real. The model not being strong enough or lacking features isn’t the root cause. The problem is that effective experience isn’t being preserved. The Q&A ends, and so does the experience. Next time you ask, it starts from scratch again. It won’t suddenly become your partner.

The change you can make today is small. Write the project background you always explain at the beginning into AGENTS.md. Extract the weekly recurring task into a Skill. Save a reusable conversation with /save. Every now and then, use session_search to browse how you solved similar problems before. After doing this, Hermes might not immediately seem more magical. But three months later, you’ll find yourself saying a lot less nonsense.

I prefer to see this as a litmus test. Whether a tool can stay in your workflow long-term doesn’t depend on how many times it impressed you on day one. It depends on whether, after three months, it can still catch the experience you’ve accumulated. If it can’t, it’s a smart temp. If it can, it’s starting to become part of your system.