diff --git a/doc/next/002.md b/doc/next/002.md new file mode 100644 index 0000000..ec18a9e --- /dev/null +++ b/doc/next/002.md @@ -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 和你之前苦恼的“性能怎么证明”三个问题,反而被同一个实验串起来了。