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

One Memory Backend Across Multiple Agents

Share when scopes match; separate records when scopes differ.

Every memU operation uses explicit user and agent scope fields. Configure Codex, Claude Code, Cursor, OpenClaw, Hermes, WorkBuddy, or a generic host adapter against the same backend and scope so memory learned in one host can be retrieved in another.

Connect Your Agents
User models and context illustration

How Scope Works

Explicit Fields
The current scope model is based on user_id and agent_id rather than inferred roles or character names.
Validated Filters
List, retrieve, and commit operations validate scope fields before reading or writing records.
Scoped Identity
Recall file identity is unique inside its configured scope, so the same file name can be used in another scope.
Shared Configuration
Host adapters read the same ~/.memu/config.env and can point to one Cloud, SQLite, or Postgres backend.
Deliberate Sharing
Use matching scope values for cross-host recall or different values when workflows need separate memory contexts.

A Cross-Agent Setup

1. Choose a Backend
Use memU Cloud for managed cross-device memory or configure a local SQLite or Postgres store.
2. Install the First Host
Give the installation skill to the agent. It configures that host's record and inject seams.
3. Add More Hosts
Run the same skill in another supported agent and connect it to the same backend and intended scope.
4. Record Experience
Each adapter captures its own host sessions and lets that host agent prepare useful memory or skills.
5. Retrieve Anywhere
A connected host retrieves relevant recall files from the shared scope before a future task.

Common Scope Patterns

One User, Many Coding Agents
Share project preferences and reusable skills between Codex, Claude Code, Cursor, and other connected hosts.
Separate Work Contexts
Use different agent scope values when two workflows should not retrieve each other's recall files.
Local Personal Memory
Keep a single user's agent memory in a local SQLite database shared by desktop host adapters.
Managed Cross-Device Memory
Use memU Cloud when configured agents on different devices need access to the same scope.

Important Scope Boundaries

Scope Is Explicit
Sharing behavior depends on the user_id and agent_id values supplied by the configured host.
Scope Is Not a Folder Layout
memU stores scoped database records; it does not promise a physical agent_id/user_id/category.md directory.
Scope Is Validated
Unsupported filter fields are rejected instead of being silently ignored.
Backend Security Still Matters
Deployment authentication, database access, and infrastructure controls remain part of the Cloud or self-hosted environment.
Sharing Must Be Intentional
Connect hosts to the same scope only when they should retrieve the same memory and skills.

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.

Now Here
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.

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.

Connect More Than One Agent to the Same Memory

Choose the intended scope, configure one shared backend, and install the appropriate host adapter in each agent.

Connect Your Agents