doc/next/002: 智能体框架「认知编译」构想(Learning → Compilation)

用户维护文档归档:每次执行沉淀 mq.md;>3 次调用自动总结优化出记忆文档;
完全学会后降能耗运行(少 LLM 思考 / Jev 决策模型 / 纯分支控制)。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
cflmyandCursor committed 2026-09-23 13:19:56 +08:00
1 parent 5fffb800f9
commit cba51238b6
1 file changed
+933
+933
View File
@@ -0,0 +1,933 @@
这是marqdo的智能体框架,我一直都不满意,我认为marqdo的智能体框架应该更好才对,因为marqdo本身就是一门极好的AI原生语言,针对这个智能体框架,我的构想是,每次执行,智能体都会沉淀mq.md文档,超过三次的调用就会自动总结优化出一份类似与记忆的mq.md文档,把每一步都拆解的非常好,类似与人类的某些学习过程,当完全学习到了一些内容,实际上后续就可以不再每次都聚精会神,而是用一种较低能耗运行,就像是我们沉淀下来的mq.md代码,其中可以使用非常少的大模型思考,或者使用类似Jev的决策模型,或者干脆只使用分支控制,之后调用即可,你觉得呢?
对,而且我现在觉得你这个构想**很可能比目前的 Agent 框架本身更接近 Marqdo 真正应该成为的东西**。
我仔细看了你上传的 `ext/ai/agent`。其实你已经无意中铺好了不少基础:现在的 `plan` 已经有 `reuse`、`near_match`、`soft_match`、`promote`、`improve_every=3` 和 `kb_dir=.marqdo/agent-kb`;命中已有 skill 后甚至可以走 `llm_free` 路径。 而且现有逻辑已经会把成功的 workbook promote 到 agent KB。
**所以我觉得你现在缺的不是“memory”,而是一个更深的概念:Learning → Compilation。**
---
# 1. 我会把你想做的东西定义成:Agent 的“认知编译”
你描述的人类学习过程非常准确:
```text
第一次:
仔细思考
↓
尝试
↓
犯错
↓
修正
第二次:
仍然需要思考
↓
但已经有经验
第三次:
开始形成套路
多次之后:
“我知道怎么做了”
↓
不再重新思考
↓
直接执行
```
传统 Agent:
```text
User
↓
LLM
↓
Tool
↓
LLM
↓
Tool
↓
LLM
```
每次任务都重新付出推理成本。
你想让 Marqdo 变成:
```text
新任务
│
▼
是否已经学会?
/ \
是 否
│ │
▼ ▼
已编译 mq.md LLM 推理
│ │
▼ ▼
低成本执行 执行 + 观察
│
▼
沉淀 mq.md
│
▼
验证 / 优化
│
▼
编译成 Skill
```
我认为这个想法**非常漂亮**。
---
# 2. 而且这和 Marqdo 的语言设计天然吻合
这可能是你整个项目最重要的一次“闭环”。
你前面定义:
> `.mq.md` = Markdown + 可执行程序 + 知识。
现在 Agent 又产生:
> `.mq.md` = Agent 学会的经验。
于是:
```text
Agent
│
│ 学习
▼
.mq.md
│
┌───────┼────────┐
↓ ↓ ↓
知识 策略 程序
│ │ │
└───────┼────────┘
▼
Agent Skill
│
▼
低成本执行
```
这就非常有意思了。
**Agent 的 memory 不再是一段向量 embedding,也不只是聊天历史。**
它是:
> **可阅读、可修改、可验证、可执行的知识程序。**
这才是真正的 **Marqdo-native Agent**。
---
# 3. 你现在的 Agent 已经有这个雏形,但还没有真正“学习”
从你现在的代码看,已经存在:
```text
reuse
near_match
soft_match
promote
improve_every = 3
llm_free
```
这些机制实际上已经在做:
> **经验复用。**
例如当前逻辑会查找已有 KB,如果命中 `llm_free` skill,就可以直接运行 resource,而不是再让父 Agent 做一轮 LLM 推理。
这是很好的基础。
但我认为:
> **Reuse ≠ Learning。**
现在更像:
```text
成功任务
↓
保存
↓
以后查找
↓
复用
```
而你现在构想的是:
```text
成功任务
↓
观察多次执行
↓
抽象共同结构
↓
去掉偶然信息
↓
形成一般策略
↓
验证
↓
编译
↓
以后低成本执行
```
这两者差距非常大。
---
# 4. 我甚至建议你不要叫它 Memory
我会给它一个更有 Marqdo 味道的名字:
## **Skill Compilation**
或者:
## **Experience Compilation**
甚至:
## **Cognitive Compilation**
整个过程:
```text
Experience
↓
Episodic Trace
↓
Pattern Extraction
↓
Generalization
↓
Marqdo Skill
↓
Validation
↓
Compiled Skill
```
然后 Agent 不再只是:
> “记住我以前做过什么。”
而是:
> **“把以前的思考编译成以后不需要思考的程序。”**
我觉得这是一个非常强的概念。
---
# 5. 例如真的可以这样工作
第一次:
用户:
> 把这个 CSV 中年龄大于 18 的用户筛出来,并按照年龄排序。
Agent:
```text
LLM reasoning
↓
读取 CSV
↓
分析结构
↓
过滤
↓
排序
↓
输出
```
产生:
```text
.marqdo/agent-runs/xxx.mq.md
```
第二次用户:
> 把另一个 CSV 中年龄大于 18 的用户筛出来,并按照年龄排序。
Agent 发现:
```text
intent similarity = 0.94
```
于是:
```text
REUSE
```
直接调用之前的程序。
---
第三、第四、第五次:
Agent 发现:
```text
same structure
different file
different column names
```
这时候不应该继续保存五个:
```text
task1.mq.md
task2.mq.md
task3.mq.md
task4.mq.md
task5.mq.md
```
而应该让 LLM 总结:
```markdown
# Filter and Sort CSV Users
## Preconditions
- Input contains user records.
- An age field exists.
## Procedure
1. Read the input table.
2. Keep rows where `age > 18`.
3. Sort by `age` ascending.
## Variables
- `input`
- `age_field`
- `output`
## Exceptions
- Missing age field
- Invalid age
## Examples
| Input | Output |
|---|---|
| ... | ... |
```
然后:
```text
skill_status = compiled
```
---
# 6. 更关键的是:这个 mq.md 可以逐渐“去 LLM 化”
这是你刚才说的:
> “其中可以使用非常少的大模型思考,或者使用类似 Jev 的决策模型,或者干脆只使用分支控制。”
**我非常赞同。**
我甚至认为这应该成为 Marqdo Agent 的核心架构。
可以设计成一个:
# Cognitive Cost Ladder
```text
Level 0
Deterministic Marqdo
│
▼
Level 1
Rule / Branch
│
▼
Level 2
Small decision model
│
▼
Level 3
Small LLM
│
▼
Level 4
Full LLM reasoning
│
▼
Level 5
Multi-agent exploration
```
新问题:
```text
Full LLM
↓
learn
↓
Marqdo Skill
↓
validation
↓
Level 2/1
```
于是 Agent 会越来越“便宜”。
---
# 7. 这甚至给你提供了一个极漂亮的学习曲线
假设一个任务第一次需要:
```text
8 次 LLM calls
```
第二次:
```text
5 次
```
第三次:
```text
3 次
```
学习完成:
```text
0 次
```
或者:
```text
1 次 small model
```
这时候你就有一个非常漂亮的指标:
## Reasoning Amortization
定义:
$$
C_n =
\frac{
\text{LLM inference cost over first } n \text{ executions}
}{n}
$$
随着执行次数增加:
```text
Cost
│\
│ \
│ \
│ \
│ \____
│ ─────────
└───────────────────
executions
```
**这甚至解决了你之前担心的 Marqdo 性能难以证明的问题。**
你之前不知道怎么证明:
> Marqdo 比 Python 更适合 AI。
但现在你可以研究:
> **Marqdo Agent 能否把高成本 LLM reasoning 逐渐编译成低成本 executable knowledge?**
这个是一个非常明确、可测量、而且很有研究价值的问题。
---
# 8. 但是这里有一个非常重要的危险
你说:
> “超过三次调用就自动总结。”
我建议:
**不要真的这么简单。**
三次可以作为:
> **触发学习候选**
但不能作为:
> **自动认为已经学会。**
否则会发生:
```text
第一次:特殊情况
第二次:特殊情况
第三次:特殊情况
```
LLM 总结:
```text
General rule:
...
```
然后把偶然性错误“编译”进 Skill。
这会非常危险。
---
# 9. 我建议建立“经验 → 技能”的四阶段
## Stage 1 — Episode
每次任务产生:
```text
task
context
actions
tool calls
observations
errors
result
cost
```
例如:
```text
episode-001.mq.md
episode-002.mq.md
episode-003.mq.md
```
---
## Stage 2 — Candidate Skill
达到阈值之后:
```text
3+ similar episodes
```
让 LLM 总结:
```text
candidate.mq.md
```
但它还是:
> **candidate**
而不是正式 skill。
---
## Stage 3 — Verification
用历史任务重新运行:
```text
episode 1
episode 2
episode 3
```
测试:
```text
candidate skill
```
如果:
```text
3 / 3 success
```
再加新的 held-out task:
```text
episode 4
```
如果:
```text
4 / 4
```
才提高 confidence。
---
## Stage 4 — Compilation
最后:
```text
candidate
↓
verified
↓
compiled
```
此时才允许:
```text
llm_free = true
```
你目前的系统已经有 `llm_free` 命中后直接运行 resource 的机制。
我认为未来这个 flag **不应该是人工/静态指定的属性,而应该成为学习系统的产物。**
---
# 10. 甚至可以让 mq.md 自己记录“学习程度”
比如:
```yaml
---
type: skill
status: compiled
confidence: 0.97
evidence: 17
success_rate: 0.941
llm_free: true
created_from: 6c8...
last_validated: 2026-09-23
avg_reasoning_cost: 0.2
---
```
然后正文:
```markdown
# CSV 成人用户筛选
## Intent
筛选年龄大于 18 岁的用户。
## Procedure
- 读取 CSV
- 判断 age
- 过滤
- 排序
## Fallback
如果无法确定 age 字段:
> ask_llm
## Verification
| Case | Result |
|---|---|
| case-001 | ✓ |
| case-002 | ✓ |
| case-003 | ✓ |
| case-004 | ✓ |
```
注意这个设计里非常重要的一点:
> **Skill 本身可以包含一个 fallback 到 LLM 的路径。**
所以不是:
```text
学会 / 不会
```
而是:
```text
确定部分 → deterministic
不确定部分 → small model
真正未知 → full LLM
```
这就非常接近人类的实际认知过程。
---
# 11. 我甚至会把 Agent 的运行模型改成这样
```text
User Task
│
▼
┌─────────────────┐
│ Skill Resolver │
└────────┬────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
Exact Near Unknown
Hit Hit
│ │ │
▼ ▼ ▼
mq.md execute small model Full LLM
│ │ │
└────────────┼────────────┘
▼
Result
│
▼
Episode
│
▼
Experience Store
│
┌────────┴────────┐
│ │
repeated? novel?
│
▼
Skill synthesis
│
▼
Verification
│
▼
Compilation
│
▼
mq.md Skill
```
**这就已经不是普通 Agent framework 了。**
它是一个:
> **Self-compiling Agent**
---
# 12. 而 Marqdo 在这里有一个其他 Agent framework 很难天然拥有的优势
因为“学习结果”不是:
```json
{
"memory": "..."
}
```
也不是:
```text
embedding vector
```
而是:
```text
learned_skill.mq.md
```
这意味着用户可以:
```text
打开
阅读
修改
运行
测试
分享
Git commit
diff
fork
```
甚至:
```text
Agent A
↓
learned_skill.mq.md
↓
Agent B
```
**Agent 的经验第一次成为一种真正可移植的软件 artifact。**
我认为这是你整个 Marqdo 项目里非常值得深入挖掘的东西。
---
# 13. 而且它和你前面说的“Executable Knowledge”完全闭环
你之前提出:
```text
Executable Document
↓
Executable Knowledge Base
```
现在再往前一步:
```text
Executable Knowledge
↓
Agent Experience
↓
Agent Learning
↓
Compiled Knowledge
↓
Executable Skill
```
于是整个 Marqdo 可以形成:
```text
┌───────────────┐
│ Human │
└───────┬───────┘
│
▼
Natural Task
│
▼
AI Reasoning
│
▼
Executable Work
│
▼
.mq.md
│
┌───────┴───────┐
▼ ▼
Knowledge Skill
│ │
└───────┬───────┘
▼
Future Agent
│
▼
Less Reasoning
│
▼
More Execution
```
这就是我现在最喜欢 Marqdo 的地方:
> **Agent 不只是使用知识库;Agent 会把自己的经验沉淀成知识库,然后知识库反过来改变 Agent 的计算方式。**
这是一个真正的闭环。
---
## 最后,我会建议你对现有 Agent 做一个非常明确的架构升级
你现在已经有:
```text
reuse
near_match
soft_match
promote
improve_every=3
llm_free
```
所以**完全没必要推倒重来**。
我会把它演化成:
```text
Current Agent
│
┌────────┴────────┐
│ │
Execution Experience
│ │
│ ▼
│ Episode Store
│ │
│ ≥ N similar
│ │
│ ▼
│ Skill Synthesis
│ │
│ ▼
│ Skill Validation
│ │
│ ▼
│ Skill Compilation
│ │
└─────────────┬───┘
▼
.mq.md Skill
│
┌────────┼────────┐
▼ ▼ ▼
Branch Small LLM Full LLM
```
而且你当前已经有一个非常好的“终点”:**当 child 返回 value 时,可以 deterministic 地 solidify,而不是再次让父 LLM 发明 patch。** 当前代码已经明确这么处理。
所以我会把你的下一版 Agent 的核心 slogan 直接定成:
> **Think → Execute → Learn → Compile → Reuse**
或者更 Marqdo 一点:
> **Every successful thought can become executable knowledge.**
这比“Marqdo 有一个 Agent framework”强得多。
而且这件事**非常适合做你前面说的论文实验**:你甚至可以测一个 Agent 在重复任务上的 **LLM calls / tokens / latency / success rate 随经验次数变化的曲线**,直接验证“推理成本被 mq.md 技能逐渐摊销”的假设。这样 Marqdo 的 Agent、Executable Knowledge 和你之前苦恼的“性能怎么证明”三个问题,反而被同一个实验串起来了。