Files
marqdo/doc/next/002.md
T
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- 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。
2026-11-18 10:29:26 +08:00

16 KiB
Executable File
Raw Blame History

这是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 和你之前苦恼的“性能怎么证明”三个问题,反而被同一个实验串起来了。