# memU: personal agent memory stored as Markdown skills > NevaMind-AI/memU gives desktop coding agents a shared memory store, with a sidecar binary per host and skill extraction that runs inside the agent. The README is honest about which integrations are unverified. **NevaMind-AI/memU** — Personal memory across agents - Repository: https://github.com/NevaMind-AI/memU - Website: https://memu.pro - Stars: 14,487 · Forks: 1,080 - Language: Python - License: NOASSERTION - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/nevamind-ai-memu ## What memU actually solves for agent users Every coding agent session starts cold. You explain the repository layout again, restate the build command, re-describe the convention that the team settled on last week. memU's answer is to mine the session logs your host already writes, turn the useful parts into Markdown, and feed that Markdown back before the next answer. The intended user is someone running a desktop coding agent all day and switching between more than one of them. The README frames the product as "Personal memory, stored as Wiki," and the pitch is cross-session, cross-agent, cross-device. That third axis is the hosted part: memu.so issues the API key, and the README describes the hosted tier as cross-device, free and unlimited. The self-hosted path is described as private and single-device, which is a real distinction rather than a marketing line: if you self-host, you are not getting the sync. It is not a general-purpose vector database and it is not a RAG framework for your documents. The unit of memory here is your own agent history. ## Two seams: record and inject memU runs as a sidecar to a desktop agent, one binary per host. Each adapter binds two seams, and understanding them explains most of the project's behaviour. The record seam is a scheduled bridging task. It slices new session logs into self-contained job files. The agent itself reads those jobs, looks at related existing skills, and decides to do nothing, patch a skill, or create a new one. Then `commit` submits whatever the agent left on disk through `commit_results`. The README is explicit that judgment and synthesis stay inside the agent: `MemoryService` makes no LLM or chat calls, it only stores, embeds and retrieves the skill Markdown the agent prepared. That is a deliberate architectural boundary, and it means memory quality tracks the host model's quality rather than memU's. The inject seam is simpler. A standing instruction is written into the host's instruction file telling the agent to run ` retrieve`, which maps to `progressive_retrieve`, before answering. The README's adapter table lists the session log each binary mines and the instruction file it patches. Codex reads `~/.codex/sessions/**/*.jsonl` and patches `~/.codex/AGENTS.md`. Claude Code reads `~/.claude/projects//.jsonl` and patches `~/.claude/CLAUDE.md`. Cursor reads `~/.cursor/projects//agent-transcripts/**.jsonl` and patches a per-project `./AGENTS.md`. OpenClaw reads a SQLite file at `~/.openclaw/agents//agent/openclaw-agent.sqlite` in read-only mode, plus legacy per-agent session JSONL. That table is the most useful page in the repository, because it tells you exactly which files memU touches on your machine before you run anything. ## Installing memU through your agent, not pip The primary install path is not a package manager command. The README instructs you to get an API key from memu.so and then send a message to your agent telling it to read `https://memu.pro/SKILL.md` and follow the instructions, with the key pasted in. The agent performs the installation and configuration. If you prefer to read the install script before an agent executes it, the self-hosted route points at the repository copy instead. The README gives this message to send: ``` Read https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md and follow it to install memU. ``` The self-hosted variant is described as private, single-device, and requiring an embedding key. Note the difference from the hosted path: hosted needs an API key from memu.so, self-hosted needs an embedding provider key. The README does not spell out which embedding providers are accepted, so that is a question to settle before you start. For contributors working on memU itself, the Makefile shows the expected toolchain. `make install` runs `uv sync` and installs pre-commit hooks; `make check` verifies the lock file with `uv lock --locked`, runs pre-commit, mypy and deptry; `make test` runs pytest with coverage. The package declares `requires-python = ">=3.11"` and depends on httpx, numpy, openai, pydantic, sqlmodel, alembic and pendulum. A Postgres extra exists for pgvector and the SQLAlchemy Postgres driver, which is the option to look at if you outgrow the default local store. One practical wrinkle: the published version in `pyproject.toml` is `0.11.0-beta.3` while the release list shows `v2.0.0-beta.0`, and the README badge points at the PyPI project `memu-cli`. If you install from PyPI rather than through the agent flow, check which of those you actually got. ## Where memU breaks or is the wrong tool The support matrix is the honest part of the README, and it should be read before anything else. ChatGPT in Chat mode is marked unsupported for both memorize and retrieve on macOS and Windows; the note says to use Work mode. Claude in Chat and Cowork is likewise unsupported on both platforms. If your workflow lives in a chat window rather than an agent with a filesystem, memU has nowhere to write and nothing to mine. Several entries are marked supported with an important limitation. OpenClaw on macOS is listed as memorize yes, retrieve yes, with the note that retrieve support has not yet been verified. Hermes Agent on Windows is memorize yes, retrieve with a warning: use a memU version with Windows `HERMES_HOME` support, because older versions may retrieve from the wrong files. WorkBuddy on Windows notes that with Hy3 retrieval may fail and suggests retrying with another model. Codex on Linux is listed as memorize no, retrieve yes, from the VS Code extension. There is also a model-dependency failure that has nothing to do with memU's code. For Claude Code on both macOS and Windows, the note says that if the selected model declines the setup steps, retry with Opus or another model, because Sonnet 5 can occasionally do this. That is a consequence of the design decision to keep synthesis inside the agent: when the host model refuses the task, memory extraction simply does not happen, and memU has no fallback path of its own. The last boundary is scope. memU distills agent history into skills and memory. It is not a document index, not a knowledge base you populate by hand, and not a substitute for repository-level context files you maintain deliberately. ## memU compared with OpenClaw and Mem0 The comparison people search for most is memU against Mem0, and the difference is architectural rather than cosmetic. Mem0 is a memory layer you call from your application: your code decides what to add and what to search. memU inverts that. It attaches to a host agent you already use, reads the session logs that host already writes, and patches the host's instruction file so retrieval happens automatically. You do not write retrieval calls; you install a sidecar and the agent calls `retrieve` on its own. That inversion is also the constraint. memU only works where a supported host writes session logs to a known path. If your agent does not persist transcripts, or persists them somewhere the adapter does not look, memU cannot see anything. An application-level memory library has no such dependency, because you hand it the data yourself. The OpenClaw comparison is different in kind, because OpenClaw appears both as a host memU supports and as a topic in the same search space. memU ships `memu-openclaw`, which reads OpenClaw's SQLite agent store read-only plus legacy session JSONL, and patches a file under `~/.openclaw/workspace/`. So the relationship is adapter, not rival: OpenClaw is one of the hosts memU bridges, and the README marks its retrieve support as unverified on macOS. A third reference point is the project's own self-hosted mode. If your objection to a hosted memory service is data leaving the machine, the self-hosted route is the alternative to memU's own hosted tier rather than to another product, at the cost of single-device scope and an embedding key you supply. ## Maintenance, licence and upgrade cost The repository is not archived, and the last push was on 2026-09-10, which is recent enough that the integration matrix should be treated as a moving target. The README says as much: support status reflects the current release and may change as host integrations evolve. That sentence matters operationally, because memU patches files inside other tools. When Codex, Claude Code, Cursor or OpenClaw changes where it writes session logs or how it reads its instruction file, the corresponding adapter has to follow. The release history shows a fast-moving beta line. v1.5.0 and v1.5.1 landed in March 2026, and v2.0.0-beta.0 in July 2026. The package classifier is Development Status 4 - Beta, and the published version string carries a beta suffix. Expect breaking changes between the v1.5 line and v2. The licence situation needs care. The README badge says Apache 2.0 and links to opensource.org, but the repository metadata reports NOASSERTION, and the `license` field in `pyproject.toml` is commented out. The file `LICENSE.txt` exists at the top level. If licence terms determine whether you can ship memU inside a product, read `LICENSE.txt` directly rather than trusting the badge. That is a factual discrepancy in the repository, not a legal opinion, and it is worth resolving before adoption rather than after. Upgrade cost is mostly the agent flow. Because installation is performed by your agent reading a remote SKILL.md, an upgrade means re-running that flow, and it means the agent will edit host instruction files again. Uninstall is documented: by default it removes the host integration and tooling while keeping your memory store and `~/.memu/config.env`, so a reinstall resumes. Memory is erased only when you explicitly ask for it. That default is sensible, but it also means an uninstall is not a clean slate unless you ask for one. ## Conclusion Adopt memU if you already run Codex, Claude Code, Cursor or OpenClaw on macOS or Windows and want session history distilled into reusable Markdown skills without writing your own retrieval loop. Skip it if you need a supported ChatGPT Chat or Claude Chat integration, or if you cannot accept that OpenClaw retrieval is listed as unverified. Before committing, check the host adapter table for your exact host and OS combination, confirm whether you want the hosted memu.so path (which needs an API key) or the self-hosted path (which needs an embedding key), and read the uninstall section so you know that the memory store and ~/.memu/config.env survive a default removal. ## FAQ ### What is the main problem with AI memory that memU addresses? Sessions start without the context the previous session established. memU mines the session logs a host agent already writes, turns useful parts into Markdown skills, and injects relevant memory before the next answer. ### What is an agent memory framework? In memU's case it is a sidecar that binds two seams to a host agent: a scheduled task that records new session history into job files, and a standing instruction that makes the agent retrieve relevant memory before answering. ### How does AI agent memory work in memU? The host adapter reads new session history including messages and tool calls, `prepare` slices each session into a self-contained job, the agent decides whether to patch or create a skill, and `commit` submits the changed Markdown through `commit_results`. MemoryService makes no LLM calls. ### Who is the founder of Mem0 AI? The repository material does not name Mem0's founder. It only describes memU's own architecture and lists Mem0 as a comparison point in search interest. ## Sources - [Issues](https://github.com/NevaMind-AI/memU/issues) - [NevaMind-AI/memU on GitHub](https://github.com/NevaMind-AI/memU) - [Project website](https://memu.pro) - [README](https://github.com/NevaMind-AI/memU/blob/main/README.md) - [Releases](https://github.com/NevaMind-AI/memU/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nevamind-ai-memu