Memory isn't enough. AI needs experience.

Twenty runs. The answer to the task was already sitting in <omnimem>. Across all twenty, the agent made zero memory calls of its own.

That result changed how I think about AI memory. Storage was never the hard part. An agent with perfect recall will still walk back into last week's dead end if nothing tells it the dead end matters, and nothing makes it look, and this isn’t how we (humans) use or think about memory. So my approach was to start modelling our behaviours into the recall, and there is much more to come in the future.

Every memory system can remember. <omnimem> is built to gain experience: to know what worked, what failed and what it cost, and to act on that before your agent repeats itself.

A filing cabinet doesn't get better at its job

Most AI memory is a filing cabinet. You put things in, you search, you get things out. Add more and it gets bigger and noisier: old decisions sit beside new ones with equal weight, and a workaround from six months ago ranks as high as the fix that replaced it.

An apprentice works differently. They remember what happened, and they remember how it went. The approach that took four attempts and a weird workaround sticks. The one that wasted a day becomes a note to self: don't do that again. After enough jobs, the lessons stop being memories and become habits.

That's the line between memory and experience.

	Memory	Experience
What it keeps	What happened	What happened, how it went, what it cost
Failures	Stored like anything else, or lost	Kept in a graveyard and used as warnings
Over time	Grows and gets noisier	Fades the stale, strengthens the hard-won
Conflicts	Both versions kept silently	Flagged the moment they're written
End state	A bigger pile	Rules your agent follows

How <omnimem> turns memory into experience

Six mechanisms, all in the same binary, all running on your machine.

[Diagram goes here: the experience loop, 5 stages. It lives in the online doc, so export it from there.]

Put together, it's a loop: what happens in one session shapes how the next one starts.

Experience scoring. Every memory carries an outcome and an effort rating from 1 to 5. Effort raises its weight at recall from 1.0× up to 1.8×, so the lesson that cost you a day outranks the one that cost you a minute. Recall ranks on similarity × surface × recency × experience × date, not similarity alone.

The graveyard. Abandoned approaches aren't thrown away. They're recorded with what was tried, why it failed and how much effort went in. When your agent heads down a path that's already in the graveyard, it gets a warning and the alternatives that worked instead.

A memory lifecycle. Memory isn't binary. Entries move from active (1.0×) to deprioritised (0.2×) to archived (0.0×) to deleted, and a deprioritised memory can come back when a query proves it's relevant again. Recency fades gently: 0.9 at 90 days, then 5% every 30 days, never below 0.3.

Contradiction detection and deduplication. Every write is checked. A near-duplicate returns the existing memory instead of storing a copy. A likely contradiction is stored with a warning, so you resolve it now rather than discovering it mid-task.

Compiled skills. This is where memory becomes habit. compile_skill(domain) reads the reinforced lessons, recurring gotchas and graveyard for a domain and writes a SKILL.md: rules your agent follows, each citing the memories it came from, plus a never-again list from the graveyard. A lesson only becomes a rule once it recurs (twice by default), every change arrives as a diff for you to accept, and the same sources always compile to the same file.

Hooks. The fix for those twenty runs. omnimem hook injects a project briefing when a Claude Code session starts, blocks tool calls that repeat an abandoned approach, and records how the session ended. A briefing takes about 6 ms. Your agent no longer has to remember to remember.

The evidence, and what it doesn't prove yet

I tested the hooks on one task: ten pairs of runs, with and without them.

• With hooks, every attempt at the abandoned approach was stopped before it ran, and no run reached a failing test suite.
• Without hooks, 8 of 10 runs did.
• Runs with hooks cost 27% less.

That's a small test, run by me, on my own data, and I'd rather say so up front. It's exactly the kind of result I want other people to try to break.

On recall, I ran <omnimem> against LongMemEval earlier this year: 5.x scored 65.6% across 500 questions with a GPT-4o judge. The runs also exposed real bugs, including fact extraction replacing verbatim content instead of adding to it, and those got fixed. Those numbers are from 5.x. I haven't re-run it on 7 yet.

It's worth being clear about what LongMemEval measures: whether a system can find facts in long chat histories. It doesn't measure whether an agent learns from outcomes, avoids dead ends or gets cheaper over time. That's the part I care about, and I haven't found a public benchmark for it yet. Maybe we should create one!

7.0: one binary, nothing else to install

6.x was four containers: Valkey, a Python MCP server, a web UI and an RSS worker. 7.0 is one Rust binary.

• One file of state. Memories live in SQLite. Vectors are searched exactly, filters are plain SQL, and there's no separate index to drift. A real store of 3,500 memories is a 12.8 MB database.
• Local embeddings. all-MiniLM-L6-v2 runs on ONNX Runtime with no GPU. The model downloads once, about 90 MB. Nothing leaves your machine unless you opt in to Claude Haiku for fact extraction, query expansion and summaries.
• Same tools. All 48 MCP tools keep their names, parameters and defaults from 6.x.
• Desktop or server. A tray app on macOS (Apple silicon), Windows and Linux (Flatpak), or .deb, .rpm and Docker on a server, serving MCP on port 8765 with token or OAuth 2.1 auth.

It works with any MCP client, including Claude Code, Claude Desktop, claude.ai, Codex, Cursor, OpenCode, GitHub Copilot, GitLab Duo and Kiro.

The rough edges, honestly: there's no Intel Mac build yet, and the Windows installer isn't code-signed, so SmartScreen will grumble.

Open source, not open core

<omnimem> is MIT licensed and free forever. Every feature in this post is in the open source core, and it stays there.

I'm planning optional paid services for people who'd rather not run things themselves: hosting, secure tunnels and encrypted backups. They're convenience, not features. Anything they do, you can do yourself with the open source binary, and paying for one funds the project rather than unlocking it.

Get started

Grab the installer for your platform from omnimem.org, or on a Debian or Ubuntu server:

sudo apt install ./omnimem_<version>_amd64.deb
curl http://127.0.0.1:8765/healthz

Then point Claude Code at it:

claude mcp add --transport http --scope user omnimem http://127.0.0.1:8765/mcp

On the desktop, the tray menu does that step for you.

The source lives on Forgejo, with a GitHub mirror. If <omnimem> saves your agent from one dead end, a star helps other people find it. If it doesn't, open an issue and tell me why.

Stop living the same session twice.