instinct 深度解析：当 AI Agent 第一次学会「从经验中自己长大」

引言：AI 编程助手的「金鱼记忆」困境

你有没有发现一个奇怪的现象：Claude Code、Cursor、GitHub Copilot 这些 AI 编程助手在单次会话中表现出色，但每次新会话都从零开始。没有连续性，也没有「上次遇到过类似情况」的判断力。

今天你教它「这个项目用 black 格式化」，明天新开一个会话，它又忘了。今天它学会了「先跑测试再提交代码」，明天它又开始直接提交。

这不是 AI 不够聪明，而是它没有「记忆」——准确地说，没有一种机制让它在反复实践中自己学会东西。

现有的应对方式是 CLAUDE.md 文件、系统提示词、手动编写的规则列表。但这些本质上都是把人当作记忆载体。人去观察模式、记录下来、维护文件，AI 只负责执行。

如果 AI 能自己学会呢？如果它能像人一样，通过反复实践形成「习惯」，不需要任何人教呢？

这就是 instinct 这个开源项目要解决的问题。

一、核心思想：基于置信度的学习

1.1 传统方式的局限

多数 AI Agent 记忆系统采用显式建模，即人写规则、Agent 遵照执行。这种模式有几个问题：

1. 人力成本高：每个规则都需要人来观察、总结、编写
2. 维护困难：规则越来越多，相互冲突，难以管理
3. 适应性差：换个项目、换个场景，规则可能就不适用了

instinct 走了一条完全不同的路——借鉴大脑中习惯形成的机制：

观察 → 重复 → 成熟 → 建议

1.2 置信度分级系统

Agent 首次执行某个操作时，instinct 将其记录为一条 raw 观察，初始置信度为 1。同一模式再次出现，置信度递增。当置信度突破第一个阈值，模式进入 mature 状态，就出现在建议列表中；如果获得更高的阈值，模式晋升为 rule，可以自动应用。

Confidence 1-4:   raw      (observed, not actionable)
Confidence 5-9:   mature   (ready to suggest)
Confidence 10+:   rule     (strong enough to auto-apply)

关键问题：什么时候一个模式算「准备好了」？

答案：没有人来做判断，数据说了算。

这种设计非常聪明。它把「什么是习惯」这个问题，从主观判断变成了客观数据。一个模式出现 5 次，可能只是偶然；出现 10 次以上，那就是真正的习惯。

二、工作原理：观察 → 合并 → 建议

2.1 观察（Observe）

每当发现一个反复出现的模式——一组工具调用序列、某种编码偏好、一类频繁出现的修复——就将其记录下来：

# 记录动作序列
instinct observe "seq:lint->fix->test"

# 记录用户偏好
instinct observe "pref:style=black" --cat preference

# 记录常见修复模式
instinct observe "fix:missing-import" --cat fix_pattern

命名约定通过前缀区分模式类别：

• seq: → Action sequence（动作序列），如 seq:lint->fix->lint
• pref: → User preference（用户偏好），如 pref:stdlib-first
• fix: → Recurring fix（常见修复），如 fix:missing-import
• combo: → Tools used together（工具组合），如 combo:pytest+coverage

每次观察都是一个 upsert 操作：模式已存在则置信度加 1，不存在则以置信度 1 新建。

2.2 合并（Consolidate）

会话结束时（或定期），运行 consolidate 触发自动晋升：

instinct consolidate
# Promoted to mature: 3
# Promoted to rule: 1
# Total instincts: 12

学习在这一步完成。累积观察次数达标的模式自动晋升，不需要人介入。

这是一个非常关键的设计。它让「学习」变成了一个自动化的过程，而不是需要人手动触发的操作。

2.3 建议（Suggest）

下一次会话开启时，Agent 向系统请求建议：

instinct suggest
#   seq:test->fix->test    conf=8  [mature]  sequence
#   pref:stdlib-first      conf=12 [rule]    preference
# 2 suggestions

只有 mature 和 rule 级别的模式会返回。Raw 观察始终保持静默，直到置信度积累到位。

这种设计避免了噪音。如果一个模式只出现过一两次，它不值得被建议；但当它反复出现，就说明这是一个值得记住的模式。

三、架构设计：极简主义的胜利

3.1 三大核心组件

instinct 的架构非常简洁，只有三个核心组件：

1. 观察器（Observer）：记录模式
2. 存储层（Store）：SQLite 数据库
3. MCP 服务器：与 AI Agent 集成

这三个组件不需要外部依赖（MCP SDK 除外），而且 SQLite 也内置于 Python 标准库；MCP 服务器基于 FastMCP 实现。

3.2 为什么选择 SQLite？

备选方案评估过 JSON 文件、Redis、简单的键值存储。而选择 SQLite 原因有四：

1. 查询灵活：可用 SQL 按置信度、类别、项目任意查询
2. 事务安全：ACID 事务保证状态一致性
3. 零配置：无需守护进程、无需额外配置，整个存储就是一个文件
4. 易于迁移：迁移学习历史只需复制这个文件

核心的 upsert 查询把创建和更新合并到了一条语句里：

INSERT INTO instincts (pattern, category, confidence, ...)
VALUES (?, ?, 1, ...)
ON CONFLICT(pattern) DO UPDATE SET
    confidence = confidence + 1,
    last_seen = excluded.last_seen

首次观察建行，重复观察加分。一条查询就搞定了。

3.3 为什么选择 MCP？

Model Context Protocol（MCP） 是一个将 AI Agent 与外部工具连接的开放标准。instinct 实现为 MCP 服务器后，天然兼容所有支持该协议的 Agent——Claude Code、Cursor、Goose，或任何其他 MCP 客户端。

{
  "mcpServers": {
    "instinct": {
      "command": "instinct",
      "args": ["serve"]
    }
  }
}

配置文件里加上这几行，任意 MCP Agent 即可接入自学习记忆。

这是一个战略性的选择。MCP 正在成为 AI Agent 工具链的标准协议，选择它意味着 instinct 可以无缝接入现有生态，而不是需要为每个 Agent 单独开发集成。

四、项目感知的学习：记忆也会「看场合」

4.1 项目指纹机制

并非所有模式都具有普适性。「用 black 格式化」也许适用于某个 Python 项目，换一个 Go 项目就不适用了。所以 instinct 用项目指纹来划定作用域：

def project_fingerprint(path=None):
    p = Path(path or Path.cwd()).resolve()
    return hashlib.sha256(str(p).encode()).hexdigest()[:12]

每个项目依据其目录路径生成一个稳定的 12 字符 SHA256 指纹。模式分为两类：

• 项目级模式：仅在对应项目中生效
• 全局模式：project 字段为空，在所有项目中可见

4.2 智能作用域隔离

Agent 调用 suggest 时，返回结果同时包含全局模式和当前项目的专属模式。Python 项目的格式化偏好不会渗透到 Go 项目中。

这种设计体现了 instinct 的一个核心理念：记忆需要上下文。一个好的习惯，在错误的地方可能是坏习惯。

五、衰减机制：遗忘也是一种智慧

5.1 为什么需要衰减？

人的习惯长期不用会逐渐淡化，instinct 中的模式也遵循同样的逻辑。

instinct decay --days 90

超过 90 天未被观察到的模式，置信度减 1。减到零的模式自动删除。系统以此避免积累过时的建议，保持记忆库的时效性。

5.2 遗忘的艺术

这是一个非常巧妙的设计。它让记忆系统具备了「自我清洁」的能力：

• 不再使用的模式会自动消失
• 记忆库不会无限膨胀
• 始终保持与当前工作流的相关性

遗忘不是缺陷，而是特性。一个不会遗忘的系统，最终会被噪音淹没。

六、实际使用：AI Agent 如何「自己长大」

6.1 与 Claude Code 的集成

以下是与 Claude Code 集成的典型场景。在 MCP 服务器的指令中，instinct 对 Agent 说：

Use 'observe' to record patterns you notice. Use 'suggest' to get mature patterns that should guide your behavior. Run 'consolidate' periodically to auto-promote high-confidence patterns.

几次会话之后，Agent 开始形成自己的「操作手册」：

seq:test->fix->test          conf=8   [mature]   — Always re-run tests after fixes
pref:stdlib-first            conf=12  [rule]     — Prefer stdlib over third-party
fix:missing-init             conf=6   [mature]   — Check for __init__.py in new packages
combo:pytest+coverage        conf=5   [mature]   — Always run coverage with tests

6.2 从零到熟练：学习曲线

没有人显式地教过 Agent 这些内容——它从跨会话的重复行为中自行归纳出来。

• 第一次会话：Agent 记录了一些原始观察，但没有任何建议
• 第三次会话：开始出现 mature 级别的模式，Agent 会建议一些做法
• 第五次会话：Agent 对工作流的熟悉程度已经超过一个新加入的团队成员
• 第十次会话：多个 rule 级别的模式，Agent 可以自动应用某些习惯

这就是「从经验中长大」的真正含义。

七、深入底层：数据库 Schema

7.1 完整的表结构

CREATE TABLE instincts (
    pattern    TEXT PRIMARY KEY,
    category   TEXT NOT NULL DEFAULT 'sequence',
    confidence INTEGER NOT NULL DEFAULT 1,
    first_seen TEXT NOT NULL,
    last_seen  TEXT NOT NULL,
    source     TEXT NOT NULL DEFAULT '',
    project    TEXT NOT NULL DEFAULT '',
    promoted   INTEGER NOT NULL DEFAULT 0,
    metadata   TEXT NOT NULL DEFAULT '{}'
)

一张表，构成完整的数据模型。这种极简设计有几个好处：

1. 易于理解：任何人一眼就能看懂数据结构
2. 易于迁移：一个 SQLite 文件就可以迁移所有记忆
3. 易于扩展：metadata 字段可以存储任意 JSON

7.2 字段说明

• pattern：模式字符串，如 seq:test->fix->test
• category：模式类别，如 sequence、preference、fix_pattern
• confidence：置信度，决定模式的成熟度
• first_seen / last_seen：首次和最后一次观察时间
• source：模式来源，如 claude-code、cursor
• project：项目指纹，空表示全局模式
• promoted：成熟度等级，0 = raw，1 = mature，2 = rule
• metadata：扩展字段，JSON 格式

八、Python API：灵活集成到任意工作流

8.1 基础用法

CLI 和 MCP 服务器之外，instinct 也提供了 Python API：

from instinct.store import InstinctStore

store = InstinctStore()  # 默认: ~/.instinct/instinct.db

# 观察模式
store.observe("seq:test->fix->test", source="claude-code")
store.observe("seq:test->fix->test")  # 置信度现在 = 2

# 查询
suggestions = store.suggest()           # 获取成熟模式
store.list(min_confidence=3)            # 按置信度筛选
store.search("test")                    # 全文搜索

# 生命周期
store.consolidate()                     # 自动提升
store.decay(days_inactive=90)           # 减少过时模式
stats = store.stats()                   # 汇总统计

# 导出
rules = store.export_rules()            # 仅置信度 >= 10

store.close()

8.2 集成场景

借助该 API，instinct 可以方便地嵌入：

• 自定义工具链：在你的脚本中调用
• CI 流水线：在自动化流程中使用
• 数据分析面板：可视化记忆演化

九、快速上手：5 分钟体验

9.1 安装

pip install instinct-mcp

9.2 记录你的第一个模式

# 记录你的第一个模式
instinct observe "seq:your->first->pattern"

# 查看系统学到了什么
instinct suggest

# 启动 MCP 服务器用于 Agent 集成
instinct serve

代码完全开源，包已发布在 PyPI 上。

GitHub 地址：https://github.com/yakuphanycl/instinct

十、对比分析：instinct vs 其他记忆方案

10.1 与 Claude Memory Compiler 的对比

Claude Memory Compiler 采用「编译器思维」，将记忆视为需要编译的代码。它强调的是结构化的记忆组织。

instinct 则采用「统计学习思维」，让记忆从重复行为中自然涌现。它强调的是自动化的习惯形成。

两种思路各有优势：

• Claude Memory Compiler 更适合复杂的知识管理
• instinct 更适合工作流的习惯化

10.2 与 MemPalace 的对比

MemPalace 引入「记忆宫殿」理念，用空间位置组织记忆。它是一个完整的记忆系统，但需要更多的配置和理解。

instinct 更加轻量，核心就是「观察 → 置信度积累 → 自动晋升」。上手更简单，但功能也更聚焦。

10.3 与传统规则系统的对比

传统规则系统需要人手动编写和维护规则。instinct 完全自动化，但前提是 Agent 的行为足够稳定和重复。

如果你的工作流变化很大，instinct 可能学不到稳定的模式；但如果你有固定的编码习惯，instinct 会非常高效。

十一、应用场景：哪里最适合使用 instinct？

11.1 理想场景

1. 固定工作流：每天做类似的事情，有稳定的模式
2. 多项目开发：不同项目有不同的习惯，需要项目级隔离
3. 团队协作：团队成员可以共享某些全局模式
4. 长期项目：需要跨会话的记忆积累

11.2 不太适合的场景

1. 探索性编程：每次都是新东西，没有重复模式
2. 快速原型：项目生命周期太短，来不及形成习惯
3. 高度定制化：每个项目都有独特的规则，难以通用

十二、未来展望：AI Agent 记忆的演进方向

12.1 当前局限

instinct 目前还比较初级，有一些局限：

1. 模式表达简单：只能表达序列、偏好等简单模式
2. 没有语义理解：无法理解模式的含义
3. 缺乏交互：用户无法主动干预学习过程

12.2 可能的演进方向

1. 语义化模式：用向量表示模式，支持模糊匹配
2. 可解释性：解释为什么某个模式被晋升
3. 用户反馈：允许用户确认或否定建议
4. 跨 Agent 学习：在多个 Agent 之间共享学习成果

结语：从「工具」到「伙伴」

instinct 代表了 AI Agent 记忆系统的一个重要方向：让 AI 从被动的规则执行者，变成主动的习惯形成者。

它的核心理念非常简单：重复就是习惯，习惯就是记忆。但正是这种简单的理念，可能会彻底改变我们与 AI 编程助手的交互方式。

未来，当你打开一个新的编程会话，AI 助手已经知道你的偏好、你的工作流、你的常见错误。它不是因为你教过它，而是因为它和你一起工作过，它「记得」这些。

这才是真正的「智能体」——不仅仅是智能，还能自主学习和成长。

项目信息：

• GitHub：https://github.com/yakuphanycl/instinct
• PyPI：instinct-mcp
• 作者：Yakuphan Yucel
• 开源协议：MIT

一句话总结：instinct 让 AI Agent 从「每次都从零开始」变成「越用越懂你」，用置信度驱动的自动学习，实现了真正的「从经验中长大」。