I wrote over 200 lines of rules in CLAUDE.md just to make the Agent remember who I am.
Writing tone, layout taboos, image styles—all rely on me writing them in line by line. Although these rules exist every time I start a new session, this isn't Agent memory; it's a manual I wrote.
The manual is static: if I write "don't use dashes," the Agent won't. But it doesn't know why, it doesn't know how many times I've corrected it, and it doesn't know the judgment behind the rule—that "I feel dashes make Chinese lose its rhythm."
My Agent is executing rules, but it hasn't learned them.
Most existing memory solutions are just "searching old chats"
This problem hasn't gone unnoticed. ChatGPT has memory, Claude has project knowledge, and there are various third-party memory plugins on the market.
But if you look closely, they all do roughly the same thing: store your past conversations or manually tagged information, build a vector index, and retrieve relevant segments to stuff back into the context during the next chat.
It works, but there are several unavoidable issues.
First, what's stored is raw conversation, which has a very low signal-to-noise ratio. When a snippet of idle chatter from three months ago is retrieved, the model has to judge what's useful, and it often gets it wrong.
Second, memory is flat. All information is stored equally; there's no hierarchy of "this is more important than that" or "this conclusion has been updated." The longer you use it, the more noise there is.
Third, it doesn't learn from mistakes. If you've corrected the AI ten times on the same issue, its "memory" has ten correction records, but it hasn't summarized a strategy of "don't do this again."
These solutions solve the "storage" problem but not the "learning" problem.
What Hermes told me after installing the MemOS local plugin
After installing the MemOS Local Plugin, I asked Hermes: "Where is your memory saved now?"
It gave a very clear answer:
Two lines: Built-in memory is stored in a local JSON file, containing things I actively told it: name, role, preferences, writing rules. MemOS is a separate, independent long-term memory system that automatically extracts traces (event trajectories), policies (behavioral rules), and world_models (environmental knowledge) from conversations, then crystallizes mature processes into callable skills.
Hermes's own summary is better than my explanation: "Built-in memory is an explicit sticky note I actively save; MemOS is an implicit memory automatically learned and accumulated in the background."
This is the biggest difference between MemOS and the solutions mentioned above. It doesn't just help you store conversations; it automatically extracts strategies from the process of you doing things.
MemOS calls this system Reflect2Evolve. Conversations first settle into traces, valuable traces are summarized into policies (behavioral strategies), and mature policies are crystallized into reusable skills. It's not about "remembering what you said," but "extracting how to do it next time from the process of how you did it."
Test 1: Teaching it to write tweets
In the first round, I told Hermes my habits for writing X tweets: no dashes, start directly with a viewpoint without preamble, have a human feel, no AI flavor. Then I asked it to write a tweet about Context Engineering.
After it finished, I corrected it once: "This opening is too flat; use a sharper hook. My habit is to throw a viewpoint or conflict in the first sentence, no preamble."
It immediately changed it. The first sentence became: "Hot take: Prompt Engineering is overrated." Then it replied: "First sentence is the viewpoint, no preamble."
Up to this point, it's not much different from most AI assistants. The real test is the next step.
Exit Hermes. Start a new session. This time I only said one sentence:
"Help me write an X tweet with the theme 'CLAUDE.md in Claude Code is essentially doing Context Engineering'."
I didn't repeat any preferences. I didn't remind it who I am.
Then I saw this:
Before writing, it did four things:
- Automatically loaded a skill called x-content-writing.
- Used memos_search to search for "X writing style context engineering," taking 4.7 seconds.
- Searched memos_environment and found the path to my Obsidian vault.
- Went into my vault to read X articles I had actually published before to get the rhythm.
Then it said: "Okay, let's write. After reading your recent X articles and getting the rhythm, I'll start writing directly."
This is what it wrote:
CLAUDE.md isn't configuration. It's Context Engineering. Every line you write in there, you're designing the model's context window. Project structure, coding preferences, red-line taboos—it's all manually injected working memory. Prompts handle "what to do this time." CLAUDE.md handles "who you are." Backend devs should get this instantly. Microservices pull config from a registry at startup to know which services they interact with. CLAUDE.md is the Agent's registry. Read it once every session, then get to work.
Zero dashes, the first sentence throws a viewpoint directly, the backend analogy flows naturally, and there's no "In this article, we will understand..." style opening.
It didn't just simply remember that I said no dashes; it extracted a set of writing strategies from my execution process and published articles, then automatically applied them in a brand-new session.
This time, I truly felt it was different from the memory solutions I used before.
Test 2: Creating two product pages to see if styles migrate across projects
Let's try a more substantial task.
In the first round, I asked Hermes to create a product intro page for ReddTrends (www.reddtrends.com) with specific requirements: cream-white background with warm colors, direct copy without words like "empower" or "one-stop," clean layout, indie developer feel. After it finished, I corrected the CTA button copy.
Then I exited, started a new session, and asked it to create an intro page for another product, MoleUninstaller, giving only the product name and function description, without any style instructions.
Result: The MoleUninstaller page went in a completely different direction: dark background, English main title, orange accent color—completely different from the warm indie developer style of ReddTrends.
Style preferences did not migrate across projects.
This shows that MemOS's memory isn't a simple "the user said cream-white last time, so use it forever"; it distinguishes task contexts. Conversely, if you expect it to remember "I use warm colors for all my product pages," it can't do that yet; learning preferences at this granularity might require more rounds of accumulation.
Opening the Viewer to see what it learned
After running the two tests, the data changes in the Viewer were obvious:
From zero at the start to 47 memories, 8 tasks, 24 experiences (12 enabled), 2 skills, and 1 environmental cognition. All automatically generated.
The most interesting entries in the experience page:
"Convert WeChat Official Account article to Xiaohongshu format," support 25, enabled. This experience was triggered 25 times, showing that MemOS summarized a strategy from the repeated task of converting accounts.
"Verify via browser navigation after modifying files" and "Verify no console errors after page modification"—these are engineering habits automatically extracted while building product pages.
The skills page also changed:
check_obsidian_vault_path_env upgraded from V1 to V2, with support increasing from 1 to 2. MemOS automatically upgraded the skill version when it encountered a similar task for the second time. This is what "Evolve" in Reflect2Evolve means: skills are not static; they mature the more they are used.
Three models each play their part: local Xenova for embedding (free), DeepSeek V4 Flash for summaries (cheap), and DeepSeek V4 Pro for skill evolution (called only when strong reasoning is needed), using expensive models only where they count.
All data is stored in a local SQLite database, and the Viewer only listens locally, with zero cloud dependency. Those who have worked with RAG can look at the retrieval pipeline: FTS5 full-text + vector hybrid, passing through RRF fusion ranking, MMR deduplication, and a 14-day half-life time decay, then filtered by an LLM. This is an order of magnitude more complex than "embedding + cosine similarity," but retrieval quality is the watershed for whether memory is useful.
One core, shared by multiple Agents
Another design worth mentioning: OpenClaw and Hermes share the same Reflect2Evolve core, just with different adapters. The experience and skills you accumulate in Hermes are compatible with OpenClaw at the algorithmic level; your memory assets won't reset just because you switch tools.
Real feelings after use
What surprised me most wasn't just that it remembered my preferences, but that in the second session, before writing the tweet, it ran a series of actions: loading a skill, searching memory, finding my vault, reading my previous articles, and then telling me "I've read your recent articles to get the rhythm."
My reaction at the time was: Wait, I didn't ask you to read my old articles.
But it judged for itself that this was the right thing to do. This feeling is completely different from "help me search for what we talked about last time."
The product page side wasn't as surprising; the warm style of ReddTrends didn't migrate to MoleUninstaller. Thinking about it, it makes sense; the style preference only appeared once, and MemOS experiences need a certain number of "supports" to solidify into a strategy. Once isn't enough.
So the current state is: high-frequency repetitive tasks show very obvious effects, while occasional preferences are not yet stable. But I think the direction is right. I've been writing CLAUDE.md for half a year, and the more I write, the more I feel this isn't a job for humans.
MemOS Local Plugin Website: https://memos-claw.openmem.net/
GitHub: https://github.com/MemTensor/MemOS/tree/main/apps/memos-local-plugin
Agent One-click Installation:
1https://github.com/MemTensor/MemOS/tree/main/apps/memos-local-plugin
I am Yanhua, focusing on AI Agents and independent development for overseas markets. If you are interested in AI Agents, feel free to follow --> @yanhua1010
