AgentRecall X Campaign

Unpopular opinion: Your AI agent is dumber than a $5 notebook.

A notebook remembers everything you wrote. Your $200/month agent forgets it all the moment you close the tab.

We gave AI the entire internet but forgot to give it a memory. That's not an AI problem. That's an engineering failure.

不受欢迎的观点：你的 AI agent 还不如一本 5 块钱的笔记本。

笔记本能记住你写的一切。你每月花 200 美元的 agent，关掉标签页就全忘了。

我们给了 AI 整个互联网，却忘了给它一个记忆。这不是 AI 的问题，这是工程的失败。

1/ I spent 6 months studying why AI agents forget. Here's what nobody talks about.

2/ There are 3 types of AI forgetting, and only one gets attention:
• Session boundary — context dies when window closes (everyone knows this)
• Correction amnesia — you fix a mistake, it makes it again next session (nobody talks about this)
• Cross-project blindness — lessons from Project A never reach Project B (nobody even thinks about this)

3/ "Just use RAG." I knew someone would say that. RAG retrieves facts. But the most valuable thing your agent forgets isn't facts — it's your corrections. "Don't mock the DB" is worth 100x more than "DB runs on port 5432."

4/ A senior dev's notebook isn't full of syntax. It's full of "never do X because last time Y happened." Why are we building agents that can write code but can't learn from their mistakes?

5/ Here's the damning metric: Session 1 and Session 50 with your AI agent look identical. It doesn't get better at working with YOU. Zero compounding. Zero learning. Just... reset.

6/ I've been building something to fix this. Shipping soon.

Honest question: what's the most infuriating thing your AI agent keeps forgetting? I want to know if my list matches yours.

1/ 我花了 6 个月研究 AI agent 为什么会「失忆」。以下是没人讨论的部分。

2/ AI 有三种遗忘，但只有一种被关注：
• 会话边界 — 关窗口就丢上下文（人人都知道）
• 纠正失忆 — 你改了一次，下次它照犯（没人讨论）
• 跨项目盲区 — A 项目的教训到不了 B 项目（没人想过）

3/ "用 RAG 啊。" RAG 检索事实，但 agent 丢掉的最值钱的东西不是事实——是你的纠正。"不要 mock 数据库"比"数据库在 5432 端口"值钱 100 倍。

4/ 资深工程师的笔记本不是语法手册，而是"绝对不要做 X，因为上次 Y 炸了"。为什么我们在造能写代码却不能从错误中学习的 agent？

5/ 致命数据：你和 AI agent 的第 1 次会话跟第 50 次长得一模一样。零复利。零学习。只是……重置。

6/ 我一直在做一个东西来解决这个问题。快了。

真心提问：你的 AI agent 最让你抓狂的「失忆」是什么？我想看看你的清单跟我的一不一样。

Image: "The Agent Amnesia Loop"

[ New session ] → [ "What are we working on?" ] → [ Human re-explains ] → [ Work ] → [ Session ends ] → [ Lost ] → repeat

Caption: The most expensive loop in AI isn't the training run. It's you re-explaining yourself every single session.

配图：「Agent 失忆循环」

[ 新会话 ] → [ "我们在做什么？" ] → [ 人类重新解释 ] → [ 干活 ] → [ 会话结束 ] → [ 全部丢失 ] → 循环

文案： AI 里最贵的循环不是训练，而是每次开会话你都要把自己重新解释一遍。

Recording:
1. Open Claude Code, correct: "no, don't use mocks in tests"
2. Close session, open new session
3. Ask agent to write tests — it uses mocks again
4. Overlay: "Session 1: corrected. Session 2: forgotten."

Caption: Watch me correct my AI agent. Then watch it make the exact same mistake 30 seconds later in a new session. This is the memory problem nobody's solving.

录屏：
1. 打开 Claude Code，纠正："不要在测试里用 mock"
2. 关闭会话，重新打开
3. 让 agent 写测试——它又用 mock 了
4. 字幕："第 1 次：已纠正。第 2 次：又忘了。"

文案： 看我纠正 AI agent，然后看它 30 秒后在新会话里犯同样的错。这就是没人在解决的记忆问题。

Spotlight: ~/.claude/

[Screenshot of directory tree]

Caption: This is everything Claude remembers about me after 6 months. Flat markdown files. No structure. No scoring. No compounding.

Claude is the best coding AI in the world, and its memory system is a folder of text files. That's not a roast — it's an opportunity.

文件聚焦： ~/.claude/

[目录树截图]

文案： 这是 Claude 在我用了 6 个月后记住的全部。平铺的 markdown 文件。没结构。没评分。没复利。

Claude 是世界上最好的编程 AI，而它的记忆系统是一个文本文件夹。这不是吐槽——这是机会。

A bigger context window won't save your agent.

It's like giving a goldfish a bigger bowl. It still forgets in 3 seconds.

The problem isn't capacity. It's that nothing persists between sessions. You need architecture, not more tokens.

更大的上下文窗口救不了你的 agent。

这就像给金鱼换个更大的鱼缸，它照样 3 秒就忘。

问题不是容量，而是会话之间什么都留不下来。你需要的是架构，不是更多 token。

1/ Last week I showed you why AI agents forget. This week: what I built to fix it. It's called a Memory Palace, and it has 5 layers.

2/ Layer 1: Working Memory (journal). Every session captures what happened. Raw, timestamped, cheap. Decays in 2 days. Like your scratch pad — useful now, garbage tomorrow.

3/ Layer 2: Episodic Memory. End-of-session, the journal gets distilled into meaning. "We fixed the auth bug" not "we edited 14 files." This is what you'd tell a colleague over coffee.

4/ Layer 3: Memory Palace. Persistent rooms organized by topic — architecture, goals, blockers, alignment. Each room has salience scoring. Hot memories float up. Stale ones decay. Like an engineer's notebook that reorganizes itself.

5/ Layer 4: Awareness. A 200-line document that COMPRESSES over time. New insights merge with existing ones or replace the weakest. After 100 sessions, it's still 200 lines — but each line carries the weight of dozens of observations.

6/ Layer 5: Cross-project Insights. Lessons from Project A automatically surface when you start Project B. Your rate-limiting fix from the proxy server? It shows up when you're building an API gateway.

7/ I shipped this as an open-source MCP server. It's called AgentRecall. Works with Claude Code, Cursor, VS Code, Codex — any MCP-compatible tool.

github.com/Goldentrii/AgentRecall

What layer surprises you most?

1/ 上周我展示了 AI agent 为什么会失忆。这周：我造了什么来解决它。叫做 Memory Palace，有 5 层。

2/ 第 1 层：工作记忆（日志）。每次会话记录发生了什么。原始的、带时间戳、便宜。2 天衰减。像草稿纸——现在有用，明天就是垃圾。

3/ 第 2 层：情景记忆。会话结束时，日志提炼成含义。"我们修了 auth bug"，不是"我们编辑了 14 个文件"。这是你跟同事喝咖啡时会说的话。

4/ 第 3 层：记忆宫殿。按主题组织的持久化房间——架构、目标、阻塞、对齐。每个房间有显著性评分。热记忆浮上来，过期的衰减。像一本会自动整理的工程师笔记本。

5/ 第 4 层：感知。一个 200 行的文档，随时间压缩。新洞察跟现有的合并，或替换最弱的。100 次会话后还是 200 行——但每一行承载了几十次观察的重量。

6/ 第 5 层：跨项目洞察。A 项目的教训在你启动 B 项目时自动浮现。你在代理服务器里的限流修复？在你造 API 网关时它会出现。

7/ 我把它做成了开源 MCP server，叫 AgentRecall。支持 Claude Code、Cursor、VS Code、Codex——所有 MCP 兼容工具。

github.com/Goldentrii/AgentRecall

哪一层最让你意外？

Image: 5-layer memory pyramid. Bottom=widest (journal, cheap, fast decay) to top=narrowest (insights, expensive, near-permanent). Token cost + decay rate per layer.

Caption: Not all memories are equal. A journal entry decays in 2 days. A correction persists for 9,999. This is the architecture of AgentRecall.

配图：5 层记忆金字塔。底部=最宽（日志，便宜，快衰减）到顶部=最窄（洞察，昂贵，近永久）。每层 token 成本 + 衰减率。

文案： 不是所有记忆都平等。日志 2 天衰减，纠正 9999 天持久。这就是 AgentRecall 的架构。

Recording:
1. Open Claude Code, run /arstart
2. Watch: identity loads, 5 insights surface, watch_for warnings appear, stale rooms flagged
3. Run a recall query — ranked results from palace + journal + insights
4. Overlay: "Session 1: blank slate. Session 10: the agent already knows you."

Caption: This is what it looks like when your agent remembers. 385 tokens to load your entire project context. No re-explaining.

录屏：
1. 打开 Claude Code，运行 /arstart
2. 看：身份加载、5 条洞察浮现、watch_for 警告出现、过期房间标记
3. 运行 recall 查询——宫殿+日志+洞察的排名结果
4. 字幕："第 1 次：空白。第 10 次：agent 已经认识你了。"

文案： 这就是 agent 记住你时的样子。385 个 token 加载你的全部项目上下文。不用重新解释。

Spotlight: ~/.agent-recall/

[Directory tree showing: projects/novada-mcp/, projects/AgentRecall/, each with journal/, palace/rooms/, identity.md, graph.json]

Caption: Last week: ~/.claude/ — flat files, no structure. This week: ~/.agent-recall/ — rooms, salience scores, decay curves, cross-project graphs. Same machine, different architecture. That's the gap.

文件聚焦： ~/.agent-recall/

[目录树：projects/novada-mcp/, projects/AgentRecall/，各含 journal/, palace/rooms/, identity.md, graph.json]

文案： 上周：~/.claude/——平铺文件，无结构。这周：~/.agent-recall/——房间、显著性评分、衰减曲线、跨项目图谱。同一台机器，不同的架构。差距就在这里。

Everyone's building RAG pipelines for their agents. Almost nobody is storing corrections.

You're retrieving the wrong things.

"Don't mock the database" will save you more time than any vector search over your docs ever will.

所有人都在给 agent 搭 RAG 管线。几乎没人在存纠正记录。

你检索的东西搞错了。

"不要 mock 数据库" 比你对文档做的任何向量搜索都更能省时间。

1/ The most counterintuitive thing I've learned building agent memory: corrections are worth 100x more than facts. Here's why.

2/ When you correct your agent ("don't use mocks", "always check null first"), you're transferring JUDGMENT, not information. Facts have alternatives. Judgment is earned through failure.

3/ So AgentRecall stores corrections as the highest-priority memory class. They never decay. They surface as warnings BEFORE the agent makes the same mistake. We call them "watch_for" patterns.

4/ After 3 corrections on the same topic, your agent starts sessions with: "You've corrected me on X three times — I should ask before assuming." It's not retrieval. It's behavioral change.

5/ And here's the compression trick: awareness is capped at 200 lines. Not 200 pages. 200 lines. New insights merge with similar ones or replace the weakest. After 100 sessions, each line carries the weight of 50 observations. The constraint IS the feature.

6/ Compare: RAG stores everything and retrieves by similarity. AgentRecall stores corrections and retrieves by importance. One gets noisier over time. The other gets sharper. Which architecture would you trust with your agent's behavior?

1/ 做 agent 记忆最反直觉的发现：纠正比事实值钱 100 倍。为什么？

2/ 你纠正 agent（"不要用 mock"、"先检查 null"），传递的是判断力，不是信息。事实有替代品，判断力是从失败中挣来的。

3/ 所以 AgentRecall 把纠正存为最高优先级记忆。永不衰减。在 agent 犯同样错误之前以警告形式浮现。我们叫它 "watch_for" 模式。

4/ 同一主题被纠正 3 次后，agent 开始会话时会说："你已经纠正我 X 三次了——我应该先问再假设。" 这不是检索，是行为改变。

5/ 压缩技巧：感知层限制在 200 行。不是 200 页。200 行。新洞察跟现有的合并或替换最弱的。100 次会话后每行承载 50 次观察的重量。限制本身就是功能。

6/ 对比：RAG 存一切按相似度检索。AgentRecall 存纠正按重要性检索。一个越用越吵，一个越用越锐利。你的 agent 行为你信任哪个架构？

Image: Two curves. Left: "Typical Memory" — linear growth, noise accumulates. Right: "AgentRecall Awareness" — flat at 200 lines, signal strengthens. Divergence after session 20.

Caption: More storage = more noise. Fixed capacity = forced compression = compounding signal. This is why 200 lines beats 200 pages.

配图：两条曲线。左："普通记忆"——线性增长，噪音累积。右："AgentRecall 感知"——固定 200 行，信号增强。会话 20 后分叉。

文案： 存储越多 = 噪音越多。固定容量 = 强制压缩 = 信号复利。这就是 200 行赢过 200 页的原因。

Recording:
1. Open Claude Code with AgentRecall
2. session_start loads — watch_for warning appears: "Corrected 3x on DB mocking"
3. Ask agent to write tests
4. Agent says: "Based on past corrections, should I avoid mocks here?"
5. Overlay: "Week 1: forgotten. Week 3: learned."

Caption: Remember Week 1's demo where my correction was forgotten? Same scenario. Different outcome. This is what compounding memory looks like.

录屏：
1. 打开带 AgentRecall 的 Claude Code
2. session_start 加载——watch_for 警告："DB mocking 被纠正 3 次"
3. 让 agent 写测试
4. Agent："根据过去的纠正，这里要不要避免 mock？"
5. 字幕："第 1 周：忘了。第 3 周：学会了。"

文案： 还记得第 1 周的录屏吗？纠正被遗忘了。同样场景，不同结果。这就是记忆复利。

Spotlight: palace/rooms/alignment/

[Show correction files with timestamp, severity, context]

Caption: This folder is the most important folder in AgentRecall. It stores every correction you've ever made. These memories never decay. They surface as warnings. They change behavior. This is what "learning from mistakes" actually looks like in code.

文件聚焦： palace/rooms/alignment/

[展示带时间戳、严重程度、上下文的纠正文件]

文案： 这是 AgentRecall 里最重要的文件夹。存着你做过的每一次纠正。这些记忆永不衰减。以警告形式浮现。改变行为。这才是"从错误中学习"在代码里的样子。

You don't need embeddings for agent memory.

A 19-rule stemmer and a 100-pair synonym table outperform a $500/month embedding API for behavioral recall.

Zero external dependencies. Zero API calls. Zero latency. Fight me.

Agent 记忆不需要 embeddings。

19 条词干规则 + 100 对同义词表，在行为召回上比 $500/月的 embedding API 表现更好。

零外部依赖。零 API 调用。零延迟。来辩。

1/ 3 formulas make AgentRecall's memory actually work. None of them are embeddings. Here's the math that matters.

2/ Formula 1: Reciprocal Rank Fusion (RRF). Problem: palace, journal, and insights each rank memories differently. Naive merge = one source dominates. RRF merges positions, not scores. Each source gets a fair vote. No source can shout louder than others.

3/ Formula 2: Ebbinghaus forgetting curve. Not all memories should live forever. Journal entries (scratch notes) decay with half-life of 2 days. Palace memories (architectural decisions) decay with half-life of 9,999 days. Same system, different respect for different knowledge.

4/ Formula 3: Bayesian Beta feedback. When you use a recall result, it gets a usefulness score. Useful = ranking boosted by 1.33x. Useless = dampened by 0.67x. No feedback = unchanged. Over 20 queries, the system learns what YOU find valuable, not what's "semantically similar."

5/ Why not embeddings? Embeddings find what's similar. These formulas find what's important. Similar ≠ important. Your most important memories (corrections) share zero semantic similarity with your query — they're about WHAT NOT TO DO.

6/ The hot-window bonus: Last 6 hours = 3x boost. Last 24h = 2x. Last 72h = 1.3x. Because what happened this morning matters more than what happened last month, even if last month's memory has higher salience.

7/ All of this runs locally. No API calls. No embedding service. No vector database. Just math that respects how memory actually works. If you want to see the code: github.com/Goldentrii/AgentRecall

1/ 3 个公式让 AgentRecall 的记忆真正有效。没有一个是 embeddings。这是真正重要的数学。

2/ 公式 1：倒数排名融合（RRF）。问题：宫殿、日志、洞察各有不同排名。简单合并=某个来源主导。RRF 合并的是位置而非分数。每个来源公平投票，没有谁能喊得更响。

3/ 公式 2：艾宾浩斯遗忘曲线。不是所有记忆都该永生。日志条目（草稿）半衰期 2 天。宫殿记忆（架构决策）半衰期 9999 天。同一个系统，对不同知识不同尊重。

4/ 公式 3：贝叶斯 Beta 反馈。当你用了一条召回结果，它得到有用性评分。有用=排名提升 1.33 倍。没用=抑制 0.67 倍。无反馈=不变。20 次查询后，系统学会的是你觉得什么有价值，不是什么"语义相似"。

5/ 为什么不用 embeddings？Embeddings 找的是相似的。这些公式找的是重要的。相似≠重要。你最重要的记忆（纠正）和你的查询零语义相似——它们是关于"不要做什么"。

6/ 热窗口加成：最近 6 小时=3 倍提升。24 小时=2 倍。72 小时=1.3 倍。因为今天早上的事比上个月的事重要，即使上个月的记忆显著性更高。

7/ 全部本地运行。无 API 调用。无 embedding 服务。无向量数据库。只是尊重记忆工作方式的数学。代码：github.com/Goldentrii/AgentRecall

Image: 3 decay curves — journal (fast drop), knowledge (gradual), palace (nearly flat). Hot-window boost zone highlighted.

Caption: Your scratch notes should decay in 2 days. Your architectural decisions should last 27 years. AgentRecall treats different memories with different respect. Most systems don't.

配图：3 条衰减曲线——日志（快速下降）、知识（渐进）、宫殿（几乎平坦）。热窗口加成区高亮。

文案： 草稿该 2 天衰减。架构决策该持续 27 年。AgentRecall 对不同记忆不同尊重。大多数系统做不到。

Recording:
1. Show palace-index.json with salience scores (0.0-1.0)
2. Run recall query — results ordered by computed salience
3. Mark result as "useful" — watch score update
4. Run same query — ranking shifts
5. Overlay: "Your memory system learns what YOU find valuable."

Caption: Watch the ranking change in real-time as I tell it what's useful. This isn't retrieval. It's a feedback loop.

录屏：
1. 展示 palace-index.json 及显著性评分（0.0-1.0）
2. 运行 recall 查询——结果按计算出的显著性排序
3. 标记结果"有用"——看评分更新
4. 再次查询——排名变化
5. 字幕："你的记忆系统学会了你觉得什么有价值。"

文案： 看排名如何随着我的反馈实时变化。这不是检索，是反馈循环。

Spotlight: The scoring engine

[Code showing salience = recency(30%) + access(25%) + connections(20%) + urgency(15%) + importance(10%)]

Caption: 5 factors, carefully weighted. Recency matters most because what happened today beats what happened last month. But connections matter too — an isolated memory is less trustworthy than one linked to three others.

文件聚焦：评分引擎

[代码：salience = 近期(30%) + 访问(25%) + 连接(20%) + 紧急(15%) + 重要(10%)]

文案： 5 个因子，精心加权。近期最重要因为今天发生的事赢过上个月。但连接也重要——孤立的记忆不如跟三条其他记忆相连的可信。

Your AI agent has PhD-level intelligence and the memory of a goldfish.

It can write a compiler from scratch but can't remember that you hate semicolons.

We spent billions on reasoning. We spent nothing on remembering. The priorities are backwards.

你的 AI agent 有博士级智力和金鱼级记忆。

它能从零写一个编译器，却记不住你讨厌分号。

我们花了几十亿在推理上，在记忆上花了零。优先级搞反了。

1/ The thing that surprised me most about AgentRecall: lessons from one project automatically show up in another. Here's a real example from my own usage.

2/ I was building a proxy server (novada-mcp). Fixed a rate-limiting bug. AgentRecall stored the lesson. Months later, started an API gateway project. At session_start: "Cross-project insight: rate-limiting pattern from novada-mcp may apply here."

3/ I didn't search for it. I didn't remember it. The system surfaced it because the keywords and context overlapped. An insight-index maps lessons to topics across ALL your projects. It's like having a senior engineer who worked on all your repos.

4/ Honest token savings numbers (I'm not going to hype this): Simple tasks with 0 corrections = pure overhead (+99%). It's a net loss. Don't use memory for throwaway scripts.

5/ But for real projects: 5 sessions, 1 correction = -30% tokens. 20 sessions, 5 corrections = -57%. Digest cache for repeated analysis = -83%. Break-even point: 3-4 sessions. After that, it compounds.

6/ The caveat: these are benchmarked models, not production telemetry. I'm being upfront about that. The real proof is qualitative: my agent on session 30 behaves measurably differently than session 1. It knows my preferences, my blind spots, my shortcuts.

1/ AgentRecall 最让我惊讶的：一个项目的教训自动出现在另一个项目里。用我自己的真实案例说。

2/ 我在做代理服务器（novada-mcp），修了个限流 bug。AgentRecall 存了这个教训。几个月后开始 API 网关项目。session_start："跨项目洞察：novada-mcp 的限流模式可能适用。"

3/ 我没搜索，也没想起来。系统因为关键词和上下文重叠自动浮现了它。洞察索引把教训映射到所有项目的主题上。像有个在你所有仓库都工作过的资深工程师。

4/ 诚实的 token 节省数据（我不会夸大）：0 纠正的简单任务=纯开销（+99%）。净亏损。一次性脚本不要用记忆。

5/ 但真实项目：5 次会话 1 次纠正=-30%。20 次会话 5 次纠正=-57%。重复分析缓存=-83%。盈亏平衡：3-4 次会话。之后开始复利。

6/ 注意：这是基准模型数据，不是生产遥测。我提前说清楚。真正的证据是定性的：我的 agent 在第 30 次会话时行为跟第 1 次明显不同。它了解我的偏好、盲点和习惯。

Image: Bar chart. Simple=+99% overhead (red). Medium=-30% (amber). Complex=-57% (green). Cache=-83% (bright green). Break-even line at 3-4 sessions.

Caption: Honest numbers. Simple tasks? AgentRecall is pure overhead. Complex projects with corrections? -57% token savings. I won't pretend it's magic for everything. But for real work, it compounds.

配图：柱状图。简单=+99% 开销（红）。中等=-30%（黄）。复杂=-57%（绿）。缓存=-83%（亮绿）。3-4 次会话盈亏线。

文案： 诚实的数据。简单任务？AgentRecall 是纯开销。有纠正的复杂项目？-57% token 节省。我不会假装它万能。但对真正的工作，它复利。

Recording:
1. Run /arstatus — empty board
2. Run /arbootstrap — scans ~/Projects/, ~/.claude/
3. Watch: discovers 18 projects, imports context
4. Run /arstatus again — full board with status, blockers, next actions
5. Overlay: "0 projects → 18 projects. One command."

Caption: Cold-start to fully loaded in one command. /arbootstrap scans your git repos, Claude memory, and CLAUDE.md files. No manual setup.

录屏：
1. /arstatus——空面板
2. /arbootstrap——扫描 ~/Projects/, ~/.claude/
3. 看：发现 18 个项目，导入上下文
4. 再次 /arstatus——完整面板带状态、阻塞、下一步
5. 字幕："0 项目 → 18 项目。一条命令。"

文案： 从冷启动到完全加载只需一条命令。/arbootstrap 扫描你的 git 仓库、Claude 记忆和 CLAUDE.md 文件。无需手动设置。

Spotlight: insights-index.json

[JSON structure showing keyword map, cross-project references, salience scores]

Caption: This file is the bridge between your projects. Every lesson, indexed by keyword, linked across repos. When you start a new project, the insights that matter find YOU. Not the other way around.

文件聚焦： insights-index.json

[JSON 结构：关键词映射、跨项目引用、显著性评分]

文案： 这个文件是你项目之间的桥梁。每条教训按关键词索引，跨仓库链接。当你开新项目时，重要的洞察主动找到你，而不是你去找它。

AI agents won't replace junior developers.

They'll replace bad memory.

The bottleneck was never intelligence. It was continuity. An agent that remembers your last 50 sessions is more valuable than one that's 10% smarter at coding.

We're optimizing the wrong dimension.

AI agent 不会取代初级开发者。

它们会取代「差记忆」。

瓶颈从来不是智力，而是连续性。一个记得你过去 50 次会话的 agent 比一个编码能力强 10% 的 agent 更有价值。

我们在优化错误的维度。

1/ The gap between how humans think and how AI agents act is structural. You can't close it. But you can navigate it. Here's the idea behind everything I've built.

2/ I call it "Intelligent Distance." When you give your agent a task, you communicate WHAT. The agent invents its own WHY and HOW. And it usually gets them wrong. This isn't a bug. It's the nature of the gap.

3/ The traditional fix: write better prompts, add more context, use bigger models. But the gap is structural. You can't prompt-engineer your way across a structural divide.

4/ The real fix: let the gap be navigated through experience. Every correction your agent receives is a data point about HOW YOU THINK. After 50 corrections, the agent doesn't just know your codebase — it knows your judgment.

5/ Session 1: "Build a login page." Agent builds something generic. You correct 5 things. Session 50: "Build a settings page." Agent already knows you prefer server components, hate inline styles, always want error boundaries. Zero corrections needed.

6/ This is the endgame for agent memory: not storage, not retrieval, but BEHAVIORAL CONVERGENCE. Your agent should behave measurably differently on session 50 than session 1. If it doesn't, your memory system is just an expensive database.

7/ AgentRecall is my attempt at building this. 240+ stars, 10 MCP tools, works everywhere. But more than the tool — I think this is where the industry needs to go. Memory as a protocol, not a product.

Follow along if you want to see where this goes. github.com/Goldentrii/AgentRecall

1/ 人类思维和 AI agent 行为之间的差距是结构性的。你关不掉它。但你可以越过它。这是我造一切东西背后的想法。

2/ 我叫它「智能距离」。你给 agent 一个任务，传达的是 WHAT。Agent 自己发明 WHY 和 HOW。而且通常都搞错了。这不是 bug，是差距的本质。

3/ 传统方案：写更好的 prompt、加更多上下文、用更大模型。但差距是结构性的。你没法靠 prompt 工程跨过结构性鸿沟。

4/ 真正的方案：让差距通过经验被导航。你的每次纠正都是关于你如何思考的数据点。50 次纠正后，agent 不只了解你的代码库——它了解你的判断力。

5/ 第 1 次会话："做一个登录页面。" Agent 做了个通用的。你纠正 5 处。第 50 次："做一个设置页面。" Agent 已经知道你偏好服务端组件、讨厌内联样式、永远要错误边界。零纠正。

6/ Agent 记忆的终局不是存储、不是检索，而是行为趋同。你的 agent 在第 50 次会话的行为应该跟第 1 次明显不同。如果没有，你的记忆系统只是一个昂贵的数据库。

7/ AgentRecall 是我的尝试。240+ 星，10 个 MCP 工具，全平台支持。但比工具更重要的是——我认为这是行业需要去的方向。记忆作为协议，而不是产品。

想看后续的话跟着我。github.com/Goldentrii/AgentRecall

Image: Split card. Left: "Session 1" — blank context, generic code, 5 corrections. Right: "Session 50" — loaded context, personalized code, 0 corrections. Specific examples listed.

Caption: Same agent. Same task. Different session number. The only difference is memory. This is what behavioral convergence looks like.

配图：对比卡。左："第 1 次会话"——空白上下文、通用代码、5 次纠正。右："第 50 次"——完整上下文、个性化代码、0 次纠正。列出具体例子。

文案： 同一个 agent。同一个任务。不同会话次数。唯一区别是记忆。这就是行为趋同。

Recording:
1. /arstart — context loads (3 sec)
2. Work happens — agent uses recalled context (10 sec, sped up)
3. remember() — new learning stored (5 sec)
4. check() — decision trail recorded (5 sec)
5. /arsave — journal + palace + awareness (5 sec)
6. Overlay: "One session. Five layers updated. Everything compounds."

Caption: 60 seconds. The full memory lifecycle. Start → recall → learn → decide → save. Every session makes the next one better.

录屏：
1. /arstart——上下文加载（3秒）
2. 工作——agent 使用召回的上下文（10秒加速）
3. remember()——新学习存储（5秒）
4. check()——决策记录（5秒）
5. /arsave——日志+宫殿+感知更新（5秒）
6. 字幕："一次会话。五层更新。一切复利。"

文案： 60 秒，完整记忆生命周期。启动→召回→学习→决策→保存。每次会话让下一次更好。

Spotlight: ORCHESTRATOR-PROTOCOL.md

[Show key sections: compound lesson rule, circular agent loop, orchestrator+executor]

Caption: The final folder spotlight. This is the spec for multi-agent orchestration with shared memory. Agents reviewing each other. Lessons compounding across agents, not just sessions. This is where we're going next.

文件聚焦： ORCHESTRATOR-PROTOCOL.md

[展示：复合教训规则、循环 agent 环、编排器+执行器模式]

文案： 最后一次文件聚焦。这是多 agent 编排+共享记忆的规范。Agent 互相审查。教训跨 agent 复利，不只是跨会话。这是我们下一步要去的地方。