Readable Markdown as the Agent-Facing Memory

Agents work with files; memU handles durable storage and search.

The host agent writes memory and skill Markdown it can inspect and revise. On commit, memU stores each recall file, indexes searchable segments, and makes the complete file retrievable by every connected host using the same backend and scope.

Install memU

How Markdown Fits the Architecture

Agent-Prepared Files

The agent creates or patches Markdown during a prepared memory job instead of sending raw conversations to a hidden extraction pipeline.

Memory and Skill Tracks

Recall files identify whether they contain durable memory or a reusable skill while keeping the same readable file shape.

Database-Backed

SQLite, Postgres, or memU Cloud stores the committed file content and indexing data; Markdown is the agent-facing artifact.

Searchable Segments

Text slices receive embeddings for retrieval, then matching slices roll up to the complete recall file.

The File Lifecycle

List Existing Files

The agent can inspect paginated recall files across both memory and skill tracks before deciding what to change.

Prepare Locally

A scheduled job supplies session context and relevant paths so the host agent can work with ordinary Markdown.

Commit Explicitly

Only files the agent leaves changed are submitted through the commit operation and indexed.

Retrieve by Meaning

A future query ranks segments by embedding similarity and returns their complete files.

Reuse Across Hosts

Any configured host can consume the same readable file when it uses the shared backend and scope.

Why Keep Memory Readable

Transparency and Trust

The durable guidance an agent may retrieve is visible as text, not only as opaque vectors.

Debuggable and Auditable

Inspect the file name, description, content, track, and searchable segments when retrieval behaves unexpectedly.

Host-Agnostic

Markdown can be consumed by different agent hosts while their adapters share one storage and retrieval layer.

Semantic Retrieval

Embeddings make relevant file segments searchable even when a future query uses different wording.

Clear Responsibility

The agent owns meaning and editing; memU owns persistence, indexing, and retrieval.

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.

Explore Agent-Driven Memory

Readable Markdown

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

Now Here

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.

Make Agent Memory Inspectable

Let agents prepare readable Markdown while memU keeps it durable, searchable, and shared.

Install memU