Your personal memory, across sessions, agents, and devices.

Agent-Driven MemoryCross-Agent MemoryAutomatic Skill ExtractionMemory RetrievalMemory StorageReadable Markdown
BlogsOpen SourceFAQCommunity
Contact UsPrivacy PolicyService Credits Terms
Usecase
SupportGet Started
Back to blog list

memU Gives the Ability to Remember Back to the Agent Itself — Across Sessions, Across Agents, Across Devices

memU Team memU Team
memU Gives Memory Back to the Agent

For the past few years, the industry has built scaffolding around LLMs: summarization pipelines, extraction prompts, reranking chains. Memory systems were the heaviest scaffolding of all — they decided, on the agent's behalf, what was worth remembering and how. memU's July release is a response to a new fact: that harness now lives inside the agent itself. So we deleted our thirty thousand lines of intelligence and gave the ability to remember back to the agent itself. The agent decides what to remember and how to remember it; memU keeps only what the model cannot provide: storage, embedding, and retrieval.

We Used to Be the Harness

The old memU was an intricate machine. You threw raw material at it — conversation transcripts, documents, audio, video — and it turned that material into structured memory. To do this, we maintained a workflow pipeline engine, an LLM/VLM gateway covering half a dozen providers, a sprawling prompt library organized by memory type and modality, and a multi-stage LLM retrieval chain (query rewriter, judge, three levels of rankers) where a single lookup could cost several model calls.

The hidden assumption behind that architecture: the intelligence lives on the memory system's side, and the caller just sends requests. In 2024 the assumption held. The caller was ordinary application code that genuinely did not know how to turn a conversation into a memory, so the intelligence had to hang outside the model as a harness — built by middleware layers like us.

Then the Caller Became a Model

In 2026, the thing calling memU is no longer application code. It is Claude Code, Codex, Cursor — the caller is itself an LLM working with full context. Which leads to a slightly awkward observation:

Everything we used an LLM for inside the pipeline — summarizing, classifying, extracting, judging what is worth keeping — the agent calling us can already do, and do better.

Better, because the agent has something an external pipeline can never have: it lived through the work. It knows which sentence revealed a user preference and which sequence of actions deserves to become a reusable skill, far more clearly than an extractor staring at a transcript after the fact with a 580-line prompt. All the effort we poured into the harness — tuning prompts, preventing misclassification, papering over provider quirks — was, at bottom, an attempt to replicate outside the model, with less context, the intelligence that already exists inside it.

Once the harness lives inside the LLM, wrapping the same harness around the outside is not redundancy — it is degradation: one more hop of latency, one more token bill, one more prompt version that silently drifts. There is only one correct move: delete it, and give the ability to remember back to the agent itself. The division of labor gets redrawn:

The agent does the thinking. memU does the remembering.

The new memU has exactly three operations: commit / list / retrieve. The only model call in the entire system is embedding — zero LLM calls. Retrieval went from a six-stage model chain to a single vector computation, fast enough to sit on the critical path of every answer the agent gives. And memory itself is a folder of Markdown files — cat it and you know exactly what the system remembers. Every other feature in this release follows naturally from that subtraction.

Corollary 1: Installation Is One Message

Taken to its conclusion, even installation needs no harness built for humans. memU's install guide is written for the agent to read: SKILL.md at the repo root is the single entry point. The agent reads it, identifies its host environment, installs the right adapter, and wires up the record and retrieve hooks by itself. All you do is send one message:

Read https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md and follow it to install memU.

Send it, let the agent run, and installation is done. There is no step two.

There is no configuration burden afterwards, either: everything defaults to a local SQLite file, and the only secret you need is an embedding API key — and on the hosted memU platform, not even that. Prefer the terminal? Three commands are the whole surface:

# embedding key (local mode) — memU's only model call
export OPENAI_API_KEY=sk-...

npx memu-cli commit results.json     # store: memories the agent wrote
npx memu-cli list-files              # inspect: what is remembered now
npx memu-cli retrieve "what are the user's release preferences?"

It can be this simple not because the complexity is hidden, but because the complexity is gone: the part that needs intelligence lives in the agent, and the part that remains fits in 474 lines.

Corollary 2: One Memory Across Agents — and Across Devices

Once the memory layer stops embedding anyone's LLM, it stops favoring any one agent. It becomes pure infrastructure that anything can plug into. In this release, every host agent connects through a lightweight adapter to the same store and the same embedding space: Claude Code, Codex, Cursor, OpenClaw, and Hermes each have a dedicated adapter, plus a generic memu-agent adapter that auto-detects any host we have never seen. What a Codex session taught memU last night, Claude Code can retrieve before answering you this morning.

Each adapter binds exactly two seams — and at both seams, the thinking is done by the agent; memU is just the pipe:

  • Record. A background job slices the host's new session logs into self-contained tasks; the agent itself distills them into two kinds of Markdown — memory and skill — and commits them back to the store. In the old architecture, this distillation was a 580-line prompt. Now it is the agent's instinct.
  • Inject. A standing instruction in the host's instruction file (CLAUDE.md / AGENTS.md / SOUL.md): retrieve before you answer. Because retrieval is one vector computation, this instruction can stay resident without worrying about latency.

Cross-device is the same idea, extended. Where your memory lives is your choice:

  • Hosted on the memU platform: memory lives in the cloud at memu.so. Every agent on your laptop, your desktop, and your remote servers reads and writes the same memory, synced automatically — and embeddings are handled by the platform, so you do not need any API key at all. The deployment trick your agent learned on your office machine is still remembered when you open your laptop at home.
  • Local: everything lands in a single SQLite file on your machine, and memory never leaves the device. Bring one embedding API key — the only external call in local mode.

Either way, the medium is always Markdown, never a black-box vector store — you can read it, and you can move it. Migrating from local to the platform, or exporting everything back out, is just moving text files. No proprietary format, no lock-in.

What the Model Absorbed: −32,399 Lines

Plus 451. That is the complete diff of the core refactor (PR #485). The tens of thousands of deleted lines were not bad code — they were working for a world that no longer exists: a world where the caller was plain application code, and the memory system had to think on its behalf. When the harness grows into the model, the right posture for infrastructure is precisely to get dumber: leave the intelligence to the agents at both ends, and make the layer in between fast, reliable, and legible.

  • 474 lines — the entire core logic: agentic.py + service.py
  • 3 operations — commit, list, retrieve. There is no fourth.
  • 0 LLM calls — the only model call is embedding

Try It Now

Send this one message to your agent:

Read https://raw.githubusercontent.com/NevaMind-AI/MemU/main/SKILL.md and follow it to install memU.

memU is open source (Apache-2.0): github.com/NevaMind-AI/MemU. The agent does the thinking; memU does the remembering.