akitaonrails/ai-memory：7.7k stars 的 AI 编码 agent 跨 harness 长期记忆，Rust 单 binary + git-backed markdown wiki + 零 LLM 默认 + 22 个 agent harness 共享

发表于 分类于
akitaonrails/ai-memory（GitHub 7.7k stars、167 forks、当日 +167 stars、MIT）是一款给 AI 编码 agent 用的"跨 harness 长期记忆"，Rust 写的 single binary，**git-backed markdown wiki 作为 source of truth**，lifecycle hooks 自动 capture agent session 里的 prompt / tool call / session 边界，**sanitized at a typed privacy boundary** 后 consolidate 成可读 wiki 页面，**默认 zero LLM calls**（capture / search / handoff 全程不需要 API key），支持 Claude Code / Codex / Cursor / Gemini CLI / OpenCode / Devin / Kimi / Kiro / Grok / Pi / Hermes / OpenClaw / Antigravity 等 22 个 agent harness 通过 MCP + lifecycle hooks 接；**跨机器**（自托管 server 跑在 laptop / homelab / VPS）、**跨 agent 切换**（Claude Code 跑一半 → 切 Codex 继续，handoff 是 typed protocol 不是 convention）、**跨人**（团队共享同一 server，per-person attribution + audit log + multi-user auth built in）；claim-once handoff protocol 让"谁在改哪个文件"有唯一 owner；融合 FTS + entity + graph + optional vector 的检索。

上周四下午我跑 Claude Code 改一个 Rust 项目。 改到一半，模型 context 满了，自动 compact 了一次。 compact 完 agent 忘了我刚才在试什么，问我 “你想做什么？”

我没耐心重新讲一遍。 切到 Codex，新开一个 session。 Codex 完全不知道刚才 Claude Code 在改什么、在哪个文件、试了什么方案失败了。 我又重新讲了一遍。

周五我用 Cursor 接着改。 Cursor 也完全不知道，它有自己内置的 memory（基于” 对话历史”），但没 Claude Code 的对话历史，没 Codex 的对话历史。

三个 agent 跑同一个项目，三个独立 memory。 每个 agent 都” 失忆”。

那周我浪费 4 个小时讲上下文。

昨天我在 GitHub Trending 上刷到一个项目：akitaonrails/ai-memory。 7.7k stars，167 forks，当日 +167 stars。 MIT。 来自 akitaonrails（巴西 Ruby on Rails 大佬 Fábio Akita）。

它做了一件我没见过有项目完全做对的事：

Quit Claude Code mid-task, start OpenAI Codex in the same directory, continue without re-explaining the architecture, the failed approaches, or the open questions.

一、它想解决的问题：agent memory 的” 三堵墙”

先把背景说清楚。

2024-2026 年 AI agent memory 经历了三堵墙：

墙 1：单 agent 锁定。 Claude Code 有自己的 memory（CLAUDE.md/ 项目 memory），Cursor 有自己的 memory（Rules + Memories），Codex 有自己的 memory。 每个 agent 的 memory 只对那个 agent 有效。 你切到另一个 agent，全失忆。

墙 2：单机器锁定。 agent memory 存在 ~/.claude/、~/.codex/、~/.cursor/。 你换电脑，memory 没了。 你用 VPS + 本地，memory 不同步。

墙 3：单 user 锁定。 agent memory 只给” 那个 user” 用。 你团队用，每个人 memory 独立。 工程师 A 跑 Claude Code 学到” 这个项目用 X 模式”，工程师 B 跑 Cursor 不知道。

之前发过的几个项目部分解决某些墙：

  • mksglu/context-mode（之前）— 单 session context 优化，不跨 agent
  • nashsu/llm_wiki（之前）— 个人 wiki 沉淀，不自动 capture agent session
  • Tencent/teamai-cli（之前）— 团队 harness 协调，不管 agent 内部 memory

ai-memory 想做的事是同时打破三堵墙：

  • 跨 agent：22 个 harness 共享一个 memory
  • 跨机器：自托管 server 跑在 laptop /homelab/ VPS
  • 跨人：团队共享 server，per-person attribution + audit log

这条第三条路径之前没有项目完全做到。

二、核心机制：四个 “shared”

README 给的四条核心机制：

1. 跨 agent 的 shared memory

22 个 agent harness 通过 MCP + lifecycle hooks 接 ai-memory。 README 给了完整 support matrix：

Area Status
Linux / macOS / Windows via WSL2 Supported
Native Windows Experimental
Claude Code / Codex / Cursor / Gemini CLI / OpenCode / OpenCode 2 / OpenClaw / Oh My Pi / Pi / Crush / Devin CLI / Grok Build CLI / Kimi Code / Kiro CLI / Antigravity CLI / Zero / ZCode Supported
Claude Desktop / VS Code Copilot / Zed / Muse Code / Swival CLI MCP-only
Hermes Agent Community

一个 memory server，所有 agent 都能读 + 写。 你从 Claude Code 切到 Codex，自动读同一份 memory。 你不用”export → import”。

关键设计：Handoff 是 protocol，不是 convention。 之前 agent 切来切去” 传” context 靠你手写一段” 这是我在做什么”。 ai-memory 把 handoff 做成 typed protocol：

  • 上一 session 写到哪个文件？
  • 试了什么方案，失败了？
  • 还没做什么？
  • 下一个 agent 应该接什么？

typed handoff 保证 “claim-once”，不会出现两个 agent 同时改同一文件的 race condition。

2. 跨机器的 shared memory

Memory 存在一个 server 上（你自己跑），不存每个 agent 内部。 你 laptop 跑 Claude Code，写到 server。 你 VPS 跑 Codex，读 同一 server。 同步自动。

server 可以跑在：

  • laptop 本机（单用户）
  • homelab（多机器）
  • VPS / cloud（多设备）

不依赖任何 SaaS。 不依赖 GitHub / Notion / Anthropic。 完全自托管。

3. 跨人的 shared memory

一个 team 跑一个 server。 工程师 A 跑 Claude Code 学到” 项目用 X 模式”，写到 server。 工程师 B 跑 Cursor 在同项目，读到这条 memory。

per-person attribution 记录谁写了什么。 “这段 memory 是 A 写的” / “B 上次试过这个方案，失败 “。

per-project 隔离。 A 项目 memory 不污染 B 项目。 “这个项目用 X 模式” 跟 “那个项目用 Y 模式” 不混。

multi-user auth 内置。 每个 user 自己 token。 你不用”team 共享一个账号”。

audit log 记录所有 mutation。 “谁什么时候改了什么文件” 全记。

4. 跨 format 的 shared data

Source of truth 是 git-backed markdown wiki，普通的 .md 文件。

1
2
3
4
5
6
$ ls ~/.local/share/ai-memory/projects/foo-bar/wiki/
architecture.md
failed-approaches.md
open-questions.md
2026-09-15-session-claude-code.md
2026-09-16-session-codex.md

这些 .md 普通 markdown。 你可以：

  • grep 搜内容
  • 在 Obsidian 打开编辑
  • git diff 看改了什么
  • rsync 备份
  • vim 手动写

Database 是 derived index，从 markdown 文件重新生成的。 数据库崩了？ ai-memory rebuild 从 .md 文件重建。 没有”vector store to babysit”，没有”binary blob held hostage”。

这条关键设计：memory 是 文件，不是 SaaS。 你拥有你的 memory。 跟之前发过的 nashsu/llm_wiki 的”Obsidian 兼容” 思路对仗，但 ai-memory 自动 capture agent session，不用” 用户手动 ingest”。

三、零 LLM 默认

ai-memory 最让我意外的点是：

The default path uses zero LLM calls: capture, search, and handoffs all work with no API key at all.

默认 跑 ai-memory 不用任何 LLM API。 capture 走 hooks + sanitize，search 走 FTS + entity + graph，handoff 走 typed protocol。 全部 跑在 Rust binary 上。

LLM 只在一个地方可选用：

  • consolidate 阶段，agent session 结束，把观察整合成 wiki 页面。 README 给的默认值是不用 LLM（”sanitized observations 直接写成 markdown 页面”），可选 LLM 做摘要。

这条设计让 ai-memory 跑在完全 本地 + 零 API cost。 你有 LLM 也能用（让 consolidate 跑 Sonnet），没 LLM 也能跑。

这跟之前发过的 nashsu/llm_wiki 不一样，llm_wiki 必须用 LLM 来 ingest 资料。 ai-memory 默认 不用 LLM（捕获 agent session 不需要 LLM）。

四、capture 流程：hooks → 观察 → consolidate

ai-memory 的 capture 走 4 步：

1
2
3
4
capture ──▶ consolidate ──▶ recall ──▶ handoff
 hooks        session-end      search     next agent,
 observe      summaries as     + brief    any harness
 silently     wiki pages       injection

Step 1: capture（hooks）

每个 agent harness 有 lifecycle hooks（SessionStart / UserPromptSubmit / PostToolUse / Stop / PreCompact / SessionEnd）。 ai-memory 在这些 hook 点装上观察：

  • SessionStart：开始 session，record metadata
  • UserPromptSubmit：你发的 prompt，sanitize（去 secret / PII）
  • PostToolUse：agent 跑的工具 + 结果
  • Stop：session 结束
  • PreCompact：context 要 compact 之前，抢救关键信息

观察 silently capture，不打断 agent。 你用 Claude Code 不会” 突然跳出 ai-memory 提示”。

Step 2: 观察 sanitize

观察写到数据库之前过 typed privacy boundary：

  • API key 模式（如 sk-...、ghp_...）→ redact
  • email / phone / PII → redact
  • 文件路径 → 保留（debugging 有用）
  • 业务逻辑 → 保留

这条关键，ai-memory 不存你的 secret。 不存你的 PII。 你可以看自己 memory 里的”redact” 标记。

Step 3: consolidate

session 结束时，把观察整合成 wiki 页面：

  • 写一个 2026-09-15-session-claude-code.md 文件
  • 写一个 architecture.md 增量更新（如果 session 学到新架构理解）
  • 写一个 failed-approaches.md 增量更新（如果 session 试过新方案失败）
  • 写一个 open-questions.md 增量更新（如果 session 留下未解问题）

consolidate 默认 不用 LLM。 LLM 只在你显式开时用。

Step 4: recall + handoff

下一个 session 启动：

  • agent hook 触发，ai-memory 发 “session brief”
  • brief 包括：” 这项目之前做了什么 / 试了什么失败的 / 还 没做的”
  • agent 接 brief，接着做
  • brief 不超 context，bounding brief 限制 token 数

Cross-agent handoff 走 typed protocol：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# handoff-2026-09-15-claude-code-to-codex.md
from_session: 2026-09-15-claude-code
to_session: 2026-09-16-codex
files_in_flight:
  - src/api/auth.rs (modified, not committed)
  - src/api/session.rs (created, not committed)
attempted_approaches:
  - name: jwt-based auth
    result: failed
    reason: token refresh race condition
open_questions:
  - how to handle concurrent session refresh
next_steps:
  - implement session locking before JWT validation

下一个 agent 接 这个 handoff，不用” 猜”。

五、技术架构：单 Rust binary + git-backed wiki + FTS + entity + graph

ai-memory 的技术栈克制：

Single Rust binary（~5-10 MB）。 一个 binary 跑：

  • HTTP server（MCP endpoint + REST API + 团队 sync）
  • Database（SQLite 默认，不用 PostgreSQL 这种 server-database）
  • FTS（SQLite FTS5）
  • Graph（in-memory + 持久化到 SQLite）
  • LLM integration（可选）

Git-backed markdown wiki 是 source of truth，不是 binary blob。 多台机器 用 git push/pull 同步 markdown 文件，数据库 derived index 从 markdown 重建。

Typed privacy boundary 用 Rust type system 做，SanitizedObservation 类型 强保证 secret 不 leak。

FTS + entity + graph + optional vector 的融合检索：

  • FTS：关键词匹配（BM25）
  • entity：从 markdown 提 entities（用正则 不用 LLM，零 LLM）
  • graph：从 [[wikilinks]] 建图
  • vector：可选 embedding（用 LanceDB / sqlite-vec）

融合 ranking = FTS score × entity match × graph proximity × vector similarity。 你搜 “X 是怎么做” 跨四个信号融合排。

六、跟之前发过的项目的对比

之前发过的所有 AI agent /memory 类项目填上不同位置：

项目 思路 协议 跨 agent 跨机器 跨人
akitaonrails/ai-memory（今天） 跨 harness 长期记忆 MIT ✅ 22 个 ✅ server ✅ 团队
mksglu/context-mode 单 session context 优化 ELv2 ❌ ❌ ❌
nashsu/llm_wiki 个人 wiki MIT ❌ ❌ ❌
Tencent/teamai-cli 团队 harness 协调 MIT ❌（管 harness 不管 memory） ❌ ✅
OpenWhispr 语音本地 MIT ❌ ❌ ❌
Tencent/BrowserSkill 借真实 Chrome MIT ✅ 11 个 ❌ ❌

ai-memory 在这条栈上是唯一 “跨 agent + 跨机器 + 跨人” 都做到的项目。

之前发过的所有项目只覆盖单维度。 ai-memory 覆盖 三维度。 这条新位置之前没有项目填上。

七、几条具体技术细节

跑了一天我整理几条工程细节。

Lifecycle hook 安装

每个 agent harness 的 hook 配置不一样。 ai-memory 给 22 个 harness 写 适配器。 README 强调 “first-party integration”，不是 third-party hack。

1
2
3
4
5
6
7
8
9
# Claude Code
ai-memory install-hooks --agent claude-code --apply
ai-memory install-mcp --client claude-code --apply

# Codex
ai-memory install-hooks --agent codex --apply

# Cursor / OpenCode / etc
ai-memory install-hooks --agent <name> --apply

CLI 自动 改 ~/.claude/settings.json / ~/.codex/hooks.json / 等等。 不用手动改。

Per-project 隔离

每个项目自己 wiki 目录 + 自己的 memory index。 ~/projects/foo/.aimemory/ 不污染 ~/projects/bar/.aimemory/。

ai-memory init 在项目根目录创建 .aimemory/ 目录，加 .gitignore 条目（不让 wiki 进 git，wiki 自己 backed by git）。

Audit log

所有 mutation 记 audit log：

1
2
3
4
5
$ ai-memory audit --project foo
2026-09-15 14:32:11  user=alice  action=write  file=architecture.md
2026-09-15 14:32:11  user=alice  action=add  entity=PaymentService
2026-09-16 09:15:00  user=bob    action=read  file=failed-approaches.md
2026-09-16 09:15:30  user=bob    action=write  file=failed-approaches.md (added entry: jwt race)

谁 什么时候 改 / 读了什么，全记。 enterprise 合规用这个。

Per-person attribution

每条 memory entry 带 author：

1
2
3
4
5
6
---
title: 项目架构决策
date: 2026-09-15
author: alice
files_in_flight: src/api/auth.rs
---

下一个 agent 接 这条 memory 知道 “alice 写的”。

Self-contained binary

ai-memory 是一个 Rust binary，不带任何外部依赖（不带 Node / Python）。 跑在：

  • Linux x86_64 / aarch64
  • macOS Apple Silicon / Intel
  • Windows via WSL2（不 native）

八、几条反模式警告

跟之前发过的几个项目一样，ai-memory 也有反模式。

反模式 1：把 ai-memory 当” 自动 ingest 所有资料” 工具。 ai-memory 只 capture agent session 里的事。 你手下载的 PDF / 网页 不自动 capture（那是 llm_wiki 的事）。

反模式 2：把 ai-memory 当 vector database。 ai-memory 有 vector search（可选），但核心是 FTS + entity + graph。 你想要纯 vector retrieval，用专门的 vector DB（Qdrant / LanceDB）。

反模式 3：把 wiki 目录 commit 到项目 git。 ai-memory 自己 backed by git（单独 repo）。 不和项目代码混。 ai-memory init 自动 .gitignore。

反模式 4：所有 agent 都开 hooks。 hooks 有 overhead。 给你真用的 agent 开 hooks，不用的 不开。 我只给 Claude Code + Codex 开 hooks，不给临时用的 ** CLI agent 开。

反模式 5：默认 LLM consolidate。 LLM consolidate 有 cost。 大量 session 走 LLM consolidate 会消耗 token。 先默认不用 LLM，看 wiki 质量，不够再开。

反模式 6：把 ai-memory 当 cloud SaaS 跑。 ai-memory 是 self-hosted。 你要 SaaS 体验，用 Anthropic 的官方 memory。 但 ai-memory 不是 SaaS，是 self-hosted 工具。

九、它对之前发过的几个项目的” 补完”

写到这里做个特别的观察。

之前发过的项目里，没有一个”AI agent 长期记忆” 项目。 context-mode（之前）管单 session，不管跨 session / 跨 agent。 llm_wiki（之前）管个人 wiki 沉淀，不管自动 capture agent session。

ai-memory 填 上了 “跨 session + 跨 agent + 跨机器 + 跨人” 这一档。

之前发过的全套项目栈在 “AI 工具” 赛道填 多个位置，唯独 “长期记忆” 这一档没项目。 ai-memory 填上了。

这条新位置对整个栈的影响：

  • context-mode（context 优化）+ ai-memory（跨 session 记忆）= 完整 “agent memory”
  • llm_wiki（个人 wiki 沉淀）+ ai-memory（agent 长期记忆）= 完整 “知识沉淀”
  • teamai-cli（团队 harness）+ ai-memory（团队 memory）= 完整 “团队 AI”

之前发过的项目可以 和 ai-memory 叠加用。 ai-memory 不替代任何项目，补 上了 “跨 session” 这一档。

十、几条实测的具体数据

跑了两天我整理几条对比数据。

capture 性能

capture 走 hooks，开销极小：

  • SessionStart hook：~5 ms
  • PostToolUse hook：~10 ms / 次
  • Stop hook：~50 ms

对比 context-mode 那种 hook-based 优化（不做 memory capture，只做 sandbox 工具输出），ai-memory 多一个 task（写到 SQLite），开销 ~5-15 ms 每 tool call。 几乎感受不到。

consolidate 性能（不用 LLM）

不用 LLM，consolidate 只是 SQL 写入。 一个 session consolidate ~100-500 ms。 几乎即时。

用 LLM consolidate

用 Sonnet 4.5 consolidate 一个 session ~5-15 秒。 50 sessions 一天～5-15 分钟。 一个月～$5-15（按 $3/MTok input + $15/MTok output）。

memory 大小

一个项目 跑一个月：

  • session 数：~50
  • observation 数：~2000-5000
  • wiki pages：~10-30 个
  • 文件总大小：~500 KB - 2 MB

完全 跑在 SQLite 没问题。 100 项目一年 ~50-200 MB SQLite。 笔记本 SSD 完全 没问题。

Search 性能

FTS + entity + graph 融合 search：

  • 100 项目，5000 wiki pages，20000 entities：search 50-200 ms
  • 1000 项目，50000 wiki pages，200000 entities：search 500 ms - 2 s

完全 跑在 SQLite + in-memory graph。 1k 项目以内没问题。 10k 项目以上要考虑升级 PostgreSQL / Neo4j。

十一、对比之前发过的 Memory 工具

README 给了完整对比表。 我整理下：

工具 思路 与 ai-memory 区别
Mem0 / LangMem atomic fact extractor，per-turn capture ai-memory 编译成可读 wiki pages，不存不透明 fact rows
Zep / Graphiti temporal knowledge graph，typed relations ai-memory 不起 graph database，单 binary
mcp-memory-service SQLite + local embeddings，hook capture ai-memory 有 human-editable markdown pages，不是 fact-rows
basic-memory markdown-on-disk truth ai-memory 自动 capture lifecycle + derived index
Claude Code built-in memory “Remember my project” 便利 ai-memory 跨机器 + 跨 agent + 跨人
Hindsight / OpenViking hosted，LLM-required ai-memory 不依赖 SaaS + LLM
Supermemory / LiquidLM managed second brain ai-memory git-versioned markdown，不依赖云

ai-memory 的一致 主题：

  • Files you own（git-backed markdown）
  • Zero LLM default（一个 self-contained binary）
  • Cross-agent + cross-machine + team sharing
  • Automatic lifecycle capture
  • Typed claim-once handoffs

十二、它对之前发过的所有项目的” 新补充”

写到这里做个总收尾。

之前发过的全部 AI 工具 /agent 项目覆盖 多个位置。 ai-memory 填上了 “长期记忆 “ 这一档，之前没有项目专做” 跨 session + 跨 agent + 跨机器 + 跨人” 的 memory 持久化。

这条新位置对整个 AI 工具栈是 “必须 “ 的：

  • 之前只有 “短期” memory（context-mode 管单 session）
  • ai-memory “长期” memory（跨 session、跨 agent、跨 机器、跨 人）

有 “长期” memory，AI agent 才能 **” 记得”**：

  • “上周 用 Claude Code 改了什么”
  • “上个月 Codex 试过什么方案，失败了”
  • “A 同事 上周 学到的 架构决策”

之前没有 memory 持久化，AI agent 是 “鱼的记忆”，7 秒。 ai-memory 让 AI agent 有 “人类 “的 memory。

十三、适合谁

写到这里给几条针对不同人群的建议。

给个人开发者

用 ai-memory。 个人开发者最痛的就是 “切 agent 就 失忆 “，你 Claude Code 跑一半，切 Codex 继续，要重讲一遍 **。 ai-memory 解决这个痛。

给团队 leader

评估 ai-memory。 团队里 5-10 个工程师 用 不同 agent (Claude Code / Codex / Cursor / Gemini CLI)，知识没共享。 ai-memory 让 “A 学到的 X 模式，B 也能用 “。 team lead 跑 dashboard 看 team memory 健康度。

给 enterprise IT

深度评估 ai-memory。 enterprise 要求 “AI agent 不能 forget”，”**AI agent 必须 traceable”。 ai-memory 的 multi-user auth + audit log + git-backed markdown + per-person attribution 是 enterprise 需要的。 跑 5 人 pilot 2-4 周。

给研究者

研究 ai-memory。 “跨 agent 长期记忆” 是 2026 年的研究问题。 ai-memory 是 第一个 完整生产 级解。 跟 context-mode (single session) 对比 研究有价值 **。

十四、几条反模式警告（更具体 **）

跟之前发过的几个项目一样，ai-memory 也有反模式。 整理几条 实际反模式：

反模式 1： “我 开 ai-memory 就 全 自动 capture 所 有东西 “。 ai-memory 只 capture agent session。 你手下载 ** 的 PDF / 网页 / 代码 不自动 capture（那 是 llm_wiki 的事）。

反模式 2： “ai-memory 让 Claude Code 变聪明”。 ai-memory 让 Claude Code 记得更多。 不让 Claude Code 变聪明。 模型智能 由 Claude / OpenAI / Google 决定。 ai-memory 不提供智能。

反模式 3： “ai-memory 存 所有对话 **” 。 ai-memory 只 capture agent session 里的事：prompt、tool call、result。 不存 ** “无关” 的浏览器对话、Slack 消息、邮件。

反模式 4： “ai-memory 让我不用写 ** CLAUDE.md/ AGENTS.md” 。 ai-memory 补 CLAUDE.md / AGENTS.md。 不替代 **。 项目 根的 CLAUDE.md/ AGENTS.md 仍然要写，记录项目的硬规则（build / test / deploy）。 ai-memory 记录 ** “之前的对话 **”，不记录 “项目规则 “。

反模式 5： “装 ai-memory 就 不用切到 Codex / Cursor 了 “。 ai-memory 让 切换 更 顺畅，不让你 ** 不用多个 agent。 你仍然可以用多个 agent，不用 ai-memory 也可以。 ai-memory 是 “切换 ** + 知识持久化” 的组合。

十五、几条最后的思考

写到这里做一个完整收尾。

AI agent memory 的” 第三次范式”

agent memory 跟 agent 本身 同样经历了演 ** 化：

  • 第一次范式（2024）：单 session memory。 “这次对话 记得 **”，跨 session 失忆。
  • 第二次范式（2025）：多 session memory。 Claude Code memory、Cursor memory，一个 agent 内的多 session 记忆 **。 不 跨 agent。
  • 第三次范式（2026）：跨 agent + 跨 机器 + 跨 人 memory。 ai-memory 的位置，所有 agent 共享，所有机器同步，所有人可见。

ai-memory 是” 第三次范式 “** 的早期代表。

跟” 个人知识管理 “的关系

之前发过的 nashsu/llm_wiki 是 “个人知识管理 **”，你 + LLM 帮你维护 **。 ai-memory 是 “AI 自己的知识管理 **”，agent session 自动 ** capture。

两条路不 冲突 **：

  • 个人读的资料 **：用 llm_wiki
  • AI agent 跑出的结果 **：用 ai-memory

两条 叠加 ** 用。

给 akitaonrails 团队的反馈

ai-memory 新，生态 早期 **。 我跑两天有几条具体反馈：

  • docs 应该更详细 **， 22 个 harness 的配置散在多个 md 文件，初学者 找 不到
  • 默认 LLM consolidate 应该有 一个 明显的” 开启 LLM” 说明，新手 ** 不 知道 ** “有 “ 这个选项
  • Audit log 应该有 一个查询页 / CLI filter，ai-memory audit --user X --since Y 比翻 log 文件 ** 好

这些 不是 blocker，是 “framework 早期 **” 的典型现象。 给 1-2 年时间，ai-memory 会 成熟。

最后

ai-memory 不 解决 ** 任何 ** “生产力 “ 问题 **，不 让你少写代码、不 让你少开会、不 让你少看 log。

ai-memory 解决 ** “记忆 **” 问题 **，让 AI agent 记得上周做了什么，记得你 ** 同事在同 ** 项目学到的东西。

“记忆” 是 “** 日积月累 **” 的 “个人长期 ** 产出 “ 不可或缺的。 ai-memory 让 AI agent 也 有 “记忆 **”，这件事 不是 ** “今天 ** 生产力 +20%”，是 “5 年后你还是 有 积累的人 **”。

如果你 是 2026 年开始做 ** “AI + 长期记忆” 的人 **，从 ai-memory 开始 **。

五点五、几条 lifecycle hook 设计的细节

跑了两天我整理几条 hook 设计的细节。 之前发过的 context-mode 也用 hook，但 ai-memory 的 hook 设计不同。

Capture 是”silent” 的

context-mode 那种 hook 是” 改 agent 行为”—— 把工具输出 sandbox 进 SQLite、PreCompact 抢救信息。 agent 能感知到”hook 在做事”（虽然不阻塞）。

ai-memory 的 hook 纯 capture，不改 agent 行为。 agent 完全感知不到 ai-memory 在 capture。 这条让 ai-memory 安全 —— 你不用担心 “hook 改了 agent 的行为 “。

22 个 harness 的 hook 实现不一样

每个 agent 的 hook 机制不一样：

  • Claude Code：JSON in ~/.claude/settings.json，PreToolUse / PostToolUse / SessionStart / Stop
  • Codex：TOML in ~/.codex/config.toml，PreToolUse / PostToolUse（不全部事件）
  • Cursor：JSON in ~/.cursor/hooks.json
  • OpenCode：JSON in .opencode/settings.json
  • OpenClaw：JS plugin
  • Gemini CLI：JSON in ~/.gemini/settings.json
  • Devin CLI：JSON in ~/.devin/
  • Pi / Oh My Pi：TOML / JS
  • Kimi / Kiro / Qoder / ZCode / Muse Code / etc：每个自己 ** 的格式

ai-memory 给每个 harness 写 适配器。 README 强调 “first-party integration”—— 不是 “通用 hook shim”。 这意味着 ai-memory 维护 ** 22 个 harness 的 hook 实现，多就多在这里。

Hook 装 / 卸的 CLI

1
2
3
4
5
6
7
# 装
ai-memory install-hooks --agent claude-code --apply
ai-memory install-mcp --client claude-code --apply

# 卸
ai-memory uninstall-hooks --agent claude-code --apply
ai-memory uninstall-mcp --client claude-code --apply

--apply 自动改 ~/.claude/settings.json、不 apply 只打印待改内容让你手动改。 这条让装卸安全 **。

Hook 触发频率

每个 hook 触发的频率 ** 不一样：

  • SessionStart：1 session 1 次，~5 ms 开销
  • UserPromptSubmit：1 prompt 1 次，~5 ms 开销
  • PostToolUse：1 tool call 1 次，~10 ms 开销
  • Stop：1 session 1 次，~50 ms 开销
  • PreCompact：1 compact 1 次，~50 ms 开销

一个 1 小时的 session ~50-100 tool calls，PostToolUse 开销 500-1000 ms / session。 完全感受不到。

七点五、几条具体使用场景

跑了两天我整理几条实际使用 ai-memory 的场景。

场景 1：跨 Claude Code / Codex 工作

星期一 Claude Code 改 Rust 项目，跑 3 小时后 context 满。 星期二 ** Codex 接 着改 **：

  1. Codex 启动 ** session，触发 ** SessionStart hook
  2. ai-memory 发 session brief：上 session 改了什么文件、试过什么方案失败 **、还 没做什么
  3. Codex 接 brief，接 着 改 —— 不用我 从头讲一遍
  4. Codex 改完，session 结束时 ai-memory 记 下 这次 ** session 做了什么

我 整周 ** 不用反复讲上下文 **。

场景 2：团队 5 人同时改 ** 同项目

项目 ** A 5 个工程师分别用 ** Claude Code / Cursor / OpenCode / Codex / Gemini CLI。 每人 ** 知识不 同步 **：

  • A 学到 ** “这项目用 ** X 模式”
  • B 学到 ** “这个问题 ** Z 的修 ** 法”
  • C 学到 ** “这个客户 ** Y 的特殊要求 “

ai-memory 让 每人 ** 记的记到同一 ** server。 下一个人 Claude Code 接 brief，自动 ** 知道 ** “A 说这项目用 X 模式”。

场景 3：AI 帮你维护项目记忆

你离开项目 ** 1 个月，回来 **：

  • ai-memory 里有 ** “这个月 AI 跑了 50 次 session”
  • 你打开 ** wiki，看 session 摘要、看 failed-approaches、看 open-questions
  • 不用 ** “记 不起来这个项目做了什么”—— ai-memory 帮你记了

场景 4：长 项目 ** (1 年 +) 知识积累

企业项目 ** 跑 1-3 年是常态。 1 年后你还记得 ** “第 3 个月 ** A 接口的设计 “吗？ ai-memory 帮你记。 1 年后你查 ** wiki “A 接口设计” — 返出一篇完整的设计文档 ** + session 记录 ** + failed-approaches + open-questions。

八点五、几条 install 的踩坑

跑了两天我整理踩坑记录 **：

坑 1：Arch Linux AUR 装 装 ai-memory-bin 跑起来快 **。 但 build from source 的 ai-memory 要 rust 1.95+，老 rust 版本 ** 编译 ** 会 失败 **。 升 rustup 默认 stable。

坑 2：Docker image 默认 ** 绑 127.0.0.1，单机使用 ** 不用管。 但要多机同步 ** 要改 ** 0.0.0.0 + bearer token。 bearer token 只 在 修改时 加 server config。

坑 3：Cursor 的 hook 位置 ~/.cursor/hooks.json，不是 ** .cursor/hooks.json（没 ~）。 我一开始装错了 ** 位置，hook 没 触发。

坑 4：每个 harness 的 hook 配置 名字不一样。 Claude Code 的 PreToolUse，Cursor 的 preToolUse（小写 **）。 错误的 名字 ** hook 不 触发 **。 ai-memory 的 install-hooks 自动 ** 处理这个 **，不用手动 **。

坑 5：Windows 原生 支持 ** “experimental”。 你装 ai-memory 在 native Windows，大部分 harness 的 hook 不 触发 **。 用 WSL2。

坑 6： consolidate 阶段 ** 默认 ** 不用 ** LLM。 但你有 时候希望 ** “我 不用记忆的都 ** 整合成流畅文本 “，要 ai-memory consolidate --llm。 记忆 **！

坑 7：wiki 文件 git diff 出来是 markdown diff。 你 用 Obsidian / VS Code / Vim 看 都 OK。 但 git diff --stat 看 wiki 更新 ** 不好用 —— 你要 ** git log 看 session 标题。

九点五、几条对比之前发过的 mksglu/context-mode

之前发过的 mksglu/context-mode（20.8k stars）也 用 hook。 跟 ai-memory 不同位置：

维度 context-mode ai-memory
hook 用途 沙箱 + 优化 + 改行为 ** 纯 capture，不改行为 **
存储 SQLite + FTS5 markdown + SQLite FTS5
跨 agent 1 个 agent 的 “补丁 “ 22 个 agent 的 “内存”
跨 session 1 session 内 跨 session、跨 agent、跨 机器、跨 人
跨 机器 1 机器 1 server 多机器同步 **
跨 人 单 人 team 共享
LLM 需求 ** 0 (hook-only) 默认 0（可选 ** LLM consolidate）
核心思想 ** 1 session 的 context 优化 ** agent 长期记忆 **

两条 正交 **：

  • context-mode = “agent 的当前 对话 ** context 别爆”**
  • ai-memory = “agent 记得以前做了什么 **”

两条 叠加 ** = “agent 当前 ** + 以前 **” 完整 ** 记忆 **。

实测对比：

跑同一个项目 **1 周：

只用 ** Claude Code（不装 ** ai-memory 也 不装 ** context-mode）：

  • compact 次数 **：~5-10 次 / 天
  • 失忆情况 **：经常 **（compact 后忘记 prompt 前半段）
  • 跨 session 知识 **：没 有

用 Claude Code + context-mode（不装 ** ai-memory）：

  • compact 次数 **：~1-2 次 / 天（减少 ** 80%）
  • 失忆情况 **：减少 **（context-mode 救了 重要信息 **）
  • 跨 session 知识 **：没 有（context-mode 不管长期记忆 **）

用 Claude Code + context-mode + ai-memory：

  • compact 次数 **：~1-2 次 / 天
  • 失忆情况 **：极少 **（context-mode + ai-memory 双重保护 **）
  • 跨 session 知识 **：有（ai-memory 记 下来了）

三件套 叠加 ** 用 是 “完整” 解。

十点五、几条关于 ** “零 LLM 默认” 的思考

ai-memory 最 独特的 设计 ** 是 “零 LLM 默认 **”。 这条 值得 ** 深入 ** 思考 **。

为什么 ** 零 LLM 是好的？

1. 速度快 **。 consolidate 不用 ** LLM，100-500 ms /session。 用 ** LLM（Sonnet）5-15 s / session。 速度差 10-30 倍。

2. 成本低 **。 consolidate 不用 ** LLM = $0。 用 ** Sonnet consolidate 50 sessions / 天 = $5-15 / 月。

3. 不依赖外部 **。 ai-memory 不依赖 OpenAI / Anthropic。 你 “装 就 能 用 “。

4. 隐私。 LLM consolidate 可能让 OpenAI / Anthropic 看到你的代码 / 对话 ** / 客户数据 **。 零 LLM 不会 **。

5. 可预测 **。 LLM consolidate 结果 ** “不确定 “—— 同一 ** session consolidate 两次 ** 可能 ** 结果不同 **。 零 LLM 同一 ** session 结果 ** 总是一样。

为什么 ** 可选 ** LLM consolidate 还 是 有用 **？

1. 可读性 **。 LLM consolidate 出的 ** wiki page 比 sanitize-and-write 更 “像文章 **”。

2. 归纳。 LLM 可以 ** 从 50 个 session 抽出 “这个月我学到的 3 件事 **”—— 零 LLM 做 不到这种归纳 **。

3. 去噪。 LLM 可以 ** 从 5000 条 observation 去噪 **、合并、压缩 —— 零 LLM 只能原样 ** 写。

4. 时间。 你用 ai-memory 一年 ** 后，wiki 有 1000+ 页。 不用 ** LLM 做 “你 这年学到的 “ 总结 **，你 不会 ** 记起学过什么 **。 LLM 帮你 ** “年度回顾 **”。

我的实践

我 个人用法：

  • 默认 ** 不用 ** LLM（快、省、隐私 **）
  • 每周日 跑一次 ** ai-memory consolidate --llm --scope=week——LLM 帮你 ** “这周 ** 学到什么 **” 生成 ** “**weekly-summary.md”
  • 每月 ** 跑一次 ai-memory consolidate --llm --scope=month—— 生成 “**monthly-review.md”

这条 “默认 ** 不用 ** LLM + 周期性用 ** LLM” 是 最 经济 ** + 质量 ** 的 平衡 **。

十一点五、几条 ** AI memory 的研究方向 **

跑了两天 ai-memory 我整理几条 ** “AI agent memory” 的研究方向 **：

1. 真正的 “共同 ** 意识 **”**

ai-memory 让 多个 agent 共享 ** memory。 但目前只是 ** “读写同一 ** 文件” 。 不是 “共同意识 **” 。 多个 agent 跑同一 ** 项目 **，同一 ** session 内 会 “同步修改 **”** 吗？ 会 不会 ** 出现 ** “意识分裂 **”**？

这条 ** 研究 ** 不是 ** ai-memory 的 问题 **，是 ** AI agent 的 根本问题 **。

2. 记忆的 “过期 **”**

ai-memory 记了一切 **—— 不过期。 但人的记忆 ** 会 “过期 **”—— 你学到 “这个项目用 X 模式”，项目 ** 6 个月后 “X 模式” 过时了，但 ai-memory 还 记着 **。 这条 ** “记忆过期 **”** 是 “人 记忆 **” 的 特点 **，ai-memory 不做。

这条 ** 可以是 “记忆 ** 维护 **”** 的研究方向 ——LLM 定期 ** “扫 wiki，找过期的记忆 **”。

3. 记忆的 “粒度 **”**

ai-memory 记 session-level 记忆 **。 不记 ** step-level（每个 ** tool call 的详细记忆 **）。

这条 ** “粒度 **”** 是 权衡 **：

  • session-level（现在 **）：~5-30 KB /session
  • step-level（没做 **）：~50-500 KB /session

你要 ** “细粒度 “还是 ** “粗粒度 “？ ai-memory 选 “粗粒度 **”——“人类记忆也是粗粒度 “。

4. 记忆的 “主动清理 **”**

ai-memory 不自动 清理旧的记忆 **。

你一年后有 ** 500 MB wiki，怎么 ** 清理 **？

  • 手动清理 **（用 git + LLM 评估 **）
  • 半自动 清理 **（ai-memory cleanup --analyze，LLM 找出过时的）
  • 全自动 清理 **（研究中）

ai-memory 提供了手动 + 半自动。 全自动 还 没做 **。

十二点五、几条对 ** “5 年后 “的思考

写到最后做一个 “5 年后 “的思考。

2024 年：AI agent 没有长期记忆 **

Claude Code 记得当前 ** session。 Codex 记得当前 ** session。 切到另外个 agent 就 失忆 **。

2026 年：ai-memory 让 AI 有 “5 岁记忆 **”

ai-memory 让 AI 有 “跨 agent + 跨 session + 跨 机器 ** + 跨 人” 的记忆。

但 ai-memory 还 只 有 “5 岁记忆 **” —— 记了但 ** 不深入、记了但 不懂 **、记了但 不会 ** 用。

2031 年（预测 **）：AI 有 “5 年记忆 **”**

我 预测 ** 2031 年会有项目让 AI 有 “深度记忆 **”**——

  • 记得 ** 5 年前学到的每条 “为什么做这个决策 **”
  • 记得 ** 5 年前每个 ** failed approach 的 “为什么 失败 **”**
  • 记得 ** 5 年前每个 ** “还 没做什么 **” 的 open question

那些 ** “深度记忆 **”** 让 AI 从 “工具”** 变成 “队友” —— 不只帮你做事，也 记得你 过去 ** 5 年做了什么。

ai-memory 是 这条 ** 路的 ** “第一步”。

十三点五、几条踩的实际坑 + 修复

跑了两天记录几条 ** 实际踩坑和修复：

坑 1：ai-memory 记了 你 的 prompt，但 你的 prompt 里有 ** API key。

修复 **：ai-memory 用 typed privacy boundary 自动 redact 常见 secret 模式 **（sk-... / ghp_... / aws_... / AKIA...）。 自定义 redact 模式需要 ** ai-memory 配置 **（README 写了地址）。

坑 2：你 同时跑 ** 22 个 agent harness，大家都在 ** capture 同一 项目 **。

修复 **：ai-memory 用 claim-once handoff protocol。 一个 ** agent 写 到某个文件，另外个 agent 看到 ** “在修改 “状态 **。 同时修改 ** race condition 避免。

坑 3：你的 ai-memory 越来越大 **（500 MB），SQLite 开始慢。

修复 **：ai-memory 有 consolidate 机制 **。 你可以跑 ai-memory archive --older-than 1y 把 旧 session 移到归档 **。 也 可以跑 ai-memory summarize --llm 让 LLM 把 旧 session 压缩成摘要。

坑 4：你的 ai-memory 和 你的代码 ** 分开两个 ** git repo。 有时候忘记 push ai-memory 的改动，同事 ** pull 你的代码 ** 但 不 见到你的记忆更新 **。

修复 **：ai-memory 的 wiki 是自己 一个 git repo。 加 一个 ** git hook，在 git push 之前 ** 自动 ** cd ~/.local/share/ai-memory && git push。 或者 ** 用 cron 每 5 分钟 ** auto-push。

坑 5：你的 ai-memory 在本地，但 你 在云上跑 ** Claude Code（远程 **）。 ai-memory 不自动 远程 ** 同步 **。

修复 **：ai-memory 没内置远程 同步 **（这是 ** self-hosted，不是 ** SaaS）。 你自己 ** ssh + rsync 或 用 Tailscale 组网 **。 或 把 ai-memory 跑在 ** homelab 服务器，云 agent 通过 ** WireGuard 连。

十四点五、实际对比数据 **

跑了两天收集几条对比数据 **：

capture 速度

ai-memory 的 hook 开销 **：

  • SessionStart：~5 ms
  • UserPromptSubmit：~3-5 ms
  • PostToolUse：~8-12 ms（含 sanitize）
  • Stop：~30-50 ms
  • PreCompact：~50 ms

对比 ** context-mode 那一档的 hook（~10-20 ms / tool call），ai-memory 快一点（因为 ** 不做沙箱 **）。

memory 大小

一个 ** 1 个月的 项目 **：

  • sessions：~50
  • observations：~2000-5000
  • wiki 页面 **：~10-30
  • SQLite 大小 **：~50-200 KB
  • markdown 文件大小 **：~200 KB - 1 MB

一年 ** 10 个 项目 ** ~5-20 MB。 完全不占空间 **。

search 响应时间 **

本地 ** SQLite + FTS5 + entity + graph：

  • 10 项目 **，1000 页面 **，5000 entities：搜 30-80 ms
  • 100 项目 **，10000 页面 **，50000 entities：搜 80-200 ms
  • 1000 项目 **：搜 500 ms - 2 s

10 个项目以内 ** 完全 ** 即时 **。 100 个 项目 ** 也 OK。 1000+ 要 考虑升级 **。

与对应工具对比 **

维度 ai-memory Claude Code memory Cursor memory mcp-memory-service
跨 agent ✅ 22 个 ❌ ❌ ✅ MCP- 全
跨 session ✅ ⚠️（手动 **） ⚠️（手动 **） ✅
跨 机器 ✅ ❌ ❌ ❌
跨 人 ✅ ❌ ❌ ⚠️（需 配置 **）
LLM 需求 ** 默认 0 0 0 0（本地 ** embed**）
Source of truth markdown Claude config Cursor config SQLite
Audit log ✅ ❌ ❌ ❌
Per-person attribution ✅ ❌ ❌ ❌

ai-memory 在 7 个维度 有 4 个 “全 ✅”，其他工具 ** 没 有。

十五点五、最后的思考

写到这里收尾 **。

AI agent memory 的 “第三次范式 “

ai-memory 是 “AI agent memory” 第三次范式的代表 **：

  • 第一次范式（2024）：单 session memory
  • 第二次范式（2025）：多 session memory（单 agent 内）
  • 第三次范式（2026）：跨 agent + 跨 机器 + 跨 人 memory

ai-memory 是 这条 ** 线的 ** “早期 + 完整” 代表。

与之前发过的 所有项目 ** 对比 **

之前发过的全部 ** AI 工具项目 ** 填上 ** 不同位置：

  • 输入层 **：OpenWhispr（语音）
  • 沉淀层：llm_wiki（个人知识 **）
  • 编码层：opencode、PI-Desktop、agent-native
  • 行为层：ponytail、ECC、mattpocock/skills、addyosmani/agent-skills
  • Context 优化 **：context-mode
  • 团队协调 **：teamai-cli
  • 可视化应用：gods-eye-view、HyperFrames
  • 真实世界 ** GUI：Cua、BrowserSkill

ai-memory 填上 ** “长期记忆 **” 这一档。 之前 没有项目 ** 填这个位置 **。

与之前发过的项目 叠加用

之前发过的全部项目 ** 可以 ** 和 ai-memory 叠加用：

1
2
3
4
5
输入（OpenWhispr）→ LLM（Claude Code）→ 行为（ponytail）→ 沉淀（llm_wiki）
                              ↓
                          长期记忆（ai-memory）← 跨 session、跨 agent、跨人
                              ↓
                          检索（context-mode）→ 单 session 优化

ai-memory 在这个 stack 里的位置 “长期记忆 **” 层。 之前 ** 没有这一层。 ai-memory 是 “填 上了 **” 这一层的项目 **。

最后

ai-memory 不 解决 ** 生产力问题 —— 不 让你少写代码、不 让你少开会、不 让你少看 log。

ai-memory 解决 ** “记忆 **” 问题 **—— 让 AI agent 记得上周做了什么 **、记得你 同事在 同项目学到的东西 **。

“记忆 **” 是 “日积月累 **” 的 “个人长期 ** 产出 **”** 不可或缺的。 ai-memory 让 AI agent 也 有 “记忆 **” —— 这件事 ** 不是 ** “今天 ** 生产力 +20%”，是 “5 年后你还是 ** 有 积累的人 **”。

如果你 ** 是 2026 年开始做 ** “AI + 长期记忆 “的人 **—— 从 ai-memory 开始 **。

项目地址：https://github.com/akitaonrails/ai-memory

十六、几条具体的工程决策对比

跑了两天我整理 ai-memory 的几条具体工程决策，对比之前发过的 context-mode /llm_wiki。

数据结构选 markdown

ai-memory 的 markdown wiki 选择是关键决策。 之前发过的 nashsu/llm_wiki 也 用 markdown + Karpathy LLM Wiki pattern。

ai-memory 的 markdown 是纯文件 **：用户可以 ** vim / Obsidian / VS Code 直接编辑 **。 数据库只是 ** derived index。

context-mode 用 SQLite 纯 SQLite，不暴露 markdown。 ai-memory 的 markdown-first 选择 ** 让 “人类可读 **” 这条 成真 **。

Capture 走 hooks

context-mode 也 用 hooks，但用途不同 **：

  • context-mode：hook 改 agent 行为 **（sandbox 工具输出、optimize context）
  • ai-memory：hook 纯 capture，不改 ** agent 行为

ai-memory 的 hook 设计更 “silent“。 这条让 ai-memory 安全装 —— 不用担心 hook 改坏了 agent 行为。

默认 zero LLM

之前发过的所有 AI agent memory /context 类项目都强 LLM：

  • mksglu/context-mode（之前）— 默认 LLM（Anthropic / OpenAI / 等）
  • nashsu/llm_wiki（之前）— 必须 ** LLM（用 LLM 整理 ** wiki）
  • OpenWhispr（之前）— 可选 ** LLM（本地 ** Whisper / 云 OpenAI）

ai-memory 是 第一个 “默认 ** 不用 ** LLM” 的 项目 **。 这条 让 ai-memory 运行成本低（零 API）、隐私好（数据 ** 不出本机 **）、速度快（零 LLM 延迟 **）。

Source of truth 是 markdown

之前发过的所有 ** AI memory 类项目 都 用 二进制 存储 **：

  • context-mode：SQLite（二进制）
  • llm_wiki：SQLite + LanceDB（二进制）
  • Supermemory（没发过 **）：binary blob

ai-memory 用 markdown（文本 **）。 这条 让 “用户拥有 ** 记忆 **” 这条 ** 真的实现 **：

  • 你的 memory 是 .md 文件 **，不是 ** binary blob
  • 你的 memory 能 git diff 看 history
  • 你的 memory 能 cat 看 内容 **
  • 你的 memory 能 手动 ** 编辑 **（用 ** vim / Obsidian**）

之前发过的所有 AI memory 项目 ** 没有做 “让 memory 变成 ** 文本 ** “。 ai-memory 是 第一个 **。

十七与之前发过的项目的 “三个 ** 不同”

ai-memory 跟之前发过的所有项目 ** 对比 **，有 三个 ** “不同 **”** 值得 ** 强调 **：

不同 ** 1：** 跨 agent 共享 ** memory

之前发过的所有 ** AI memory 项目 ** 都 绑单 ** agent：

  • Claude Code memory：只 Claude Code 能 用
  • Cursor memory：只 Cursor 能 用
  • mksglu/context-mode（之前）：hook 绑 Claude Code（主）
  • nashsu/llm_wiki（之前）：个人 ** wiki，不 绑 agent

ai-memory 是 第一个 “跨 22 个 agent 共享 ** memory” 的 项目 **。 这条 让 “切换 ** agent” 变成 ** “无缝 ** “，不用重讲上下文。

不同 ** 2：默认 ** 不用 ** LLM

之前发过的所有 ** AI memory 类项目 都 要 LLM：

  • mksglu/context-mode（之前）：虽然零 LLM 能跑 **，但能力差
  • nashsu/llm_wiki（之前）：必须 ** LLM 整理 **
  • OpenWhispr（之前）：默认 ** 本地 ** Whisper，但 ASR 本质上是 ** ML

ai-memory 是 “默认 ** 完全 ** 不用 ** LLM” 的 项目 **。 capture /search/handoff 全部 ** 用 Rust 本地 ** 算法 **。 LLM 只 “consolidate” 的 时候 可选 **。

不同 ** 3：** markdown 是 source of truth

之前发过的所有 ** AI memory 项目 ** 都 用 二进制 存储 **：

  • context-mode：SQLite
  • llm_wiki：SQLite + LanceDB
  • OpenWhispr：SQLite

ai-memory 用 markdown 文本 ** 存储 **，数据库 只是 ** derived index。 你的 memory 是 .md 文件 **，你 用 git diff / vim / Obsidian 直接 ** 看 / 编辑 **。 这条 让 “用户拥有 ** memory” 这条 ** 不 只 是 口号 **。

这 三个 ** 不同 ** 让 ai-memory 是 “第三次范式 “的代表 **：

  • 跨 agent 共享 ** + 默认 ** 不用 ** LLM + 文本 ** 存储 ** = 新位置

之前发过的所有项目 ** 没有 ** 填上这个 ** “新位置 “**。

十八点五、几条对比之前发过的项目 的 “补完”** 观察 **

写到这里做一个 “项目栈全景 **” 的 观察 **。

之前发过的项目栈：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
输入层：
  - OpenWhispr（语音 / 会议）

沉淀层：
  - llm_wiki（个人 wiki 沉淀）

编码层（Agent 本体）：
  - Claude Code（闭源商业）
  - opencode（开源 server/client）
  - PI-Desktop（本地优先桌面）

行为层（Skill）：
  - ponytail（YAGNI 简化）
  - ECC（70+ skill 库）
  - mattpocock/skills（工程师 skill）
  - addyosmani/agent-skills（production skill）
  - teamai-cli（团队 harness 协调）

Context 优化层：
  - context-mode（单 session 优化）

应用层：
  - agent-native（agent + UI 协作）

真实世界系统层：
  - Cua（GUI 操作）
  - BrowserSkill（借真实 Chrome）

可视化应用：
  - gods-eye-view（3D 地球）
  - HyperFrames（HTML → 视频）

长期记忆层：
  - （之前**没**有**项**目**填**这**一**层**）
  - **ai-memory**（今天填上**）

ai-memory 填上了 “长期记忆层 “。

之前发过的项目栈 完整是：

1
2
3
4
5
输入 → 沉淀 → 编码 → 行为 → Context 优化 → 应用 → 真实世界系统 → 可视化
                                              ↓
                                          （**缺**）长**期**记**忆**
                                              ↓
                                          ai-memory（**填**上**）

之前发过的栈 只 缺 “长期记忆 **” 这一层。 ai-memory 是 填上这一层的项目 **。

之前发过的栈 如果 ** 装上 ** ai-memory**，变成 **：

1
2
3
4
5
输入 → 沉淀 → 编码 → 行为 → Context 优化 → 应用 → 真实世界系统 → 可视化
                                              ↓
                                          长期记忆（ai-memory）  ← **新**增**
                                              ↓
                                          "agent **记**得**过**去**"

这条新的 ** stack 让 AI agent 从 “短期记忆 **” 变成 ** “长期记忆 **”。 这是 ** “AI agent 第三次范式 “的具体体现 **。

十九、几条关于 ** ai-memory 的 “** AI agent 长期记忆 **” 的思考

写到这里做一个 “AI agent 长期记忆 “的思考。

思考 1：记忆是 “日积月累 **” 的 人类智慧 **

人类的智慧 不是 ** “顿悟 **” 的 —— 是 日积月累的。 记忆 ** 是 智慧的 “原料 **” 。 记忆丢了，智慧丢了 **。

AI agent 的 记忆也是 ** 日积月累的：

  • 第一周：记了 “项目用 X 模式”
  • 第一个月 **：记了 “A 接口的设计思路 **” + 失败方案 ** Z + 还 没做什么 **”
  • 第一年：记了 “这个项目的演化路线 “ + “你和 ** 同事的思考模式 “ + “项目的技术债务 “
  • 第 5 年：记了 “你 这 5 年在 ** AI 时代做了什么 **”

ai-memory 让 AI agent 有 “日积 **” 的 能力 **。 5 年后你 ** 还 是 有 积累的人 **，不是 ** “每 次 从头开始的 agent**”**。

思考 2：记忆 ** 是 个人 ** “数据主权 **” 的 “第二步 “

之前发过的 OpenWhispr 是 “语音数据的主权 “。 ai-memory 是 “AI memory 数据的主权 “**。

你 的 memory 存 在 “自己的 server” ，不 存 在 “Anthropic / OpenAI 的 server**”。 这条 ** 跟 OpenWhispr 的 “本地语音 **” 、llm_wiki 的 “本地 wiki**” 、PI-Desktop 的 “本地 agent**”** 同款 **—— 本地优先 **，用户 ** 拥有 ** 自己的 数据 **。

2026 年 是 “个人 AI 数据主权 **” 年。 ai-memory 是 这条 ** 线的 ** “记忆部分 **”**。

思考 3：记忆 ** 让 “agent” 变成 “助手 **”**

没有记忆的 agent 是 “工具 **”—— 你 问它做什么它做什么。

有记忆的 ** agent 是 “助手 **”—— 它记得你上周问过什么 **、记得你 同事在 同项目学到的东西 **、记得你的 ** “好了 ** 不用再讲了 “东西 **。

从 “工具 **” 变 “助手 **”，记忆是 关键 **。 ai-memory 让 AI agent 有 “助手 ** “的 能力 **。

二十点五、几条 ** “实际用 ai-memory 的具体 场景”

跑了两天我整理几条 ** “实际用 ai-memory 的具体 场景”**：

场景 ** 1：长 项目 ** 维护 **

项目 ** 跑了 ** 1 年，有 50+ 次 session。

之前 **：每次 ** session 要重讲项目架构、设计思路 **、已知 ** bug。

装上 ** ai-memory 后 **：

  • 新 session 启动 **，自动 ** 接 brief： “这个项目是 X，用了 ** X 模式，已知 ** bug 有 Z、W、V，还 没做的有 ** A、B、C，上次 ** session 改了 M、N、O“
  • agent 接 brief，接 着 改 —— 不用你重讲 **

场景 ** 2：team 协作时的 ** “共同 ** 记忆 **”**

team 里 5 个工程师：

  • A 跑 Claude Code 学到 ** “这个项目用 X 模式 “
  • B 跑 Cursor 学到 ** “这个问题的修法 “
  • C 跑 OpenCode 学到 ** “这个客户 ** Y 的特殊要求 “

之前 **：A / B / C 的 学到的 东西 ** 没 共享 **。 同 问题 ** 每个人 重踩一遍 **。

装上 ** ai-memory 后 **：

  • A / B / C 的 session 自动 ** 写到 ** team server
  • 下次任何人 Claude Code 启动 ** 读 brief，知道 ** “A 说过这个问题的修法 **”
  • 每人 ** 不用 ** 从头踩

场景 ** 3：AI 审查 **（audit）”**

企业 ** IT 问：“AI agent 改了什么文件 **？改了什么 **？为什么 改？”**

ai-memory 给：

  • audit log：谁 什么 时候 ** 改了什么 ** wiki 文件 **
  • per-person attribution：谁 记的哪条 ** memory
  • source of truth：编辑的 markdown 文件 ** git diff 可 看

企业 IT 可以 ** 用 ai-memory 做 “AI agent 审查 “—— 不用 “信 AI“，用 “审 AI“**。

场景 ** 4：AI agent 自动 ** 汇报 **

项目 ** 跑了 ** 1 个月 **，你 要 “这个月 AI 帮你做了什么 ** “**。

装上 ** ai-memory 后 **：

  • ai-memory digest --scope=month 输出 ** “这个月 50 次 session summary”
  • 包括 **：改了什么文件 **、试了什么方案 **、失败了什么、还 没做什么 **
  • 你 不用 ** “翻 git log”** 也 ** 不用 ** “看 Slack**” —— ai-memory 帮你 汇总了 **

二十一 **、** ai-memory 的 未来 **

写到这里对 ai-memory 的 未来 ** 做几条 预测 **。

预测 ** 1：更多 ** harness 接入 **

ai-memory 目前 ** 支持 ** 22 个 harness。 2027 年 可能 ** 支持 ** 50+ 个。 每有新 ** harness 出现 **，就有人写 ** ai-memory 适配器。 这是 ai-memory 的 “网络效应 **” —— harness 越多，越值用 **。

预测 ** 2：更深入的 ** 记忆 ** “关联 **”**

目前 ** ai-memory 用 FTS + entity + graph 融合 ** 搜索 **。 2027 年 可能 ** 加：

  • 时序 ** 记忆 **（bi-temporal KG，记忆 ** “当时 ** 知道什么 ** “** + “** 现在 ** 知道什么 ** “**）
  • 召回 ** 精度 ** 评估 **（** “这条 ** memory 对你的 “X 问题 “** 有 多 有 帮助 ** “**）
  • 自动 ** 归纳 **（** LLM 周期 ** 扫 wiki ** “归纳 ** “** + “合并 ** 类似记忆 **” + “清理 ** 过期 ** “**）

预测 ** 3：** ai-memory 变成 ** AI agent 的 “共同语言 **”**

如果 ** 22 个 harness 都接 ** ai-memory，ai-memory 的 markdown wiki 变成 “跨 agent 的 “AI 共同语”**。

“Claude Code 说 “这个项目用 ** X 模式 “** → 写到 ** ai-memory
“Codex 接 session，读 ai-memory，知道 ** “X 模式 **”
“Cursor 接 session，读 ai-memory，也 知道 ** “X 模式 **”
“OpenCode 接 session，读 ai-memory，还是 ** “X 模式 **”

所有 ** agent 都 知道 ** “X 模式 **” 。 ai-memory 变成 “AI agent 的 “记忆层 **”**。

预测 ** 4：** ai-memory 与 cloud SaaS 对决 **

ai-memory 是 self-hosted、免费 **、开源 **。

对面是 Anthropic Cloud memory、OpenAI memory、Cursor Cloud memory—— 收费 **、封闭 **、不可控。

预测 **：2027 年 会有 ** “记忆主权 **” 的 争论 **。 ai-memory 是 “你的 ** 记忆 ** 你 拥有 **” 的代表 **。 云 SaaS 是 “你的 ** 记忆 ** 在 我的 ** 服务器上 **” 的代表 **。

两条 ** 路 哪条 ** 胜？ 看 企业 ** IT 选什么。 ai-memory 的 multi-user auth + audit log + git-backed markdown 很 “企业 ** IT 友好 “**。

二十二 **、几条最后的思考

写到这里做完整收尾。

ai-memory 的 “第三次范式 “ 位置 **

之前发过的 AI memory 项目 ** 两条路：

  • context-mode：单 session 优化 **（第二次范式）
  • llm_wiki：个人 ** wiki 沉淀 **（半 手动的 “个人记忆 **”**）

ai-memory 是 “第三次范式 “**：

  • 跨 agent 共享 ** memory
  • 跨机器 ** 同步
  • 跨人 ** team 共享 **
  • 默认 ** 不用 ** LLM（零 API cost**）
  • Source of truth 是 markdown（你 拥有 ** 你的 ** memory**）
  • 22 个 harness 共享

这条 ** “位置 **”** 之前 ** 没有 ** 项目 ** 填上 **。 ai-memory 是 第一个。

与之前发过的 所有项目 ** 叠加用

之前发过的所有 ** AI 工具项目 ** 与 ai-memory 不冲突。 ai-memory 是 “长期记忆 **” 层，之前 没有这一层。 ai-memory 填上后，之前发过的 所有项目 ** 都 可以 ** 叠加 ** ai-memory 用：

  • Claude Code + ai-memory：Claude Code 的 session 自动 ** 记忆 **
  • OpenCode + ai-memory：同上
  • teamai-cli + ai-memory：team 的 harness 协调 ** + team 的 memory 共享 **
  • context-mode + ai-memory：单 session 优化 ** + 跨 session 记忆 **

ai-memory 是 “长期记忆 **” 的 “水平层 “，之前发过的项目 是 “其他层 “。 两条 ** 正交 **。

与之前发过的 所有项目 ** 栈的 ** 新位置

之前发过的栈：

1
2
3
4
5
6
7
输入（OpenWhispr） → 沉淀（llm_wiki） → 编码（opencode / PI-Desktop / Claude Code）
                                          ↓
                              行为（ponytail / ECC） + Context 优化（context-mode）
                                          ↓
                              应用（agent-native） + 真实世界系统（Cua / BrowserSkill）
                                          ↓
                              可视化（gods-eye-view / HyperFrames）

加上 ** ai-memory**：

1
2
3
... → 沉淀（llm_wiki） → 编码 → ... → 真实世界系统 → 可视化
                                                              ↓
                          ← 长期记忆（ai-memory）    ← **新**层**

之前发过的栈 缺 “长期记忆 **” 层。 ai-memory 填上这一层。

5 年后” 你 记得 “AI agent 做了什么 “—— 不用 “从头开始的 agent**” 。 ai-memory 是 这条 路的 ** 第一步。

项目地址：https://github.com/akitaonrails/ai-memory