OmniMem: Persistent Semantic Memory for AI Coding Agents now with skills
Every AI memory system I've used, including earlier versions of my own, has the same ceiling. It remembers things. Facts, decisions, that bug you fixed in March. Useful, but passive. The agent still has to stumble across the right memory at the right moment, and hope is not a retrieval strategy.
OmniMem v6 is out and it goes past that ceiling. The big new feature is the skill compiler. OmniMem now takes your agent's accumulated experience, the stuff that worked and the stuff that failed, and compiles it into loadable SKILL.md documents that your agent carries into every session.
There's also a much improved web UI, which I'll get to.
From memory to skill
OmniMem has always tracked more than content. Memories carry experience data: an effort score, an outcome, breakthroughs, gotchas, and a graveyard of abandoned approaches with the reason each one died. That data already influenced recall ranking, so hard-won lessons surface ahead of things that worked first time.
v6 takes the next step. If the system already knows what worked, what nearly went wrong and what definitely doesn't work, why wait for a lucky recall? Compile it into an actual skill.
That's what `compile_skill` does. For a given domain it walks your experience data and builds a structured skill:
- Breakthroughs become "Do" rules. The approaches that cracked the problem.
- Gotchas become "Watch" rules. The traps you nearly fell into.
- Graveyard entries become "Don't" rules. Dead ends, with the reason each one failed.
Every rule cites the memories it came from. You can trace any line in a skill back to the session where you actually learned it.
No LLM in the compile path
This was a deliberate design call and I'd defend it all day. The compiler is a deterministic template engine. Similar lessons cluster by embedding similarity, graveyard entries group by approach name, and rule text is lifted straight from your memories.
Why bother? Because skills shouldn't rewrite themselves behind your back. Compilation goes through a propose and accept gate: `compile_skill` returns a unified diff with a risk-classified summary of what changed, and nothing gets written until you accept it. Deterministic rendering means those diffs show substance. A new rule, a removed source. Not an LLM paraphrasing everything and burying the one real change in noise.
There's a quality bar too. A lesson needs reinforcement from at least two separate memories before it earns a place in a skill. One good afternoon doesn't make doctrine. If you do have a single lesson strong enough to promote straight away, `bless()` skips the gate on purpose. Intelligence at the edges, determinism in the middle.
Knowledge can feed skills, but only when you say so
The RSS worker has been pulling articles from your feeds since the early versions. In v6 that knowledge can flow into compiled skills, but never automatically, you have to tell the skill to check the knowledge in OmniMem first.
Volatile stuff like version numbers stays lookup-only. Durable reference material crosses over when you promote it with `promote_knowledge`, and you can pull discrete guidance out as individual rules. An article titled "5 things to avoid for accessible websites" becomes five separate don't rules, each citing the source, rather than one mushy summary line.
Rules go stale, so there's `knowledge_watch` as well. It compares newly ingested articles against your existing skills and flags anything nearby in your session briefing, escalating when an article looks like it contradicts a rule you're carrying. Your RSS feeds become an early warning system for your own doctrine.
The flywheel effect
This is the bit that makes v6 more than a feature release. It closes a loop:
- You work. Sessions generate memories, effort scores, breakthroughs and dead ends.
- Experience accumulates. The graveyard grows, lessons get reinforced across sessions.
- Skills compile. Reinforced lessons distil into reviewed, versioned SKILL.md documents.
- Your agent shows up already carrying your doctrine. Not hoping to recall it. Loaded with it.
- Better work generates better experience, which refines the skills, which improves the work.
Each turn of the wheel makes the next push easier. Months of your actual engineering experience, compiled into skills your agent applies by default. And the whole thing spins on your own hardware. No SaaS in the loop, no context shipped to someone else's servers.
Full mechanics are in the docs: https://codeberg.org/ric/_harvey/omnimem/src/branch/main/docs/skill-compiler.md
The web UI
The dashboard got a proper rework in v6 as well.
There's a new Skills section: a catalogue of compiled skills with a banner when a proposal is waiting for review, and a detail view showing the rule manifest, the full SKILL.md body, and links from every rule back to its source memories.
The dashboard picked up a Skills card and a project state breakdown, skills appear in the recent activity feed, and the sidebar has been regrouped so Memory, Skills, Knowledge Management and System Management each have a sensible home.
The whole UI has also been rethemed. Proper dark theme, a new light theme with a footer switch, a composition bar on the dashboard, and recall heat indicators on memory rows so you can see which memories are actually earning their keep.
Try it
OmniMem is open source, MIT licensed and self-hosted. Valkey for vector search, local embeddings via sentence-transformers, multi-arch Docker images that run on anything from a Raspberry Pi to Graviton. Free forever. No enterprise tier, no strings.
To get it running is one command:
curl -fsSL https://codeberg.org/ric_harvey/omnimem/raw/branch/main/install.sh | bash
The installer walks you through the config prompts, pulls the containers, and polls until both the MCP endpoint and the web dashboard are actually answering before it hands back your terminal. When it finishes you have a working memory server, not a to-do list. If you'd rather read a shell script before piping it into bash (good instinct), it's right there in the repo.
Website and docs: https://omnimem.org/
Source, issues and the full v6 changelog: https://codeberg.org/ric/_harvey/omnimem
One small ask. OmniMem has no marketing budget, no VC money and no growth team yet. What it has is stars. If this looks useful, star it on Codeberg (or on the GitHub mirror if that's where you live). It genuinely helps other people find the project, and it costs you one click.
If you keep living the same coding session twice, this is the fix. I'd be curious to hear what skill your agent compiles first. Find me on the Codeberg repo or on Mastodon.