ReMe: Markdown Memory for AI Agents, Reviewed

The problem ReMe targets: agent memory that outlives the context window

Most agent frameworks keep memory inside the process: a vector store, a summary buffer, or a session table owned by the application. That works until you want to read what the agent believes, correct it, or move it to another agent runtime. ReMe takes the opposite position. The README describes it as "a local-first, self-evolving personal knowledge base for AI agents," and the durable artifact is a Markdown file with frontmatter and wikilinks. The index is derived and rebuildable; the files are the source of truth.

The audience is narrow but real. It fits engineers running assistants, coding agents, or research agents on their own machine or their own server, who want the memory to be diffable in git and editable in an editor. It also fits anyone who has tried to migrate a vector database between providers and discovered that the embeddings and the metadata were the only thing they actually owned. ReMe's answer is that the ownership boundary sits at the filesystem, not at the API.

Memory as file: the Markdown, frontmatter and wikilink model

A ReMe memory node is a Markdown document with a name, a description, and a body. The quick-start example writes a node at path digest/wiki/quick-start-demo with a heading and a line reading Related: [[digest/wiki/memory-as-file.md]]. Those double-bracket links are the graph edges. The README calls the approach "Memory as File, File as Memory" and states that indexes and generated metadata remain rebuildable, which is the important design claim: if the index is lost, the corpus is not.

Retrieval is described as line-level rather than document-level. The README states that BM25, optional embeddings, and wikilink expansion retrieve relevant line-level passages and their relationships without loading the entire knowledge base into the agent context. That combination matters for cost. Wikilink expansion means a hit can pull in a linked node, so the graph does work that a pure vector search would have to approximate through similarity. The trade-off is that link quality becomes your problem. A corpus with sparse or stale wikilinks degrades the expansion step, and the README does not describe any automatic link repair.

Installing ReMe and writing your first memory node

ReMe requires Python 3.11 or newer. The README gives a pip install for the core extra, which is the shortest path to a working service.

pip install "reme-ai[core]"

Installing from source is a longer path. It clones the repository, installs the reme_studio package in editable mode alongside the core extra, then builds the Studio static assets with npm. The README states that the static build requires Node.js 22.13 or newer.

git clone https://github.com/agentscope-ai/ReMe.git
cd ReMe
pip install -e reme_studio -e ".[core]"
cd reme_studio
npm ci
npm run build:static
cd ..

Before starting the service, create a .env file. The README marks LLM_API_KEY and LLM_BASE_URL as required for auto_memory, auto_resource, auto_dream and proactive refresh, and marks the embedding variables as optional and only used after embedding components are enabled in the config.

cat > .env <<'EOF'
# Optional: used only after embedding components are explicitly enabled in the config.
# EMBEDDING_API_KEY=sk-xxx
# EMBEDDING_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1

# Required for auto_memory, auto_resource, auto_dream, and proactive refresh.
LLM_API_KEY=sk-xxx
LLM_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
EOF

Start the service with reme start. The default address is 127.0.0.1:2333, and the README shows how to move it if the port is taken.

reme start
reme start service.port=8181
reme start workspace_dir=/tmp/reme-demo service.port=8181

The README also lists reme version, reme health_check and reme help, plus a curl call against the /version endpoint that posts an empty JSON object. For a first real use, write a node, search for it, then read it back.

reme write \
  path=digest/wiki/quick-start-demo \
  name="Quick Start Demo" \
  description="A first ReMe memory node" \
  content="# Quick Start Demo

ReMe stores agent memory as readable Markdown.

Related: [[digest/wiki/memory-as-file.md]]"

reme search query="agent memory markdown" limit=5

After the write, the search should return the node you just created. If it does not, the first thing to check is whether the service is still running on the port you started it on, because the CLI and the service are separate processes.

Embeddings are off by default, and that is a deliberate cost choice

The README is explicit that embeddings are disabled by default, so the default setup does not start an embedding model or require an embedding API key. To turn semantic retrieval on, you uncomment components.as_embedding and components.embedding_store in reme/config/default.yaml, then change components.file_store.default.embedding_store from an empty string to default. The memory search guide in docs/en/memory_search.md is cited for details.

This is the right default for a local-first tool, and it is also a limitation worth naming. Without embeddings, recall depends on lexical overlap between the query and the stored text. A user who asks about "my editor setup" will not match a node that only says "neovim config" unless a wikilink or a shared token bridges the gap. Turning embeddings on adds an API dependency and a vector index to maintain, and the README does not describe what happens to the index when you edit a file outside the service. If you plan to edit memory files by hand, and the whole premise is that you can, you should confirm the reindexing behavior against docs/en/memory_search.md before you rely on it.

Running ReMe across more than one agent runtime

The README states that personal assistants, coding agents, and other agent runtimes can share the same local workspace through native integrations, SKILL.md, CLI, HTTP, MCP, or Python APIs. That is a wide surface. The npm package @agentscope-ai/reme, published in 2026.08, provides native integrations for DeepSeek Harness and OpenClaw plus a shared TypeScript HTTP client, according to the release notes in the README.

The practical consequence is that the memory workspace becomes a shared service rather than a library embedded in one process. That is good for consistency and bad for isolation. Two agents writing to the same node will race, and the README does not document locking or conflict resolution. If you want per-agent memory, you need separate workspace_dir values, which the README demonstrates as a start parameter. The repository also ships a skills/ directory and a plugins/ directory, and the README mentions two optional plugins, Daily Paper for paper discovery and Auto Fin for researching the latest 24 hours of topic-related CLS news with local-memory search and validated historical wikilinks.

How ReMe differs from MemoryScope and from hosted memory services

ReMe is not the first attempt in this repository. The README links previous versions 0.3.x and 0.2.x on separate branches, and a MemoryScope branch. MemoryScope is the earlier lineage, and the project has since moved to the Markdown-file model described here, with the current package at 0.4.1.11. If you find an older tutorial that imports memoryscope, it describes a different architecture than the one in reme/config/default.yaml.

The clearer comparison is against hosted memory services. A service like Mem0 exposes memory as an API you call; you get managed storage and retrieval, and you give up direct file access. ReMe inverts that. You own the files, you run the process, and you carry the operational burden: the port, the API keys, the embedding configuration, the reindexing. The payoff is that the corpus is portable and auditable. For a personal knowledge base that a single engineer maintains, that trade is usually worth it. For a multi-tenant product where memory is a feature rather than an asset, a hosted API removes a class of operational work that ReMe pushes onto you.

Licence, releases and what maintenance costs look like

ReMe is Apache-2.0, both in the repository LICENSE file and in the pyproject.toml metadata, where the license field is set to Apache-2.0 and the author is listed as the EconML team of Alibaba Tongyi Lab. Apache-2.0 includes an explicit patent grant and permits commercial use, modification and redistribution provided you keep the notices. That is a permissive arrangement, but it is not legal advice; if you are embedding the code in a product, read the licence text yourself.

The release cadence visible in the repository is fast. Three releases landed between 2026-08-28 and 2026-09-01, and the last push to the default branch was on 2026-09-10. Fast releases on a 0.4.x line mean the API surface is still moving, and the pyproject classifier says Development Status :: 4 - Beta. The upgrade cost is therefore not zero: pin the version, read the release notes before bumping, and expect configuration keys in reme/config/default.yaml to change between minor versions. The dependency list is also substantial. The core extra pulls in faiss-cpu, zvec, jieba, rjieba, neo4j, networkx, polars, claude-agent-sdk, dingtalk-stream, openai-codex and a proxy package. If your environment is size-constrained, install the base reme-ai package and add extras selectively rather than taking core wholesale.

Editorial conclusion

Adopt ReMe if you want durable agent memory stored as inspectable Markdown you can edit, move and back up with ordinary tools, and if you are willing to run the service yourself. Skip it if you need a hosted memory API with an uptime commitment, or if you cannot accept that the retrieval quality ceiling is set by your own chunking and link hygiene. Before committing, verify three things: that Python 3.11+ is available in your runtime, that the default 127.0.0.1:2333 port does not collide with anything you already run, and that you are comfortable with the LLM_API_KEY requirement that auto_memory, auto_resource, auto_dream and proactive refresh carry. Basic file operations, BM25 search and wikilink traversal run without LLM credentials, so you can evaluate the storage model before you evaluate the evolution features.

Frequently asked questions

Official sources

1. agentscope-ai/ReMe on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases