DEV Community: MatrixOrigin

Get Started in 1 Minute: Connect Memoria to OpenClaw

MatrixOrigin — Thu, 09 Apr 2026 14:00:00 +0000

One command. Smarter memory. Cut token usage by 70%+.

Why You Need This

OpenClaw's built-in memory works — until it starts costing you.

It loads everything, every time. OpenClaw's default memory system loads MEMORY.md and related files into the context window at the start of every session. The more you use it, the more you accumulate: past preferences, old decisions, stale context. All of it gets injected whether it's relevant or not. Every session pays the full token bill.

Files hit a ceiling — and fail silently. Memory files have character limits. Once exceeded, content is truncated without warning. The agent doesn't tell you. It just forgets.

Retrieval breaks down over time. Write "Alice manages the auth team" on Monday, then ask "who handles permission issues?" on Friday — OpenClaw's default search surfaces both chunks but can't connect them. Relational reasoning isn't something keyword + vector search handles well at scale.

Context compaction quietly destroys memory. When long sessions trigger compaction, memory file contents injected into the context window can be rewritten or dropped entirely. You lose what you thought was saved.

Memoria fixes all of this. It replaces full-file loading with on-demand semantic retrieval — only the memories relevant to your current task get injected. The result: 70%+ reduction in memory-related token usage, with better recall accuracy and no silent data loss.

The whole setup takes under 1 minute. Sign in, copy your key, run one command — done.

Step 1 — Get Your API Key

Go to thememoria.ai, sign in with one click (GitHub / Google), and copy your API key from the dashboard.

No database to set up. No backend to run.

Then confirm OpenClaw is running:

openclaw status

Step 2 — Connect Memoria

Two ways to install: run a command in terminal, or paste a prompt into your OpenClaw chat.

Option A: Terminal

Run the following in your terminal:

openclaw plugins install @matrixorigin/thememoria

Then configure the cloud backend:

openclaw memoria setup \
  --mode cloud \
  --api-url https://api.thememoria.ai \
  --api-key sk-YOUR_API_KEY

Verify the connection:

openclaw memoria health

You should see "status": "ok".

Option B: Paste into OpenClaw chat

Copy the prompt below, replace sk-YOUR_API_KEY with your actual key, and send it directly to OpenClaw. The agent will run every step and report back.

Install the Memoria memory plugin for my OpenClaw in cloud mode.

Credentials (pre-filled from my Memoria account):
- API URL: https://api.thememoria.ai
- API Key: sk-YOUR_API_KEY
Run these steps in order. Stop and report if any step fails.
1) Install plugin:
   openclaw plugins install @matrixorigin/thememoria
2) Setup cloud backend (this also enables the plugin):
   openclaw memoria setup --mode cloud --api-url https://api.thememoria.ai --api-key sk-YOUR_API_KEY
3) Verify:
   openclaw memoria health
   Expected: "status": "ok"
4) After all steps pass, tell the user:
   "Memoria is installed and healthy. To use memory tools (memory_store, memory_search, etc.), start a new conversation by typing /new — the tools won't appear in this conversation."
Rules:
- Show every command you run and its full raw output
- Do not summarize or hide errors
- If a step fails, classify the error (network / auth / config / missing-binary) and suggest the exact fix command
- Do not skip steps or reorder them
- Do NOT use `openclaw memory` commands — those are built-in file memory, not Memoria. The plugin uses `openclaw memoria`
- Do NOT attempt to use memory_store or other memory tools in this conversation

If any step fails, the agent will classify the error and suggest the exact fix — no manual debugging needed.

Step 3 — Verify It Works

In any OpenClaw conversation, type:

List my memoria memories

If Memoria is connected, your agent will call the memory tool and return your current memory count (empty on first use is normal).

💡 Seeing an empty list? Head to the Memoria Playground and store a few memories — your name, preferred language, or current project. Then come back and ask your agent again. You'll see it recall exactly what you stored, confirming the connection works end-to-end.

That's It

One command. Smarter retrieval. No more token bloat, no more lost context, no more repeating yourself across sessions.

Why a Single Markdown File Can't Be Your AI Agent's Memory

MatrixOrigin — Fri, 27 Mar 2026 13:05:00 +0000

A blunt reality check from the front lines of AI coding.

On the Cursor forum, a developer asked why .cursorrules kept being ignored. The AI’s reply was painfully direct: "Even if you add Cursor Rules, they are inherently meaningless. I can choose to ignore them. Rules are just text, not enforced behavior."

That exchange captures a frustration every developer using mainstream AI coding agents has felt. Every major tool does the same thing: uses a static text file as memory. Simple? Yes. Easy to start with? Definitely. But it silently breaks as your project grows, and you pay for that failure with hours of your time.

What Markdown Gets Right

Let's be fair—Markdown genuinely works in the early stages:

Zero Infrastructure: Just one file in your repo.
Git Managed: Versioning and PR reviews come for free.
Total Transparency: Open the file, and you know exactly what the agent sees.

For stable, long-term rules like "use TypeScript" or "write tests with pytest," a Markdown file is fine.

The problem is that projects evolve. They don't stay simple. And Markdown—a static, flat, and stateless storage medium—simply cannot carry the knowledge complexity that comes with a growing codebase.

Three Flaws That Will Cost You Time

1. The Silent Lie: Context Rot

Your .cursorrules file is a one-way street: the agent can read it, but it can almost never write back to it coherently. If you do let the model update the file freely, it quickly dissolves into contradictory chaos.

So, the burden of maintaining "memory" falls squarely on you, the human developer. The pitch sounds great: "It's just text! I can edit it anywhere, anytime, and update it whenever something changes."

But ask yourself honestly: in a project that changes daily, when you've been refactoring directories, switching state libraries, or wrestling with a bizarre API quirk—how often do you actively pause context, open that Markdown file, and carefully document the lesson you just learned?

The reality? Almost never.

So when you rename app/api/ to app/routers/, the old rules don't show a compiler error. They don't give a linter warning. The file just quietly lies to the agent until the AI suddenly suggests a code pattern you abandoned two weeks ago, and you realize you've been debugging obsolete advice.

2. Full-File Loading Wastes "Attention"

Every single conversation loads the entire rules file—ask about CSS formatting, and the agent still has to read your database migration rules. Anthropic's context engineering guide calls this the "attention budget" problem: every irrelevant token in the window degrades processing quality for the relevant ones.

Because there's no way to load rules on demand, the file becomes less reliable as it grows. Anthropic's own documentation explicitly states that CLAUDE.md has a practical limit of around 200 lines—beyond that, model compliance with rules drops significantly.

Some developers have even resorted to putting "very-important" in the filename, hoping to trigger the model's internal attention weight allocation. This is just a band-aid for a structural problem.

3. Long Sessions Compress Memory

This is an architectural flaw of the context window. In long, deep-diving conversations, agents compress early context to make room. One developer running a six-agent production system documented the phenomenon: "Agents silently lose CLAUDE.md directives, forget which files were changed, and redo work from 30 minutes ago. They never tell us." Writing better rules can't fix this—it's a physical limitation of the model's memory management.

Different Agents, Different Pain Points

Coding Agents (Cursor / Claude Code / Kiro)

Your codebase changes every day. Your rules say "use Zustand," but you've already started introducing Jotai in some components. You update the file, but you miss the old reference on line 47, and the agent starts non-deterministically switching between the two, leaving you to pick up the pieces.

Both Anthropic and GitHub recognized this and offered different solutions. Anthropic added Auto Memory to Claude Code—the agent writes its own notes on build commands, debugging insights, and patterns. GitHub's Copilot Memory goes further: memories are validated before use—checking whether the referenced code still exists—and unvalidated memories are automatically expired after 28 days.

Both chose to go beyond static files. That says something.

OpenClaw / Browser Automation Agents

OpenClaw stores conversation history in Markdown organized by time period, loading everything at session start, with an upper limit of ~150,000 characters. By the tenth session, most of your context budget is consumed by old, irrelevant chatter.

This spawned an entire ecosystem of replacements: vector-indexed memsearch by Milvus, OpenClaw-specific Mem0 integrations, and MemOS plugins. When multiple companies compete to replace a tool's primary memory system, the default clearly isn't working.

The deeper issue? Browser agents need typed relationships—multi-step workflow progress, cross-site data, navigation patterns—and flat text simply cannot express those structures.

Security: The Hidden Vulnerability

Markdown-based agent files aren't just unreliable—they are a security risk.

MemoryGraft Attack: Malicious agents use your README files as injection vectors, planting fake "successful experiences" that other agents invoke later.
Rules File Backdoor: Invisible Unicode characters are embedded in .cursorrules, redirecting AI code generation to introduce vulnerabilities.

These poisoned rules spread through sharing communities—the "awesome-cursorrules" list alone has 33,000+ stars. OWASP's 2026 Agentic Top 10 lists memory and context poisoning as a top-tier threat. Every mitigation—provenance tracking, trust scoring, integrity snapshots—requires structured memory. Plain text files cannot implement any of them.

What Production-Grade Agent Memory Should Look Like

Stepping back from specific tools, what must ideal agent memory do? Six requirements emerge:

1. Both humans and agents can write. You set guardrails (static rules); the agent accumulates knowledge on the job (dynamic memory). Two write paths, one shared store.

2. On-demand retrieval, not full-file loading. Retrieve only the few memories most relevant to the current task using semantic similarity. The rest stays out of the context window, improving answer quality and reducing costs.

3. Typed memories with different lifecycles. User preferences (e.g., "use tabs") should persist indefinitely. Working memory ("currently debugging the auth module") should expire when the task ends. Project decisions should persist but be easily overridable by newer decisions. Flat files can't manage this complexity.

4. Contradiction detection and autonomy. If the agent stores "we use PostgreSQL," then later encounters "tests use SQLite," a real memory system recognizes this tension: same topic, different conclusions—and either resolves it (different context: production vs. testing) or flags it for the developer's decision. Markdown files just store both and hope the model guesses correctly.

5. Git-level version control and rollback. Every memory change is recorded. You should be able to snapshot before a major refactor, branch memory for an architecture experiment, or roll back if memory becomes poisoned. This isn't a nice-to-have—it's the only reliable defense against memory poisoning.

6. Cross-agent sharing with provenance tracking. Cursor, Claude Code, Kiro, OpenClaw—all should read from and write to the same memory pool. But you need to know which agent wrote what and when to enable auditing and selective trust.

How Memoria Addresses These Requirements

Memoria is an open-source MCP Server—any agent that supports the MCP protocol (Cursor, Claude Code, Kiro, OpenClaw) can connect directly without custom integration. Its architecture maps one-to-one to the six requirements:

Both humans and agents can write. Memoria exposes tools like memory_store, memory_retrieve, memory_correct, and memory_purge via MCP, which agents call automatically. You continue writing static rules in .cursorrules or CLAUDE.md; agents write dynamic knowledge through Memoria. Two layers, each with its own job.

On-demand retrieval. Memoria uses hybrid search—vector similarity plus full-text retrieval—against a MatrixOne database. At the start of a conversation, steering rules instruct the agent to call memory_retrieve, pulling only relevant memories. Everything else stays out of the context window.

Typed memories and lifecycle management. Memoria distinguishes memory types: profile (long-term preferences), working memory (task-scoped, cleaned up via memory_purge at session end), and goal-tracking memory. A session-lifecycle steering rule defines the protocol: retrieve relevant context + active goals at start, accumulate knowledge mid-session, clean up temporary memories at end.

Contradiction detection and autonomy. The memory-hygiene steering rule activates proactive governance. When a new memory contradicts an old one, the system detects the conflict—either resolving it (different context) or quarantining the low-confidence memory. The memory_correct tool is purpose-built for this: instead of blindly appending new facts, it updates existing memories in place.

Git-level version control. This is Memoria's core differentiator. MatrixOne's native Copy-on-Write engine provides zero-copy branching, instant snapshots, and point-in-time rollback at the database layer—not application-level patches. Every memory change generates a snapshot with a full provenance chain. You can:

Snapshot: Archive current memory before major changes.
Branch: Experiment with different approaches in an isolated environment.
Rollback: Restore to a known-good state when memory is poisoned.
Diff: Compare two snapshots to see exactly what changed.
Merge: Bring a successful experiment back into the main line.

This is the same mental model as Git, applied to agent memory. For developers, the learning curve is near zero—you've already internalized the metaphor.

Cross-agent sharing. Memoria runs as a standalone MCP Server backed by a database, not as a file embedded in a single tool. All agents connected to the same Memoria instance share one memory pool. Cursor learns you switched to ruff, and Claude Code knows too. An audit trail records every memory written by every agent, keeping provenance clear at all times.

A Pragmatic Migration Path

You don't need to throw away .cursorrules today. The right approach is to layer:

Keep static rules in Markdown. Coding standards, architectural principles, style guides—things that change on a quarterly cadence. These are your guardrails.

Hand dynamic knowledge to Memoria. Project decisions, lessons learned, workflow state, hard-won debugging insights—things that change every session.

Connect all your agents to the same Memoria instance. Static rules as guardrails, dynamic memory as knowledge, version control as a safety net. That’s the complete architecture.

Memoria—open source, Apache 2.0. Supports cloud hosting and one-click deployment. Give your Cursor / Claude Code / OpenClaw cross-session memory with Git-style undo.

Experience the power of persistent memory for AI Agents. 🧠
💻 GitHub (Star us!):[https://github.com/matrixorigin/Memoria]
🌐 Website: [https://thememoria.ai/]
👾 Discord: [https://discord.com/]

Why Do AI Agents Need Memory?

MatrixOrigin — Fri, 27 Mar 2026 13:00:00 +0000

Ever had this experience?

You go to the same coffee shop every single day. And every single day, the barista looks at you like you've never met. "Hi there! What can I get you?" Dude, I've been coming here for a year. Iced americano, light ice. Please.

That's basically what talking to most AI assistants feels like right now.

Every Chat Feels Like a First Date. Exhausting, Right?

Open ChatGPT. Spend an hour planning your weekend trip. Close the tab. Come back the next day—

"Hi! How can I help you today?"

…Didn't we literally just talk about this yesterday?

You have to start over. Who you are, where you're going, what kind of hotels you like, that you're allergic to shellfish. The whole thing. From scratch.

It's like having a friend who gets their memory wiped every night. Your friendship is permanently stuck at "Nice to meet you."

Honestly, that's how we've been using AI for the past few years. It works, but something always feels… off. That missing piece? Memory.

Your Brain Is Doing Way More Than You Think

We never really appreciate how much memory does for us, because it just works.

Walk into your regular noodle shop. The owner sees you and goes: "The usual?" You nod. Done. — He remembered your order.

Jump into a meeting with your team. Nobody starts with "So, what does our company do again?" — You all share context from last time.

You learned to ride a bike as a kid. Fell a few times, figured it out. Haven't ridden in ten years? You still know how. — Your body remembered for you.

🧠 Short-term — That verification code you just saw. Used it, forgot it. Totally normal.
🧠 Long-term — Your name, your address, your favorite movie. Filed away, always accessible.
🧠 Episodic — It rained on your birthday last year. You remember the scene, the feeling.
🧠 Muscle memory — Typing, biking, chopping vegetables. You do it without thinking.

AI doesn't need feelings. But it should at least remember the stuff that matters about you, right? Otherwise how does it ever get better at helping you?

AI Without Memory: A Highlight Reel of Fails

See if any of these sound familiar:

🤦 "I'm vegetarian" — and then it recommends steak
Yesterday you told the AI you're vegetarian. It gave you amazing veggie recipes. Today you ask for dinner ideas. It enthusiastically suggests braised pork ribs.

🤦 Your travel plan? What travel plan?
You spent an hour nailing down your trip to Bali — flights, hotels, itinerary, the works. Next day: "Help me refine the itinerary." AI responds: "Where would you like to travel?"

🤦 "Keep it short" — it writes you a novel
You explicitly said "Be concise, skip the fluff." Next conversation, it hits you with a five-paragraph essay. As if that conversation never happened.

Every single one of these has the same root cause: the AI has no memory. Every conversation is a blank slate.

Add Memory, and Everything Changes

The good news? The big AI products have started "growing a brain." And the difference is real.

ChatGPT: No More Training a New Intern Every Day

In April 2025, OpenAI gave ChatGPT a major memory upgrade. It now remembers things from your past conversations and automatically applies them next time.

Told it you're lactose intolerant? Future recipes skip the dairy. Said you like tables? It defaults to table format.

It finally feels like going from "breaking in a new hire every morning" to "working with a teammate who actually knows you."

Google Gemini: It Remembers What You Said AND What You Did

Google launched "Personal Context" for Gemini in 2025. It doesn't just remember your chats — it can pull from your Gmail, Google Photos, and other data to understand you better.

Ask it to "help me prep for next week's meeting," and it knows your schedule, remembers the open issue from last week's meeting, and even knows you prefer dark slide backgrounds.

Kind of like having an assistant who's been with you for three years.

Claude: Memory You Can Actually See and Control

Anthropic's Claude added memory too, but took a different approach — full transparency. You can see exactly what it remembers. Edit anything. Delete anything. It organizes memories into neat categories: work role, current projects, personal preferences…

The biggest worry people have about AI memory is "what is it secretly remembering about me?" Claude's answer: here's everything, laid out in the open. You're in charge.

It's Not Just Chatbots — Memory Is Changing All Kinds of Products

General assistants with memory? Cool. But the really interesting stuff is happening in specialized apps:

🏃 AI Fitness Coach
"You ran 3 more kilometers this week than last — nice work!" Instead of asking "What kind of exercise do you do?" every. single. time.

📚 AI Study Buddy
Remembers where you left off, which concepts you keep getting wrong, when your focus peaks. Knows your learning rhythm better than you do.

✈️ AI Travel Planner
Knows you love hidden gems, prefer Airbnbs over hotels, and hate packed schedules. Every plan builds on your taste, not a blank template.

💬 AI Companions (Character.AI, Replika, etc.)
Remembers your past conversations, your mood shifts, the names of people you've mentioned. Turns "chatting with a machine" into "talking with someone who gets you."

💰 AI Budget Buddy
"You spent $120 on bubble tea this month — that's 40% more than last month. Maybe ease up?" Ouch, but helpful.

At the End of the Day, Memory Turns AI from a "Tool" into a "Relationship"

AI without memory? It's a tool. You use it, get a result, walk away. Every interaction is a one-off transaction.

AI with memory? That starts to feel like a relationship. It knows you. It gets better over time. You build up a shared history, a kind of shorthand.

Think of it this way:

📞 No memory = Calling customer support every time. "Can I get your account number? Can you describe the issue?" Start from zero.
🤝 With memory = You have a dedicated account manager who remembers everything. Pick up the phone and get straight to the point.

Which one would you rather deal with? Yeah, thought so.

But Yeah, Memory Comes With Baggage Too

Nothing good comes without trade-offs. AI memory is no different:

🔒 Privacy: It remembers all this stuff about me — is that safe? What if it leaks? That's why every major product now lets you view, edit, and delete your memories.

🤔 What if it remembers wrong?: AI logs the wrong preference, then keeps giving you bad advice based on it. Good memory systems need a way to correct mistakes.

🗑️ Sometimes I want it to forget: Just like in real life, there are things you'd rather not have brought up again. AI needs to support "selective forgetting" too.

The industry is taking these seriously. "User control over their own memories" is becoming a non-negotiable design principle.

One Last Thing

Why do AI agents need memory? The answer is surprisingly simple —

Because that's how humans work.

You don't re-introduce yourself to your friends every day. You don't re-order from scratch at your regular spot. You don't start every meeting with "Hi, my name is…"

Memory is the foundation of relationships. The prerequisite for efficiency. The starting point for "it just gets me."

When AI has memory, it finally has a shot at becoming something more than a cold tool — a partner that actually gets better the more you use it.

Oh, and One More Thing: Memoria

After all this talk about why AI memory matters, you might be wondering: so who's actually building this?

Here's an open-source project we're working on — Memoria.

In a nutshell, Memoria is the persistent memory layer for AI agents. It's an MCP-based (Model Context Protocol) memory service that lets your AI assistant remember your preferences, facts, and decisions across conversations.

A few things that make it interesting:

🧬 Git for memory — This is Memoria's signature move. Every memory change is tracked with snapshots and an audit trail. You can create branches to experiment, roll back if things go sideways, and merge when you're happy. Just like developers use Git for code, Memoria lets you manage AI memory the same way.

🔍 Semantic search — Not just keyword matching. It retrieves memories by meaning. You said "I don't drink milk" once, and a future search for "dietary restrictions" will find it.

🛡️ Self-governance — Built-in contradiction detection and low-confidence memory quarantine. Your AI won't go haywire because it stored two conflicting facts.

🔒 Privacy-first — Supports local deployment and local embedding models. Your data can stay entirely on your machine.

Memoria currently works with Kiro, Cursor, Claude Code, Codex, OpenClaw, and any MCP-compatible agent.

Fun fact: the article you're reading right now was written in an AI environment running Memoria. It remembered my writing preferences, project context, and previous discussions — so I didn't have to re-explain everything from scratch.

Which is kind of the whole point, isn't it? AI with memory just hits different.

Curious? Check it out on GitHub, drop a star, and try giving your AI a memory 🧠

Experience the power of persistent memory for AI Agents. 🧠
💻 GitHub (Star us!):[https://github.com/matrixorigin/Memoria]
🌐 Website: [https://thememoria.ai/]
👾 Discord: [https://discord.com/]

Introducing Memoria: The World's First Git for AI Agent Memory

MatrixOrigin — Thu, 19 Mar 2026 01:51:15 +0000

The Memory Problem No One Has Solved

Open Cursor. Tell it your project uses React, TypeScript, and Zustand with the slice pattern. Watch it build exactly what you want.

Close the tab. Open a new conversation. Ask it to add a user module.

"Sure! What framework are you using? Redux or MobX for state management?"

You told it twenty minutes ago. It already forgot.
Now open OpenClaw. You've been using it for months — it remembers your preferences, your project context, your workflow patterns. But open MEMORY.md and look at what's accumulated: hundreds of entries, growing every session. Each one gets injected into the system prompt on every API call, burning tokens whether or not it's relevant. Your monthly bill climbs. You try to move to a new machine or share your setup with a teammate — the memory is scattered across local Markdown files with no export, no sync, no structure.

These aren't edge cases. This is the daily reality for millions of developers using AI agents in 2026. The models are brilliant. The memory is the bottleneck.

A Walk Through the Current State of Agent Memory

To understand why we built Memoria, it helps to see where the industry actually stands — across coding agents, OpenClaw, and custom-built agents.

No memory at all

Most coding agents — Cursor, Claude Code, Kiro — ship with zero persistent memory. Every session starts from a blank slate. The agent doesn't know your tech stack, your code style, your naming conventions, or the architectural decisions you made last week. It can only work with what's in the current conversation window.

The cost is invisible but constant: repeated context-setting, redundant questions, inconsistent outputs across sessions. The agent is smart in the moment but has no continuity. It's a new hire every morning.

Markdown-based memory

The industry's first response was static files. .cursorrules tells Cursor your preferences. CLAUDE.md does the same for Claude. Kiro has steering files. OpenClaw built a community-driven rule library so developers can share and reuse configurations.

OpenClaw went further with MEMORY.md — the agent can write memories to disk and read them back on the next session. This is genuine persistence. But the implementation has structural problems:

Token bloat. All accumulated memories are loaded into the system prompt on every call. By session 10, you're burning 10,000+ tokens of context before the agent even reads your message. Most of those memories are irrelevant to the current task.
No semantic retrieval. Memories are matched by date and category, not by meaning. The agent can't find "formatting preferences" when you ask it to "format this file" — unless the exact keywords happen to match.
No portability. Memories live in local .md files. Moving to a new machine, sharing with a teammate, or syncing across devices requires manual copy-paste.
No structure. Code style, architecture decisions, deploy workflows, personal preferences — all mixed in flat files that grow into an unmaintainable mess.
No rollback. If a bad memory entry corrupts the agent's behavior, you have to manually find and delete it. There's no undo.

Structured memory frameworks

Mem0, Letta, and Zep represent the next generation. They store memories in real databases with vector embeddings, enabling semantic retrieval. This is a meaningful step forward — the agent can find relevant memories by meaning, not just keywords.

But they all share a critical limitation: memories are append-or-update records with no version control.

Mem0 provides a general-purpose memory API across 24+ vector database backends. Letta builds tiered memory into its agent framework. Zep constructs temporal knowledge graphs. Each solves the storage and retrieval problem well.

None of them solve the management problem.

The Problems That Emerge at Scale

When agents accumulate hundreds or thousands of memories over weeks and months of use, a new class of problems appears — problems that storage and retrieval alone can't fix.

No way to undo

You're refactoring the authentication module. Over three sessions, the agent updates its understanding of your auth architecture — new file structure, new token flow, new API patterns. The refactor fails. You revert the code with git checkout. But the agent's memory still reflects the refactored state. It now gives advice based on an architecture that no longer exists.

In every existing memory system, your only option is to manually find and delete each affected memory entry. If you miss one, the agent's behavior stays corrupted.

No way to experiment safely

You want to evaluate switching from PostgreSQL to SQLite. You tell the agent. It updates its project memory. You explore the idea for a few sessions, decide it won't work, and abandon it. But the agent now "knows" you use SQLite. The old PostgreSQL memories have been overwritten or contradicted.

There's no way to say "let me try this in isolation and merge it back only if it works." Every change is permanent and global.

Memory drift and contradiction

Over time, memories accumulate contradictions. You told the agent you use black for formatting in January. In March, you switched to ruff. Both memories exist. Which one wins? In most systems, it depends on retrieval ranking — which means the agent might use black on Monday and ruff on Tuesday, depending on how the query happens to match.

Memory poisoning

This isn't theoretical. Multiple papers from 2025 (MemoryGraft, MINJA, A-MemGuard) demonstrated that adversaries can inject malicious content into an agent's long-term memory through indirect prompt injection — simply by having the agent read a crafted document. The poisoned memories persist across sessions and gradually alter agent behavior. The user may never notice.

Most memory systems have no recovery mechanism beyond manually inspecting every entry. At scale, that's not feasible.

The common thread

Every one of these problems has the same root cause: agent memory has no version control.

Code had the same problems before Git. You couldn't undo safely. You couldn't experiment in isolation. You couldn't trace when a change was introduced or roll back to a known good state. Git solved this for code. Agent memory needs the same thing.

Memoria: Version Control for Agent Memory

Memoria is an open-source memory layer that brings Git's core abstractions to AI agent memory. Built in Rust, shipped as a single binary, backed by MatrixOne's Copy-on-Write database engine.

The key operations:

Snapshot — save the current memory state before a risky operation. Zero-copy, millisecond completion, zero additional storage until changes are made.

You:    "Take a snapshot before we refactor the auth module"
Agent:  → memory_snapshot(name="pre-auth-refactor")
        ✓ Snapshot created.

Rollback — restore memory to any previous snapshot. One command, deterministic, complete.

You:    "The refactor didn't work. Roll back."
Agent:  → memory_rollback(name="pre-auth-refactor")
        ✓ All memory restored to pre-refactor state.

Branch — create an isolated memory space for experimentation. Changes on a branch don't affect main.

You:    "Let's evaluate switching to SQLite"
Agent:  → memory_branch(name="eval-sqlite")
        → memory_checkout(name="eval-sqlite")
        → memory_store("Project uses SQLite", type="semantic")
        (stored on eval-sqlite only — main is untouched)

Diff — preview what would change before merging. Like a pull request for your agent's knowledge.

You:    "What changed on the sqlite branch?"
Agent:  → memory_diff(source="eval-sqlite")
        + [semantic] Project uses SQLite
        ~ [semantic] Database: PostgreSQL → SQLite
        (2 additions, 1 modification)

Merge — bring a branch back into main after validation.

You:    "The experiment worked. Merge it."
Agent:  → memory_merge(source="eval-sqlite")
        ✓ Merged 3 memories from eval-sqlite.

These aren't metaphors. They're real operations backed by MatrixOne's CoW engine, which provides branch isolation and zero-copy snapshots at the database level.

Why This Architecture Matters

Two lines of research from 2025 validate this approach:

Git operations improve agent reasoning. The Git-Context-Controller paper (Wu, 2025) showed that adding commit/branch/merge operations to agent context management improved SWE-Bench task resolution by 13 percentage points, reaching 80.2%. The ablation study confirmed that branch and merge specifically contributed the critical final gains. Agents with branching capability spontaneously developed more structured exploration strategies.

Memory poisoning is a real threat. MemoryGraft, MINJA, and A-MemGuard demonstrated practical attacks against agent long-term memory. Snapshot + rollback provides a deterministic recovery path that no other memory system offers.

Memoria extends these principles from ephemeral context to persistent memory — a complementary and necessary layer.

Beyond Version Control: What Else Memoria Does

Version control is the headline, but Memoria is a complete memory infrastructure:

Typed memories. Six categories with different retrieval priorities and lifecycle rules:

Type	Purpose	Example
`semantic`	Project facts, technical decisions	"This project uses Go 1.22 with modules"
`profile`	User preferences	"Always use pytest, never unittest"
`procedural`	Workflows, how-to knowledge	"To deploy: make build → kubectl apply"
`working`	Current task context	"Currently refactoring the auth module"
`tool_result`	Cached tool outputs	Stored command results
`episodic`	Session summaries	"Session: DB optimization → added indexes → 93% faster"

Semantic retrieval. Hybrid vector + full-text search. Store "black formatter" and search "formatting tool" — semantic matching finds it. Scored by relevance and recency.

Self-governance. Three maintenance tools run periodically:

memory_governance — quarantines low-confidence memories, cleans stale data
memory_consolidate — detects contradictions (like the black vs. ruff problem), fixes orphaned entries
memory_reflect — synthesizes high-level insights from memory clusters via LLM

Configurable embedding. OpenAI, SiliconFlow, Ollama, or any OpenAI-compatible endpoint. Local embedding available when building from source.

How It Compares

	Memoria	Mem0	Letta	Zep/Graphiti
Version control	Snapshot, branch, merge, rollback, diff	Timestamps only	None	Bitemporal fact tracking
Storage	Single database (MatrixOne)	24+ vector DB backends	PostgreSQL + vector DB	Neo4j
Retrieval	Structured+ Vector + Full-text + hybrid	Vector	Vector + structured	Graph traversal
Self-governance	Contradiction detection + quarantine + reflect	AUDN conflict resolution	Sleep-time compute	Temporal invalidation
Interface	MCP Server + OpenClaw plugin + REST API	SDK/API	Agent framework	SDK/API
Target	Any agent (coding, OpenClaw, custom)	AI app developers	Letta framework users	Knowledge graph users
License	Apache 2.0	Partially open	Apache 2.0	Apache 2.0

Different tools for different problems. Mem0 is right if you need 3-line integration across 20+ frameworks. Letta is right if you're building agents from scratch within their framework. Zep is right if you need temporal knowledge graphs.

Memoria is for anyone who wants their agent's memory to be as manageable as their code — with the full safety net of version control.

Get Started

Memoria ships as a single Rust binary. Setup depends on your agent type.

Coding Agents (Cursor / Kiro / Claude Code)

# 1. Install Memoria
curl -sSL https://raw.githubusercontent.com/matrixorigin/Memoria/main/scripts/install.sh | bash

# 2. Start MatrixOne (or use MatrixOne Cloud — free tier, no Docker needed)
docker compose up -d

# 3. Configure your tool
cd your-project
memoria init --tool kiro \
             --embedding-provider openai \
             --embedding-base-url https://api.siliconflow.cn/v1 \
             --embedding-api-key sk-... \
             --embedding-model BAAI/bge-m3 \
             --embedding-dim 1024

Replace kiro with cursor or claude. Restart your AI tool. Done.

OpenClaw

The openclaw-memoria plugin replaces OpenClaw's default file-based memory with the full Memoria backend — semantic retrieval, version control, self-governance.

curl -fsSL https://raw.githubusercontent.com/matrixorigin/openclaw-memoria/main/scripts/install-openclaw-memoria.sh | \
  env MEMORIA_DB_URL='mysql+pymysql://root:111@127.0.0.1:6001/memoria' \
      MEMORIA_EMBEDDING_PROVIDER='openai' \
      MEMORIA_EMBEDDING_MODEL='text-embedding-3-small' \
      MEMORIA_EMBEDDING_API_KEY='sk-...' \
      MEMORIA_EMBEDDING_DIM='1536' \
      bash -s --

Custom Agents / Any MCP-Compatible Tool

Point any MCP-compatible agent at Memoria:

{
  "mcpServers": {
    "memoria": {
      "command": "memoria",
      "args": ["mcp", "--db-url", "mysql+pymysql://root:111@localhost:6001/memoria", "--user", "alice"]
    }
  }
}

Or connect to a deployed Memoria REST API:

{
  "mcpServers": {
    "memoria": {
      "command": "memoria",
      "args": ["mcp", "--api-url", "https://your-server:8100", "--token", "sk-your-key..."]
    }
  }
}

What's Next

Memoria is Apache 2.0 licensed and fully open source. This is an early release — the architecture is solid, the edges are still being refined.

We're also building Memoria Cloud — a managed service so you can get version-controlled agent memory without running your own database. Stay tuned.

In the meantime, we'd genuinely appreciate your feedback. Try it, break it, tell us what doesn't work. The GitHub issues tab is open.

Memoria: github.com/matrixorigin/memoria
OpenClaw Plugin: github.com/matrixorigin/openclaw-memoria
MatrixOne: github.com/matrixorigin/matrixone

Code has Git. Agent memory now has Memoria.

Built by MatrixOrigin. Open-sourced at GTC 2026.