memU: Agent Memory Stored as Markdown Wiki, Distilled by the Agent Itself
Personal memory across agents
At a glance
- What is it?
- memU is a Python sidecar that turns desktop coding-agent session logs into retrievable Markdown skills and memory. Its design keeps all LLM judgment inside the host agent, which is unusual and also the source of its main constraint.
- Who is it for?
- Adopt memU if you already run Codex, Claude Code, Cursor or OpenClaw daily and want session knowledge to survive across those hosts without building a memory layer yourself. Skip it if you need memory inside a chat product, since the support matrix marks ChatGPT Chat and Claude Chat as unsupported, or if you cannot accept a hosted API key for the default path.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The Problem memU Targets: Session Knowledge That Dies With the Session
Desktop coding agents accumulate useful context and then lose it. A debugging sequence in Cursor that took forty minutes produces nothing reusable. The same problem recurs in Codex, in Claude Code, and in OpenClaw, and each tool keeps its own transcript in its own format under its own home directory. memU's premise is that these transcripts are the raw material for memory, and that the right output format is Markdown a human can read and edit. The README frames the product as "Personal memory, stored as Wiki" and lists the scope as "Across Sessions. Across Agents. Across Devices." The intended user is someone who runs more than one desktop coding agent and wants the knowledge from one to be available in another. That is a narrower audience than the phrase "agent memory" suggests. memU is not a memory library you import into your own agent loop. It is a sidecar that patches existing hosts.
Record and Inject: The Two Seams Every Host Adapter Binds
The architecture is easier to grasp through the adapter contract than through the banner diagram. Each host adapter is described as binding two seams. The record seam has a scheduled bridging task that slices new session logs into self-contained job files. The agent, not memU, distills those jobs into memory or skill Markdown. Then `commit` submits whatever the agent wrote back through `commit_results`. The inject seam is a standing instruction placed in the host's instruction file, telling the agent to run `<binary> retrieve` (the README maps this to `progressive_retrieve`) before answering. The data flow is therefore: session log on disk, sliced into job files, agent reads them and decides what to write, `commit` indexes the result, and a later `retrieve` call surfaces it. The README is explicit that `MemoryService` makes no LLM or chat calls and only stores, embeds and retrieves the Markdown the agent prepared. That is the most interesting design decision in the project. It means the quality of your memory depends on the host model's judgment, not on memU's. It also means memU cannot improve memory quality by changing a prompt, and it cannot be blamed for bad extractions either.
Skill Extraction Is a Six-Step Loop With the Agent in the Middle
The README breaks automatic skill extraction into six steps. Capture new sessions, including messages and tool calls. `prepare` slices each session into a self-contained job with the paths and context the agent needs. The agent reads related existing skills and chooses among three actions: do nothing, patch an existing skill, or create a new one. Each skill is written as Markdown with a name, a description, and a reusable workflow covering branches, edge cases and pitfalls. `commit` submits changed skill files through `commit_results`, and memU embeds the skill name and description and stores it under the `skill` track. Retrieval then returns the skill when a similar task appears. Two things stand out. First, the do-nothing branch is a real design choice, not a formality: it gives the agent permission to conclude that a session taught nothing reusable. Second, only the name and description are embedded, not the full workflow body. That keeps the index small but means retrieval matches on a summary the agent wrote, so a poorly worded description makes a skill effectively invisible. Nothing in the README describes a fallback for that case.
Host Adapters and the Files They Mine
The adapter table is the most concrete part of the documentation. Codex uses the `memu-codex` binary, mines `~/.codex/sessions/**/*.jsonl`, and patches `~/.codex/AGENTS.md`. Claude Code uses `memu-claude-code`, mines `~/.claude/projects/<project>/<session>.jsonl`, and patches `~/.claude/CLAUDE.md`. Cursor uses `memu-cursor`, mines `~/.cursor/projects/<project>/agent-transcripts/**.jsonl`, and patches a per-project `./AGENTS.md`. OpenClaw uses `memu-openclaw` and reads `~/.openclaw/agents/<agentId>/agent/openclaw-agent.sqlite` in read-only mode, plus legacy `<agentId>/sessions/*.jsonl` files. The read-only SQLite access is worth noting: memU does not write into the host's database, which limits the blast radius if something goes wrong. The instruction-file patch is the part that should make you pause. memU edits a file your agent already reads on every task, and the README notes the Cursor target is per project while the Codex and Claude Code targets are global. A global edit to `~/.claude/CLAUDE.md` affects every project you open with that host.
Installation Runs Through the Agent, Not Through pip
The documented install path is a message to your agent, not a shell command. The README gives this example: ask the agent to read `https://memu.pro/SKILL.md`, follow its instructions to install and configure memU, and supply an API key obtained from memu.so in the form `memu_•••••••••`. The self-hosted variant instead points the agent at `https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md`. Uninstall follows the same pattern against the hosted SKILL.md. The Python package is published as `memu-cli` on PyPI, and the README states Python 3.11 or newer. The self-hosted section is labelled "Private · Single-device · Embedding key required", which tells you the local path still needs an embedding provider key and does not synchronise across devices. That is a meaningful gap against the "Across Devices" tagline, which the hosted path presumably covers. One operational detail worth knowing before you install: uninstalling by default removes the host integration and tooling but keeps your memory store and `~/.memu/config.env`, so a reinstall resumes. Memory is erased only on explicit request.
The Support Matrix Is Where memU Gets Honest
The tested-integration matrix is unusually candid and is the section to read before anything else. ChatGPT in Chat mode is marked unsupported for both Memorize and Retrieve on macOS and Windows, with the note that Work mode should be used instead. Claude Chat and Cowork are likewise unsupported on both platforms. On Linux, the Codex VS Code extension shows Memorize as unsupported while Retrieve works. Several entries carry caveats rather than clean ticks. Claude Code may need a retry with Opus or another model because Sonnet 5 can occasionally decline the setup steps. On Windows, Hermes Agent retrieval is flagged with a warning that older memU versions may retrieve from the wrong files, and the fix is a version with Windows `HERMES_HOME` support. WorkBuddy with Hy3 may fail retrieval entirely. OpenClaw on macOS is noted as having unverified retrieve support. These are not edge cases buried in an issue tracker; they are in the README. The pattern is that memU's reliability depends on the host model's willingness to follow instructions, which is a fragile foundation for a background task you are not watching.
Where memU Is the Wrong Tool
The clearest failure mode is host dependence. Because the agent performs the distillation, any host that declines the setup steps, or a model that refuses a tool call, produces no memory. The README confirms this happens with Sonnet 5 on Claude Code and with Hy3 on WorkBuddy. If your team standardises on a chat product rather than a coding agent, memU has nothing to offer, since ChatGPT Chat and Claude Chat are both marked unsupported. A second limitation is scope: the self-hosted configuration is single-device and requires an embedding key, so the cross-device promise only holds on the hosted path with a memu.so API key. If your constraint is that session data cannot leave your machines, you are choosing between single-device memory and no memory. Third, the project is on a beta release line. The most recent release listed is `v2.0.0-beta.0` from July 2026, following stable `v1.5.1` in March 2026. The README notes that support status reflects the current release and may change. Anyone adopting the beta is accepting that the adapter surface can move.
How memU Differs From an Embedding-First Memory Library
The natural comparison is a memory library you import into your own agent, where you call an add function with a message and a search function that returns semantically similar past messages. That approach embeds raw conversation turns and retrieves by vector similarity. memU inverts both halves. Storage is agent-authored Markdown with an explicit name, description and workflow rather than raw turns, and retrieval is triggered by an instruction the host agent is told to run before answering. The practical difference shows up in what you get back. A vector store returns fragments of things you said. memU returns a skill document the agent wrote, which may include branches and pitfalls that never appeared verbatim in any session. The trade-off is that memU's output is only as good as the agent's synthesis, and its index only covers the name and description. A library that embeds full text will match on details memU's summary omits. memU's counter-argument is inspectability: the README states the core memory logic is only 500 lines, compact enough to read and adapt. That is a claim about the codebase, not about memory quality, and it is the kind of claim you can check in an afternoon.
Maintenance Cost and the Licence Question
Maintenance has three components. The first is version drift between memU and your hosts, since adapters read specific paths and patch specific files; the Hermes Agent warning about `HERMES_HOME` shows what happens when the host moves and the adapter does not. The second is model drift, since a host model update can change whether the agent follows the install and retrieval instructions. The third is your own skill store, which grows as Markdown files and will need pruning if the agent keeps patching rather than creating. On licensing, the material conflicts. The repository metadata reports NOASSERTION, while the README displays an Apache 2.0 badge and links to opensource.org. NOASSERTION is what GitHub reports when it cannot match a licence file to a known template, so the two are not necessarily contradictory, but they are not the same signal either. Check the actual LICENSE file in the repository before you rely on either. This is not legal advice, and if you are embedding memU in a commercial product, the file itself is the only thing that settles it.
Editorial conclusion
Adopt memU if you already run Codex, Claude Code, Cursor or OpenClaw daily and want session knowledge to survive across those hosts without building a memory layer yourself. Skip it if you need memory inside a chat product, since the support matrix marks ChatGPT Chat and Claude Chat as unsupported, or if you cannot accept a hosted API key for the default path. Before trusting it, verify three things: that your host appears in the tested matrix with both Memorize and Retrieve ticked, that your Python is 3.11 or newer, and that the self-hosted route is viable for you, because that is the only path that avoids the memu.so key. Read the actual licence file rather than the badge, since the repository metadata reports NOASSERTION while the README shows an Apache 2.0 badge.
Community notes