- CHANGELOG.md:v2.8.0 条目(中英双语); - README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明); - doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制); - skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/ require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过); - 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
16 KiB
Executable File
这是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 的“认知编译”
你描述的人类学习过程非常准确:
第一次:
仔细思考
↓
尝试
↓
犯错
↓
修正
第二次:
仍然需要思考
↓
但已经有经验
第三次:
开始形成套路
多次之后:
“我知道怎么做了”
↓
不再重新思考
↓
直接执行
传统 Agent:
User
↓
LLM
↓
Tool
↓
LLM
↓
Tool
↓
LLM
每次任务都重新付出推理成本。
你想让 Marqdo 变成:
新任务
│
▼
是否已经学会?
/ \
是 否
│ │
▼ ▼
已编译 mq.md LLM 推理
│ │
▼ ▼
低成本执行 执行 + 观察
│
▼
沉淀 mq.md
│
▼
验证 / 优化
│
▼
编译成 Skill
我认为这个想法非常漂亮。
2. 而且这和 Marqdo 的语言设计天然吻合
这可能是你整个项目最重要的一次“闭环”。
你前面定义:
.mq.md= Markdown + 可执行程序 + 知识。
现在 Agent 又产生:
.mq.md= Agent 学会的经验。
于是:
Agent
│
│ 学习
▼
.mq.md
│
┌───────┼────────┐
↓ ↓ ↓
知识 策略 程序
│ │ │
└───────┼────────┘
▼
Agent Skill
│
▼
低成本执行
这就非常有意思了。
Agent 的 memory 不再是一段向量 embedding,也不只是聊天历史。
它是:
可阅读、可修改、可验证、可执行的知识程序。
这才是真正的 Marqdo-native Agent。
3. 你现在的 Agent 已经有这个雏形,但还没有真正“学习”
从你现在的代码看,已经存在:
reuse
near_match
soft_match
promote
improve_every = 3
llm_free
这些机制实际上已经在做:
经验复用。
例如当前逻辑会查找已有 KB,如果命中 llm_free skill,就可以直接运行 resource,而不是再让父 Agent 做一轮 LLM 推理。
这是很好的基础。
但我认为:
Reuse ≠ Learning。
现在更像:
成功任务
↓
保存
↓
以后查找
↓
复用
而你现在构想的是:
成功任务
↓
观察多次执行
↓
抽象共同结构
↓
去掉偶然信息
↓
形成一般策略
↓
验证
↓
编译
↓
以后低成本执行
这两者差距非常大。
4. 我甚至建议你不要叫它 Memory
我会给它一个更有 Marqdo 味道的名字:
Skill Compilation
或者:
Experience Compilation
甚至:
Cognitive Compilation
整个过程:
Experience
↓
Episodic Trace
↓
Pattern Extraction
↓
Generalization
↓
Marqdo Skill
↓
Validation
↓
Compiled Skill
然后 Agent 不再只是:
“记住我以前做过什么。”
而是:
“把以前的思考编译成以后不需要思考的程序。”
我觉得这是一个非常强的概念。
5. 例如真的可以这样工作
第一次:
用户:
把这个 CSV 中年龄大于 18 的用户筛出来,并按照年龄排序。
Agent:
LLM reasoning
↓
读取 CSV
↓
分析结构
↓
过滤
↓
排序
↓
输出
产生:
.marqdo/agent-runs/xxx.mq.md
第二次用户:
把另一个 CSV 中年龄大于 18 的用户筛出来,并按照年龄排序。
Agent 发现:
intent similarity = 0.94
于是:
REUSE
直接调用之前的程序。
第三、第四、第五次:
Agent 发现:
same structure
different file
different column names
这时候不应该继续保存五个:
task1.mq.md
task2.mq.md
task3.mq.md
task4.mq.md
task5.mq.md
而应该让 LLM 总结:
# 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 |
|---|---|
| ... | ... |
然后:
skill_status = compiled
6. 更关键的是:这个 mq.md 可以逐渐“去 LLM 化”
这是你刚才说的:
“其中可以使用非常少的大模型思考,或者使用类似 Jev 的决策模型,或者干脆只使用分支控制。”
我非常赞同。
我甚至认为这应该成为 Marqdo Agent 的核心架构。
可以设计成一个:
Cognitive Cost Ladder
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
新问题:
Full LLM
↓
learn
↓
Marqdo Skill
↓
validation
↓
Level 2/1
于是 Agent 会越来越“便宜”。
7. 这甚至给你提供了一个极漂亮的学习曲线
假设一个任务第一次需要:
8 次 LLM calls
第二次:
5 次
第三次:
3 次
学习完成:
0 次
或者:
1 次 small model
这时候你就有一个非常漂亮的指标:
Reasoning Amortization
定义:
C_n =
\frac{
\text{LLM inference cost over first } n \text{ executions}
}{n}
随着执行次数增加:
Cost
│\
│ \
│ \
│ \
│ \____
│ ─────────
└───────────────────
executions
这甚至解决了你之前担心的 Marqdo 性能难以证明的问题。
你之前不知道怎么证明:
Marqdo 比 Python 更适合 AI。
但现在你可以研究:
Marqdo Agent 能否把高成本 LLM reasoning 逐渐编译成低成本 executable knowledge?
这个是一个非常明确、可测量、而且很有研究价值的问题。
8. 但是这里有一个非常重要的危险
你说:
“超过三次调用就自动总结。”
我建议:
不要真的这么简单。
三次可以作为:
触发学习候选
但不能作为:
自动认为已经学会。
否则会发生:
第一次:特殊情况
第二次:特殊情况
第三次:特殊情况
LLM 总结:
General rule:
...
然后把偶然性错误“编译”进 Skill。
这会非常危险。
9. 我建议建立“经验 → 技能”的四阶段
Stage 1 — Episode
每次任务产生:
task
context
actions
tool calls
observations
errors
result
cost
例如:
episode-001.mq.md
episode-002.mq.md
episode-003.mq.md
Stage 2 — Candidate Skill
达到阈值之后:
3+ similar episodes
让 LLM 总结:
candidate.mq.md
但它还是:
candidate
而不是正式 skill。
Stage 3 — Verification
用历史任务重新运行:
episode 1
episode 2
episode 3
测试:
candidate skill
如果:
3 / 3 success
再加新的 held-out task:
episode 4
如果:
4 / 4
才提高 confidence。
Stage 4 — Compilation
最后:
candidate
↓
verified
↓
compiled
此时才允许:
llm_free = true
你目前的系统已经有 llm_free 命中后直接运行 resource 的机制。
我认为未来这个 flag 不应该是人工/静态指定的属性,而应该成为学习系统的产物。
10. 甚至可以让 mq.md 自己记录“学习程度”
比如:
---
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
---
然后正文:
# CSV 成人用户筛选
## Intent
筛选年龄大于 18 岁的用户。
## Procedure
- 读取 CSV
- 判断 age
- 过滤
- 排序
## Fallback
如果无法确定 age 字段:
> ask_llm
## Verification
| Case | Result |
|---|---|
| case-001 | ✓ |
| case-002 | ✓ |
| case-003 | ✓ |
| case-004 | ✓ |
注意这个设计里非常重要的一点:
Skill 本身可以包含一个 fallback 到 LLM 的路径。
所以不是:
学会 / 不会
而是:
确定部分 → deterministic
不确定部分 → small model
真正未知 → full LLM
这就非常接近人类的实际认知过程。
11. 我甚至会把 Agent 的运行模型改成这样
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 很难天然拥有的优势
因为“学习结果”不是:
{
"memory": "..."
}
也不是:
embedding vector
而是:
learned_skill.mq.md
这意味着用户可以:
打开
阅读
修改
运行
测试
分享
Git commit
diff
fork
甚至:
Agent A
↓
learned_skill.mq.md
↓
Agent B
Agent 的经验第一次成为一种真正可移植的软件 artifact。
我认为这是你整个 Marqdo 项目里非常值得深入挖掘的东西。
13. 而且它和你前面说的“Executable Knowledge”完全闭环
你之前提出:
Executable Document
↓
Executable Knowledge Base
现在再往前一步:
Executable Knowledge
↓
Agent Experience
↓
Agent Learning
↓
Compiled Knowledge
↓
Executable Skill
于是整个 Marqdo 可以形成:
┌───────────────┐
│ Human │
└───────┬───────┘
│
▼
Natural Task
│
▼
AI Reasoning
│
▼
Executable Work
│
▼
.mq.md
│
┌───────┴───────┐
▼ ▼
Knowledge Skill
│ │
└───────┬───────┘
▼
Future Agent
│
▼
Less Reasoning
│
▼
More Execution
这就是我现在最喜欢 Marqdo 的地方:
Agent 不只是使用知识库;Agent 会把自己的经验沉淀成知识库,然后知识库反过来改变 Agent 的计算方式。
这是一个真正的闭环。
最后,我会建议你对现有 Agent 做一个非常明确的架构升级
你现在已经有:
reuse
near_match
soft_match
promote
improve_every=3
llm_free
所以完全没必要推倒重来。
我会把它演化成:
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 和你之前苦恼的“性能怎么证明”三个问题,反而被同一个实验串起来了。