Memory Driven by the Agent You Already Trust

The agent decides what is useful. memU makes it durable and retrievable.

memU does not run a separate memory agent or call an LLM behind the scenes. Host adapters prepare session history for the existing agent, which can ignore it, update a memory or skill, or create a new Markdown file. memU then stores, embeds, and retrieves the result.

Install memU

What Agent-Driven Means

Use the Existing Agent

Codex, Claude Code, Cursor, OpenClaw, Hermes, WorkBuddy, or another compatible host performs the judgment and synthesis.

No Hidden LLM Pipeline

The memory service makes no chat or reasoning calls. Its model dependency is limited to embeddings for indexing and search.

Readable Outputs

The agent writes memory and skill Markdown that remains inspectable before and after it is committed.

Three Memory Operations

The service surface lists recall files, retrieves relevant context, and commits agent-prepared results.

Two Host Seams

A record seam prepares new sessions for memory work; an inject seam retrieves relevant context before the agent answers.

Inside the Agent-Driven Workflow

1. Capture New Sessions

The host adapter reads new session history, including messages and tool calls.

2. Prepare a Job

A scheduled bridge slices the session into a self-contained job with the paths and context the agent needs.

3. Let the Agent Decide

The agent reads related files and chooses to do nothing, patch an existing file, or create a new one.

4. Write Markdown

Useful knowledge becomes readable memory or a reusable skill with a clear name, description, workflow, and edge cases.

5. Commit and Index

The adapter commits changed files; memU stores them and creates the embeddings required for later search.

6. Retrieve Later

On a similar task, a connected host retrieves the relevant file so the agent can reuse what was learned.

Where Agent-Driven Memory Helps

Coding Continuity

Carry project conventions, debugging lessons, and successful workflows across coding sessions.

Cross-Agent Handoffs

Let one host retrieve memory or skills prepared from another host's sessions.

Durable Preferences

Preserve constraints and preferences the agent judges useful instead of asking the user to repeat them.

Inspectable Automation

Review the Markdown an agent prepared and understand exactly what future sessions may retrieve.

Why Keep Judgment in the Agent

One Source of Reasoning

The same agent that performed the work evaluates the outcome and decides what is worth preserving.

No Second Chat Bill

memU does not call another LLM to rewrite queries, summarize results, or manage memory.

Host-Native Context

Each adapter understands where its host stores sessions and which instruction file controls retrieval.

Explicit, Reviewable Changes

Memory changes exist as readable files before commit instead of being hidden inside an opaque pipeline.

Shared Infrastructure

The same storage and retrieval layer works across dedicated and generic host adapters.

Ready to Unlock the Full Potential of AI Memory?

Memory Storage

Store readable memory and skill files with searchable segments in a shared Cloud, SQLite, or Postgres backend.

Explore Memory Storage

Memory Retrieval

Embed a query once, rank relevant file segments and workspace resources, then return the complete readable files to the agent.

Explore Memory Retrieval

Automatic Skill Extraction

Let the agent turn useful session history into reusable Markdown skills, then index those skills for future tasks.

Explore Skill Extraction

Cross-Agent Memory

Connect multiple host adapters to one configured backend so skills learned in one agent can be retrieved by another.

Explore Cross-Agent Memory

Agent-Driven Memory

Keep judgment and synthesis inside the agent while memU handles durable storage, embeddings, and retrieval.

Now Here

Readable Markdown

Give agents inspectable memory and skill files instead of hiding all useful context inside opaque vector records.

Explore Markdown Memory

Coding Skills

Capture coding sessions and compound successful workflows, debugging lessons, and project conventions into reusable skills.

Explore Coding Skills

Open Source

Inspect the lightweight Python implementation, run locally, and adapt host integrations for the agents you already use.

Explore Open Source

Connect Your Agents to memU

Cloud Platform

Get a memU Cloud key, then give the installation prompt to your agent. The skill configures its host adapter against one managed, cross-device memory backend.

Get the Install Prompt

Self-Hosted Open Source

Ask your agent to follow the open-source SKILL.md. It installs the CLI, configures SQLite or Postgres and an embedding provider, then verifies retrieval with the host adapter.

View SKILL.md

Add Another Agent

Run the installation skill in each additional host. Every configured adapter can record its own sessions and retrieve from the same shared backend.

See Host Adapters

FAQ

memU is a lightweight, agent-driven memory system for the agents you already use. It gives connected agents one shared, inspectable memory layer across sessions, agents, and devices.

The memU installation skill configures a host adapter for your agent. A scheduled task captures new session history, the agent decides what memory or skill Markdown to write, and the adapter retrieves relevant files before future tasks. Users do not need to integrate a public memory API.

No. memU's memory service makes no LLM or chat calls. Judgment and synthesis remain inside the host agent; memU stores the Markdown it prepared, creates embeddings, and retrieves relevant files.

The query is embedded once. memU ranks searchable file segments and workspace resources by vector similarity, rolls matching segments up to their complete recall files, and returns segments, files, and resources without an LLM in the retrieval path.

memU includes dedicated adapters for Codex, Claude Code, Cursor, OpenClaw, Hermes, and WorkBuddy. A generic adapter can detect compatible session logs and instruction files for other agents.

Host adapters use the same configured Cloud or local backend. When they use the same memory scope, a skill learned from one host's sessions can be retrieved by another connected host.

Yes. The self-hosted mode supports SQLite for local use and Postgres with pgvector for larger or concurrent stores. Local mode requires a configured embedding provider. memU Cloud provides a managed, cross-device backend.

Yes. The Python package, CLI, host adapters, and core memory service are available on GitHub under the Apache-2.0 license.

Let Your Agent Decide What Becomes Memory

Install the memU skill, connect the host adapter, and keep all judgment inside the agent you already use.

Install memU