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