memU
Long-term memory for AI agents across sessions, tools, and devices, automatically distilling agent history into reusable memory and skills.
SKILL.md explicitly instructs 'install in one pass; don't stop for confirmation', defaulting to an hourly cron background task, patching host instruction files, and installing memu-cli; cloud mode sends user API key and session data to MemU Cloud. Data flow is disclosed (local/cloud, ~/.memu/config.env) and uninstall preserves user memory with a recovery path — good; but there is no explicit user confirmation before install, disclosure of the sensitive session-log reading is incomplete, and the actual install guide lives outside this file and is unauditable. Deducted for: silent full-install default and incomplete confirmation mechanism.
Path is self-consistent: install → pick host → print packaged guide → follow, with stale-build ('invalid choice') troubleshooting, verify gates, and good failure feedback (omit registration time rather than fabricate). But the core install logic lives in packaged 'docs install' output outside this file and cannot be statically verified; host adapter behavior is not reproducible here. Deducted for: key paths not statically reproducible, tests do not cover this skill's install path.
Target scenario (installing memory for coding agents) and trigger terms (install/set up/uninstall) are clear, with a nine-host routing table and memu-agent detect fallback; README adds an OS×agent support matrix. But the cloud backend depends on memu.so (overseas service), Chinese-language support and mainland-China reachability are undeclared, and non-fit boundaries appear only in scattered notes. Deducted for: limited evidence on environment reachability and non-fit ranges.
Repository has Apache-2.0 LICENSE, CHANGELOG, AGENTS.md, pre-commit, CI build workflow, and a substantive test suite; SKILL.md name/description match capability, and layering (routing file + packaged guides) is clean. But license metadata is NOASSERTION, publisher unverified, and pyproject (0.11.0-beta.3) vs CHANGELOG (2.0.0-beta.0) versions are inconsistent. Deducted for: license metadata inconsistency and maintenance responsibility not pinned at the skill level.
Goals are clear (install+uninstall loop, two-seam report, reversible); marginal value is real (saves manual cron and instruction-file wiring). But actual output depends entirely on the pip package's embedded guides, unverifiable statically; the word-for-word report template is useful yet rigid. Deducted for: no execution evidence; direct usability is inferred only.
Repo contains real CI (build.yml running make test) and a service-level test suite (test_agentic.py etc.), with per-commit CHANGELOG links — auditable primary material. But the install flow this skill routes has no tests or third-party execution evidence, and the README host matrix cannot be statically checked. Deducted for: thin reproducible evidence for this skill's key path.
- Install defaults to no user confirmation and registers an hourly background task plus patches to host instruction files; require explicit confirmation beforehand if you need control.
- Cloud mode sends the API key and session data to MemU Cloud (memu.so, an overseas service); mainland-China reachability is unverified — use local mode without a key.
- The skill reads full host session logs as its memory source and persists potentially sensitive data; uninstall keeps the memory store by default — deletion requires an explicit request.
- The actual install steps live in dynamic docs inside the pip package, unauditable by static review; run <binary> doctor after install to verify.
- Version markers are inconsistent (pyproject 0.11.0-beta.3 vs CHANGELOG 2.0.0-beta.0) and the project is in beta.
What does this skill do, and when should you use it?
memU is a lightweight, agent-driven memory system that gives agents a shared long-term memory across sessions, agents, and devices (local or MemU Cloud). It wires into a host agent through two seams: a scheduled background task that mines session logs into durable memory (record) and a standing instruction in the agent's instruction file that makes it retrieve before answering (inject). The core memory logic is only about 500 lines, compact enough to inspect and adapt. The installation entry point is a SKILL.md routing skill: install the memu-cli package, identify your host, and follow that host's packaged install guide. Beyond dedicated desktop-coding-agent adapters, it offers automatic skill extraction that turns agent history into reusable Markdown skills.
After installing memu-cli, the skill picks the binary for your host (memu-codex, memu-claude-code, memu-cursor, memu-openclaw, memu-hermes, memu-workbuddy, memu-cola, memu-pi, or generic memu-agent), writes ~/.memu/config.env via <binary> init (local or cloud backend), and <binary> docs install prints a guide that registers the scheduled bridging task, patches the host instruction file, and passes verify gates at each step. It reads each host's session logs (e.g. JSONL under ~/.claude/projects, SQLite for OpenClaw/Hermes); the agent distills them into memory/skill Markdown, committed through commit_results and embedded/indexed by MemoryService. The injected instruction makes the agent run <binary> retrieve before answering. <binary> doctor verifies config and a live retrieval; uninstall via <binary> docs uninstall keeps the memory store and config by default.
- A developer who uses Claude Code or Codex daily and wants project knowledge and past pitfalls available in new sessions automatically
- A user juggling multiple agents (e.g. Claude Code + Cursor) who wants them to share one memory store
- A user who wants agent history automatically distilled into reusable Markdown skills
- A privacy-conscious self-hoster keeping memory in local SQLite or Postgres
- A user of niche agents like Hermes, WorkBuddy, Cola, or pi that have dedicated adapters
What are this skill's strengths and limitations?
- One shared long-term memory across sessions, agents, and devices
- Core memory logic is ~500 lines — easy to inspect and customize
- Local (SQLite/Postgres) and MemU Cloud backends; privacy is under your control
- Automatically turns agent history into reusable Markdown skills
- Verify gates on every install step plus a `doctor` command to diagnose the whole loop
- GitHub license field is NOASSERTION, conflicting with the README's Apache-2.0 claim
- Some platform combos are incomplete: ChatGPT only in Work mode, Codex on Linux retrieve-only, OpenClaw retrieval unverified
- Local mode requires your own embedding provider API key (openai/jina/voyage/doubao/openrouter)
- Uninstall and reporting rely on the agent following fixed templates exactly; not all models will comply reliably
- No independent test suite is evidenced in the source material
How do you install this skill?
Simplest path: get an API key from memu.so and send your agent: "Read https://memu.pro/SKILL.md and follow its instructions to install and configure memU, API Key is memu_...". The agent executes SKILL.md's three steps: pip install --upgrade memu-cli; identify the host (run memu-agent detect if not in the table); then <binary> init [--cloud-api-key <key>] followed by <binary> docs install, followed exactly. For self-hosting, use the same entry point and configure a local backend during setup (an embedding provider key is required).
How do you use this skill?
After installation the agent retrieves relevant memory automatically before answering — no extra action needed. Manual retrieval: memu-codex retrieve "What should I remember about this project?" (swap in your host's binary). Cloud users view memory files at memu.so; local users inspect the store set by MEMU_DB (default ~/.memu/memu.sqlite3). To uninstall, tell your agent: "Follow <your-binary> docs uninstall to uninstall memU".