MemOS Turns Your AI Agent Into One That Actually Remembers: A Hands-On Look

I was a committed Codex user until last month. Then GLM-5.2, Kimi K3, and Qwen-3.8-Max started climbing the leaderboards, and the price difference between Pro and Plus was hard to justify when the open-weight models were holding their own. So I went back to Hermes. I missed the client interface.

But Codex’s memory system had spoiled me. It treats memory as a machine-generated byproduct — something the system produces, not something you actively manage. Hermes takes the opposite position: memory is an active asset the agent maintains itself. The catch is the storage ceiling. Two files, both tiny. MEMORY.md holds the agent’s working notes with a 2,200-character cap. USER.md holds the user profile with a 1,375-character cap.

That is not enough for anyone who actually uses an agent across real projects.

I found MemOS, an open-source memory hosting platform that layers a full memory operating system on top of existing agents. You keep Hermes. You gain a structured, long-horizon memory layer with a visual dashboard, automated skill generation, and team sharing capabilities.

This is not a sponsored post. I installed it, used it for a few days with real projects, and have things to say about what works and what does not.

Why Memory Is the Most Underrated Agent Concept

Agents are genuinely capable now. But the time you spend working with one rarely compounds. Today you tell it where your project lives, how you want materials organized, which sources are reliable, and what format the output should use. Start a new session and you begin again. Previous mistakes go unremembered. Validated workflows do not transfer.

Each agent handles memory differently:

• Claude Code stores project history and work rules in Markdown files, loaded at session start.
• ChatGPT builds a cross-session user profile maintained by the platform, not the user.
• OpenClaw maintains an auditable knowledge base across MEMORY.md, daily notes, and an index.
• Hermes caps memory at two small files and relies on an external Provider for anything beyond that.

The underlying problem is that benchmark conditions across memory products are all over the place. Different prompts, different judge models, different dataset versions, different definitions of what a “score” even means. It is the wild west of AI evaluations, circa 2023.

MemOS recently open-sourced OmniMemEval, a framework that puts 14 memory products through the same pipeline with unified benchmarks, model configuration, prompts, and judging. MemOS’s own numbers are competitive. But numbers only matter so much. What matters is whether the memory system actually changes how your agent behaves across sessions.

What MemOS Actually Does

MemOS describes itself as a memory operating system. The product has two layers:

The memory panel — a local web interface running on your machine that visualizes every memory store the agent has accumulated. Think of it as a structured view of everything your agent has learned about your projects, your preferences, your working patterns, and your team’s conventions.

The memory layer — a persistent, retrievable memory backend that sits alongside your agent’s native memory, adding longer-horizon storage and better organizational structure. Memories are tagged, retrievable by semantic search, and organized into tiers that reflect how confirmed and stable they are.

Installation is straightforward on systems with Hermes or OpenClaw already configured. The installer detects your existing setup and deploys the plugin to the right directory, generates a config file, and starts the Viewer. The Viewer runs at http://127.0.0.1:18800 by default and requires a password on first launch.

After setup, MemOS can import your agent’s native memory files directly, so nothing is lost in transition. The panel then gives you a structured view of what was previously just raw text in MEMORY.md.

The Self-Evolving Memory Feature

The feature that stood out most is called Self-Evolving Memory. Beyond basic summarization, it can automatically distill task patterns, validated approaches, environment awareness, and skills from your ongoing work. Over time, these distillations can crystallize into reusable Skills that the agent can call on in new contexts without being explicitly taught.

To enable it, you configure a capable model as the distillation engine — the documentation supports several options, and configuration is done through the Viewer settings. The system then runs background synthesis on completed tasks, extracting what changed from session to session, what approaches succeeded, and what environment conditions kept recurring.

This is the part that separates MemOS from just being a fancy notepad. The system is designed to keep memory growing upward, not just storing sideways.

User Memory Benchmarks: What the Numbers Actually Mean

OmniMemEval tested 14 commercial memory products across five benchmark datasets.

MemOS performed competitively on the headline metrics, but the more interesting data point is Context Token efficiency — how many tokens are injected into the model context per query to achieve those scores.

A memory product that achieves high accuracy by stuffing massive context windows into every prompt is not impressive. It is expensive, slow, and increases hallucination risk.

MemOS’s memory retrieval and routing layer appears to prioritize relevant, concise context injection over breadth. In practical terms: lower token counts per query, lower API costs, faster responses.

The specific scores on LoCoMo and LongMemEval put MemOS at the top of the leaderboard in those categories, according to the official OmniMemEval results. Whether you trust those benchmarks depends on how much you trust the evaluation framework — which is a fair question — but the efficiency argument is directionally sound regardless.

Agent Memory: Making Coding Agents Actually Learn

The Agent Memory benchmarks use AgentBench across five task domains:

Domain	Capability
BrowseComp-Plus	Information Retrieval
OmniMath	Mathematical Reasoning
SWE-Bench	Software Engineering
LiveCodeBench	Code Implementation
GDPVal	Knowledge Work

OpenClaw results across those five domains were strong — MemOS took first place in four of the five categories (BrowseComp-Plus, OmniMath, SWE-Bench, GDPVal). Average task completion climbed from 36.63% to 50.87%. That kind of jump is not from tuning a prompt. It is the memory system changing what the agent is actually capable of across sessions.

The Hermes results are even more striking:

Method	OmniMath	SWE-Bench
Baseline	62.00	37.18
Mem0	64.33	34.62
Hindsight	64.00	28.20
MemOS	72.67	52.56

SWE-Bench on Hermes jumped from 37.18% to 52.56% — more than 15 percentage points. That means the agent’s ability to fix bugs improved substantially because long-horizon memory gives it access to what went wrong before.

Team Shared Memory

MemOS includes a team memory feature that allows shared memory stores across team members. Each person maintains their own working memory, but selected stores can be shared at the team level — onboarding context, project conventions, established decisions. I have not fully tested this layer yet, but the architecture supports it.

What Still Feels Unfinished

The installer is solid. The Viewer is functional. But the self-evolving memory feature requires a capable model to drive the distillation process, which adds cost and latency you need to be comfortable with. If you are running a tight budget on API calls, the automatic distillation loop is something to evaluate carefully before enabling broadly.

The OmniMemEval benchmarks are MemOS’s own benchmarks, which creates an obvious conflict of interest. Treat the leaderboard positions as one data point, not a final verdict.

The team memory feature needs more hands-on testing before I can say how well it handles conflicts, staleness, and access control in practice.

The Bottom Line

I have not exhaustively tested every feature. But after running MemOS with real projects for a few days, two things are clear.

First, it solves the actual problem. If you have been frustrated that your agent does not build on what you have already taught it, MemOS addresses that directly. The memory layer accumulates, the Viewer makes it legible, and the self-evolving distillation means the system keeps improving without constant manual curation.

Second, the experience feels genuinely different from just keeping a larger MEMORY.md file. The organizational structure, the retrieval efficiency, and the distillation pipeline add up to something more than the sum of their parts.

If you run Hermes or OpenClaw as your primary agent and you work across meaningful projects, MemOS is worth a weekend of real testing. Do not just install it, ask a few questions, and expect the value to be obvious on day one. Let some work accumulate, let the distillation run, and then look at what the Viewer shows you. That is when the system starts making sense.

You can find MemOS on GitHub. It requires Python 3.11 or 3.12, and the install script handles most of the setup automatically on systems with Hermes or OpenClaw already configured.