Skip to main content
ReMe is a local-first memory layer for AI agents. It turns conversations and resources into file-based long-term memory, then keeps that memory indexed, linked, and refined for future recall. Users can inspect, correct, and carry the result across agents and sessions. The following diagram summarizes ReMe’s file-native approach to shared, portable memory: ReMe design philosophy

Start in 5 Minutes

Install ReMe and complete a verifiable write, search, and read loop.

Explore the Concepts

Understand the principles and trade-offs behind file-native memory.

Choose an Integration

Embed ReMe in Python, connect a supported agent, or choose a service interface.

​
Core Ideas

  • Memory as File: memory is a user-owned file, not hidden database state.
  • Memory from Experience: long-term memory is refined and corrected, not an endless context dump.
  • Human-Agent Shared Memory: people and agents work on the same visible, portable Markdown.
  • Connected and Traceable: links provide context and trace durable conclusions back to sources.
Read the core concepts for the full philosophy and trade-offs.

​
What ReMe Solves

Agent context usually disappears when a session ends. Even with a vector database, users may not know what was remembered, where a conclusion came from, or how to correct and move that memory. ReMe provides a complete memory loop in a local workspace without hiding the source data:
  • Capture: raw conversations and resources remain available as traceable sources.
  • Refine: useful facts, preferences, procedures, and knowledge evolve into Markdown memory.
  • Retrieve: BM25 and wikilinks work by default; embeddings add optional semantic recall.
  • Integrate: Python, AgentScope, MCP, CLI, HTTP, plugins, and Skills expose the same file-native memory model; keep one runtime owner per workspace.
Memory becomes shared knowledge owned by the user instead of opaque agent state.

​
Where It Fits

  • Personal assistants that retain preferences, background, plans, and important events.
  • Coding agents that carry project decisions, conventions, and debugging experience across sessions.
  • Personal knowledge bases built from conversations, notes, and linked resources.
  • Experience-driven agents that preserve reusable procedures and lessons learned.
ReMe may need another system alongside it when you need strict transactions, complex authorization, or very large-scale online retrieval. It is a memory layer—not a complete agent product—and deliberately avoids invisible, unbounded collection.

​
File-Native Memory System

ReMe separates raw evidence, intermediate refinement, durable memory, and derived system state. The following flow shows how memory moves through those layers:
The workspace maps the flow to these top-level directories: Auto Memory, Auto Resource, and Auto Dream currently drive refinement. BM25, optional embeddings, and wikilinks support retrieval and relationship expansion. These mechanisms can evolve; the durable promise is that sources remain traceable, memory remains correctable, and the result stays in user-accessible files.

​
Offline Use

File operations, keyword search, and wikilink traversal do not require an LLM. Conversation refinement, resource interpretation, and long-term consolidation need a compatible LLM. Semantic search additionally needs an embedding service.

​
Choose an Integration

Python

Embed ReMe directly or use AgentScope’s first-party ReMeMiddleware.

Agents

Connect service-based agents such as Claude Code or QwenPaw.

Integration

Connect through MCP, a Skill, the CLI, or HTTP.

​
Research

ReMe’s experience-driven memory direction is described in Remember Me, Refine Me: A Dynamic Procedural Memory Framework for Experience-Driven Agent Evolution, accepted to Findings of ACL 2026.

​
More

Reference

Workspace, configuration, and self-describing interfaces.

FAQ

Common questions and troubleshooting.

Contribution

Development setup, tests, and contribution flow.