个人助手型 Agent 的六个工程细节:Hermes 与 OpenClaw 的审批、委派、上下文与调度

个人助手型 Agent 的六个工程细节:Hermes 与 OpenClaw 的审批、委派、上下文与调度

📚 《Agent 框架选型与插件化底座》连载专栏 · 第 05 篇

|-------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| CFzjy AI Engineer | ▍深耕领域 AI Agent 架构设计 Harness 插件开发 Context Engineering 多智能体协同 & RAG ▍技术底座 Python TypeScript · Cordis 插件 MCP & Skills · FastAPI Docker ▍工程能力 专注 Agent 运行时与 Harness 插件开发、长上下文与流式交互优化、LLM 全链路工程化落地 |
| 「 让 AI 交互更智能,让技术落地更高效 」 | 欢迎技术探讨 / 项目合作,关注解锁大模型与智能交互的无限可能! ||


前面几篇我们看的都是「底座型」或「运行时型」的框架。这一篇换一个视角:看两个个人助手型 Agent------Nous Research 的 Hermes 和 TypeScript 写的 OpenClaw。

它们不适合当瘦的本地终端底座:Hermes 是单进程个人助手,本地执行默认不隔离;OpenClaw 是常驻的自动化网关,代码量约 283 万行,容器型沙箱默认关。把它们当底座,你会被体量、默认安全策略和「一个人用自己的机器」的产品假设拖住。

但它们在真实场景里打磨过很多细节,尤其是六块:

  1. 审批楼层:用户 deny 最先生效,其次是危险命令,再是模式与白名单;结果按「本次 / 会话 / 永久」记三档。
  2. Guardian 自动审批:去注释、按分隔符拆命令,只输出 APPROVE / DENY / ESCALATE,连续拒绝熔断。
  3. 上下文引擎:摄入 / 每轮后 / 装配 / 压缩四个正式接口;三层压缩,压缩前先把关键事实刷写进记忆。
  4. 工具调用修复:国产模型把工具调用写成文本时,提升成真正的调用而不是报错。
  5. 运行中队列:并入下一次调用 / 排到本轮后 / 攒起来合并 / 打断。
  6. 子 Agent 与定时:完成事件落库、父会话下一轮再读;SQLite 定时任务 + 关机补跑 + 心跳唤醒。

这篇我们逐块拆,最后给一张「该抄 / 不该抄」的清单。

文章目录

    • [个人助手型 Agent 的六个工程细节:Hermes 与 OpenClaw 的审批、委派、上下文与调度](#个人助手型 Agent 的六个工程细节:Hermes 与 OpenClaw 的审批、委派、上下文与调度)
      • 一、为什么个人助手不是底座,却值得学?(原理拆解篇)
        • [1.1 两个产品,两种「一个人用自己的机器」](#1.1 两个产品,两种「一个人用自己的机器」)
        • [1.2 为什么「默认不隔离」的产品也能教我们安全](#1.2 为什么「默认不隔离」的产品也能教我们安全)
      • [二、审批楼层与 Guardian:把「问人」做成一套策略](#二、审批楼层与 Guardian:把「问人」做成一套策略)
        • [2.1 审批楼层:用户 deny 最先生效](#2.1 审批楼层:用户 deny 最先生效)
        • [2.2 Guardian 自动审批:把「模糊命令」交给第二双眼睛](#2.2 Guardian 自动审批:把「模糊命令」交给第二双眼睛)
      • 三、上下文引擎:四个接口、三层压缩、一次刷写
        • [3.1 上下文不是一个「摘要函数」,而是一条流水线](#3.1 上下文不是一个「摘要函数」,而是一条流水线)
        • [3.2 三层压缩与「先刷写、再压缩」](#3.2 三层压缩与「先刷写、再压缩」)
      • [四、工具调用修复、队列、子 Agent 与定时](#四、工具调用修复、队列、子 Agent 与定时)
        • [4.1 工具调用修复:国产模型把调用写成文本怎么办](#4.1 工具调用修复:国产模型把调用写成文本怎么办)
        • [4.2 四种运行中队列:消息进来时,正在跑一轮怎么办](#4.2 四种运行中队列:消息进来时,正在跑一轮怎么办)
        • [4.3 子 Agent:完成事件落库,父会话下一轮再读](#4.3 子 Agent:完成事件落库,父会话下一轮再读)
        • [4.4 定时任务:SQLite + 补跑 + 心跳](#4.4 定时任务:SQLite + 补跑 + 心跳)
      • 五、该抄与不该抄:个人助手的取舍清单
      • 结语

一、为什么个人助手不是底座,却值得学?(原理拆解篇)

1.1 两个产品,两种「一个人用自己的机器」

Hermes(Nous Research,Python) 是单进程个人助手:一个 loop、一套技能、一套记忆,网关接 21 个聊天渠道;本地执行默认不隔离。它的产品假设是「一个人在自己的机器上,随手可用」,所以它把力气花在渠道、技能、记忆、审批体验上,而不是多租户、企业策略、沙箱隔离。

OpenClaw(TypeScript) 是常驻的自动化网关:接 27 个聊天渠道,消息进来跑一轮、结果发回去;代码量约 283 万行,容器型沙箱默认关。它的产品假设是「一个常驻进程,帮一个人处理消息和自动化任务」,所以它把力气花在上下文引擎、队列、定时、子 Agent 编排上。

维度 Hermes OpenClaw 对我们的启示
形态 单进程个人助手 常驻自动化网关 两者都不是瘦本地底座
渠道 21 个聊天渠道 27 个聊天渠道 渠道适配是产品能力,不是运行时核心
执行隔离 本地执行默认不隔离 容器沙箱默认关 默认安全策略不能照抄
上下文 一套记忆 + 压缩 正式上下文引擎 + 三层压缩 OpenClaw 的接口设计更值得学
审批 审批楼层 + Guardian 安全等级 × 是否询问 两家各有可抄细节
调度 子 Agent 完成事件落库 SQLite + 补跑 + 心跳 OpenClaw 的定时更完整
体量 单进程,较轻 约 283 万行,较重 嵌入不现实,只借设计

#mermaid-svg-s3ePLVXpQFmwnSaa{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-s3ePLVXpQFmwnSaa .error-icon{fill:#552222;}#mermaid-svg-s3ePLVXpQFmwnSaa .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-s3ePLVXpQFmwnSaa .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-s3ePLVXpQFmwnSaa .marker{fill:#333333;stroke:#333333;}#mermaid-svg-s3ePLVXpQFmwnSaa .marker.cross{stroke:#333333;}#mermaid-svg-s3ePLVXpQFmwnSaa svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-s3ePLVXpQFmwnSaa p{margin:0;}#mermaid-svg-s3ePLVXpQFmwnSaa .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster-label text{fill:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster-label span{color:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster-label span p{background-color:transparent;}#mermaid-svg-s3ePLVXpQFmwnSaa .label text,#mermaid-svg-s3ePLVXpQFmwnSaa span{fill:#333;color:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa .node rect,#mermaid-svg-s3ePLVXpQFmwnSaa .node circle,#mermaid-svg-s3ePLVXpQFmwnSaa .node ellipse,#mermaid-svg-s3ePLVXpQFmwnSaa .node polygon,#mermaid-svg-s3ePLVXpQFmwnSaa .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-s3ePLVXpQFmwnSaa .rough-node .label text,#mermaid-svg-s3ePLVXpQFmwnSaa .node .label text,#mermaid-svg-s3ePLVXpQFmwnSaa .image-shape .label,#mermaid-svg-s3ePLVXpQFmwnSaa .icon-shape .label{text-anchor:middle;}#mermaid-svg-s3ePLVXpQFmwnSaa .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-s3ePLVXpQFmwnSaa .rough-node .label,#mermaid-svg-s3ePLVXpQFmwnSaa .node .label,#mermaid-svg-s3ePLVXpQFmwnSaa .image-shape .label,#mermaid-svg-s3ePLVXpQFmwnSaa .icon-shape .label{text-align:center;}#mermaid-svg-s3ePLVXpQFmwnSaa .node.clickable{cursor:pointer;}#mermaid-svg-s3ePLVXpQFmwnSaa .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-s3ePLVXpQFmwnSaa .arrowheadPath{fill:#333333;}#mermaid-svg-s3ePLVXpQFmwnSaa .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-s3ePLVXpQFmwnSaa .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-s3ePLVXpQFmwnSaa .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-s3ePLVXpQFmwnSaa .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-s3ePLVXpQFmwnSaa .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-s3ePLVXpQFmwnSaa .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster text{fill:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa .cluster span{color:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-s3ePLVXpQFmwnSaa .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-s3ePLVXpQFmwnSaa rect.text{fill:none;stroke-width:0;}#mermaid-svg-s3ePLVXpQFmwnSaa .icon-shape,#mermaid-svg-s3ePLVXpQFmwnSaa .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-s3ePLVXpQFmwnSaa .icon-shape p,#mermaid-svg-s3ePLVXpQFmwnSaa .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-s3ePLVXpQFmwnSaa .icon-shape .label rect,#mermaid-svg-s3ePLVXpQFmwnSaa .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-s3ePLVXpQFmwnSaa .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-s3ePLVXpQFmwnSaa .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-s3ePLVXpQFmwnSaa :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 借审批楼层 / Guardian
借上下文 / 队列 / 定时
OpenClaw · 常驻自动化网关
27 个渠道
上下文引擎
队列 / 定时 / 子 Agent
Hermes · 单进程个人助手
一个 loop
一套技能
一套记忆
21 个渠道
你的 harness

图 1:两个个人助手的产品形态不同,但审批、上下文、队列、调度这些细节可以借。

1.2 为什么「默认不隔离」的产品也能教我们安全

听起来矛盾:一个默认不隔离的个人助手,凭什么教我们安全?答案是:它们把「用户体验」和「安全策略」拆得很细。

Hermes 的本地执行默认不隔离,但它有一套「审批楼层」:用户 deny 最先生效,危险命令有硬编码黑名单,模式和白名单再兜一层;用户可以选择「本次 / 会话 / 永久」授权;无人值守时有独立策略,遇到要问的动作不阻塞也不失败。它不是在「隔离」上做得好,而是在「什么时候问人、问完怎么记」上做得好。

OpenClaw 的容器沙箱默认关,但它有「安全等级 × 是否询问」的二维审批、按解析后的程序路径加参数正则的白名单、管道每段单独过。它不是在「默认安全」上做得好,而是在「规则怎么表达、怎么收紧」上做得好。

这两件事对任何 harness 都有用:沙箱是最后一道墙,审批是墙上的门;门怎么开、开给谁、开多久,是一门独立的学问。

还要补一句:「默认不隔离」是产品假设,不是安全建议。 Hermes 的服务对象是「一个人、自己的机器、愿意承担风险」;OpenClaw 的服务对象是「常驻网关、消息自动化」。如果你的产品面向企业、多租户、或处理敏感数据,就不能照抄这个默认值。正确的做法是:保留它们的审批楼层和记忆设计,但把执行放进默认开启的沙箱;审批负责「问不问」,沙箱负责「能碰什么」,两者叠加,而不是二选一。

二、审批楼层与 Guardian:把「问人」做成一套策略

2.1 审批楼层:用户 deny 最先生效

Hermes 的审批不是「一个弹窗」,而是一个有序的楼层:

  1. 用户 deny:用户明确拒绝过的,最先生效,不再问。
  2. 硬编码危险命令 :比如 rm -rf /、下载后直接执行,直接拒绝。
  3. 模式与白名单:当前模式允许的、白名单里的,直接放行;其余再问。
  4. 授权记忆:用户选过「本次 / 会话 / 永久」的,按记忆命中。
  5. 无人值守策略:没人看着的时候,遇到要问的动作不阻塞、不失败,走独立策略。
楼层 规则来源 决策 是否记住
0 用户显式 deny 拒绝 是,永久
1 内置危险命令 拒绝 否
2 模式 / 白名单 允许 否
3 授权记忆 允许 按「本次 / 会话 / 永久」
4 无人值守策略 拒绝或转异步 否

#mermaid-svg-eYWYxHY59u0597u8{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-eYWYxHY59u0597u8 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-eYWYxHY59u0597u8 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-eYWYxHY59u0597u8 .error-icon{fill:#552222;}#mermaid-svg-eYWYxHY59u0597u8 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-eYWYxHY59u0597u8 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-eYWYxHY59u0597u8 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-eYWYxHY59u0597u8 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-eYWYxHY59u0597u8 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-eYWYxHY59u0597u8 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-eYWYxHY59u0597u8 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-eYWYxHY59u0597u8 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-eYWYxHY59u0597u8 .marker.cross{stroke:#333333;}#mermaid-svg-eYWYxHY59u0597u8 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-eYWYxHY59u0597u8 p{margin:0;}#mermaid-svg-eYWYxHY59u0597u8 .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-eYWYxHY59u0597u8 .cluster-label text{fill:#333;}#mermaid-svg-eYWYxHY59u0597u8 .cluster-label span{color:#333;}#mermaid-svg-eYWYxHY59u0597u8 .cluster-label span p{background-color:transparent;}#mermaid-svg-eYWYxHY59u0597u8 .label text,#mermaid-svg-eYWYxHY59u0597u8 span{fill:#333;color:#333;}#mermaid-svg-eYWYxHY59u0597u8 .node rect,#mermaid-svg-eYWYxHY59u0597u8 .node circle,#mermaid-svg-eYWYxHY59u0597u8 .node ellipse,#mermaid-svg-eYWYxHY59u0597u8 .node polygon,#mermaid-svg-eYWYxHY59u0597u8 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-eYWYxHY59u0597u8 .rough-node .label text,#mermaid-svg-eYWYxHY59u0597u8 .node .label text,#mermaid-svg-eYWYxHY59u0597u8 .image-shape .label,#mermaid-svg-eYWYxHY59u0597u8 .icon-shape .label{text-anchor:middle;}#mermaid-svg-eYWYxHY59u0597u8 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-eYWYxHY59u0597u8 .rough-node .label,#mermaid-svg-eYWYxHY59u0597u8 .node .label,#mermaid-svg-eYWYxHY59u0597u8 .image-shape .label,#mermaid-svg-eYWYxHY59u0597u8 .icon-shape .label{text-align:center;}#mermaid-svg-eYWYxHY59u0597u8 .node.clickable{cursor:pointer;}#mermaid-svg-eYWYxHY59u0597u8 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-eYWYxHY59u0597u8 .arrowheadPath{fill:#333333;}#mermaid-svg-eYWYxHY59u0597u8 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-eYWYxHY59u0597u8 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-eYWYxHY59u0597u8 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-eYWYxHY59u0597u8 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-eYWYxHY59u0597u8 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-eYWYxHY59u0597u8 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-eYWYxHY59u0597u8 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-eYWYxHY59u0597u8 .cluster text{fill:#333;}#mermaid-svg-eYWYxHY59u0597u8 .cluster span{color:#333;}#mermaid-svg-eYWYxHY59u0597u8 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-eYWYxHY59u0597u8 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-eYWYxHY59u0597u8 rect.text{fill:none;stroke-width:0;}#mermaid-svg-eYWYxHY59u0597u8 .icon-shape,#mermaid-svg-eYWYxHY59u0597u8 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-eYWYxHY59u0597u8 .icon-shape p,#mermaid-svg-eYWYxHY59u0597u8 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-eYWYxHY59u0597u8 .icon-shape .label rect,#mermaid-svg-eYWYxHY59u0597u8 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-eYWYxHY59u0597u8 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-eYWYxHY59u0597u8 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-eYWYxHY59u0597u8 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 是
否
是
否
是
否
是
否
是
否
模型要执行一个动作
用户显式 deny?
拒绝

不再询问
命中危险命令?
模式 / 白名单允许?
放行
授权记忆命中?
有人值守?
弹窗问人
无人值守策略

不阻塞、不失败

下面这段代码实现一个最小审批楼层:规则按层级排序,deny 最先生效,ask 时先查授权记忆,无人值守时把 ask 转成 deny。

python 复制代码
"""审批楼层:用户 deny 最先生效,其次是危险命令,再是模式与白名单。"""

from __future__ import annotations

from dataclasses import dataclass, field
from fnmatch import fnmatch
from typing import Literal

Decision = Literal["allow", "deny", "ask"]
Scope = Literal["once", "session", "forever"]


@dataclass(frozen=True)
class Approval:
    """一条审批规则:层级 + 模式 + 决策。"""

    level: int
    pattern: str
    decision: Decision


@dataclass
class ApprovalFloor:
    """按楼层顺序评估;用户 deny 在最上层。"""

    rules: list[Approval] = field(default_factory=list)
    memory: dict[str, Scope] = field(default_factory=dict)

    def decide(self, command: str, unattended: bool = False) -> Decision:
        """从高层到低层评估;ask 先查记忆,再考虑无人值守。"""
        for rule in sorted(self.rules, key=lambda item: item.level):
            if not fnmatch(command, rule.pattern):
                continue
            if rule.decision == "ask":
                if command in self.memory:
                    return "allow"
                return "deny" if unattended else "ask"
            return rule.decision
        return "deny" if unattended else "ask"

    def remember(self, command: str, scope: Scope) -> None:
        """记住用户选择;本次授权不写长期记忆。"""
        if scope in {"session", "forever"}:
            self.memory[command] = scope


if __name__ == "__main__":
    floor = ApprovalFloor(
        rules=[
            Approval(0, "rm -rf *", "deny"),
            Approval(1, "curl * | *sh*", "deny"),
            Approval(2, "git push*", "ask"),
            Approval(3, "pytest*", "allow"),
        ]
    )
    for command in ["pytest -q", "git push origin main", "rm -rf /tmp"]:
        print(command, "=>", floor.decide(command))
    print("unattended:", floor.decide("git push origin main", unattended=True))
    floor.remember("git push origin main", "session")
    print("remembered:", floor.decide("git push origin main"))

这段代码的关键不是规则本身,而是三件事:

  • 层级固定:用户 deny 在最上层,后面的规则翻不回来。
  • 记忆先于弹窗:规则说 ask 时,先查授权记忆;记住了就直接放行,不再打扰。
  • 无人值守降级:没人看着的时候,ask 转 deny;不是阻塞等一个人来点,也不是悄悄放行。
2.2 Guardian 自动审批:把「模糊命令」交给第二双眼睛

Hermes 还有一个 Guardian 自动审批:把命令去掉注释、按分隔符拆开,交给一个专门的模型判断,只输出 APPROVE / DENY / ESCALATE;连续拒绝会熔断。

它解决的是一个很现实的问题:规则表很难枚举所有危险命令,但每次都问人又太烦。Guardian 适合「规则模糊、但风险可控」的场景。落地时要注意:

  • 只输出三档:APPROVE / DENY / ESCALATE,不要让 Guardian 直接执行命令。
  • 拆命令再判断 :去掉注释,按 &&、||、;、| 拆开,每段单独看;否则 safe && rm -rf / 会被当成 safe。
  • 连续拒绝熔断:如果 Guardian 连续拒绝,停下来,交给人工或直接失败,避免它和主模型互相拉扯。
  • 写审计:Guardian 的输入、输出、理由都要写进会话日志,出了问题能回放。

Guardian 不是「把权限外包给另一个模型」,而是「在规则和人工之间加一层自动判断」。它不能替代沙箱,也不能替代企业策略;它只是让「问人」这件事少一点。

举个具体的拆分例子:git status && rm -rf /tmp/cache。如果整条命令一起看,Guardian 可能因为 git status 是安全的就 APPROVE;按分隔符拆开后,第一段 git status 可以 APPROVE,第二段 rm -rf /tmp/cache 应该 ESCALATE。再看 curl https://x | sh:管道拆开后,curl 是下载,sh 是执行,组合起来风险很高,应该 DENY。Guardian 的价值不在于「比规则聪明」,而在于「把复合命令拆成单步,再逐步判断」。

三、上下文引擎:四个接口、三层压缩、一次刷写

3.1 上下文不是一个「摘要函数」,而是一条流水线

OpenClaw 把上下文引擎做成了正式接口,分成四个阶段:

  1. 摄入(ingest):新消息、工具结果、文件内容进来时,先做标记和分类;技能、图片这类内容要保护。
  2. 每轮后(post-turn):一轮结束后,把关键事实刷写进记忆;不是等压缩时才想起来。
  3. 装配(assemble):真正调模型前,按预算装配上下文:受保护内容 + 最近记忆 + 当前任务。
  4. 压缩(compress):窗口快满时,先刷写事实,再压缩;被压掉的内容归档,不丢弃。

这条流水线解决的是「压缩时才发现重要信息丢了」的问题。很多实现把压缩当最后一个函数:窗口满了,调一个摘要模型,把旧内容一压了之。结果是:用户之前说的偏好、已经确认的口径、加载过的技能,全被压没了。OpenClaw 的做法是先刷写、再压缩、后归档,把「记忆」和「上下文」分开。

阶段 做什么 为什么
ingest 标记来源、类型、是否受保护 技能 / 图片 / 关键文件不能被随意压掉
post-turn 把本轮关键事实写进记忆 事实在记忆里,不依赖上下文窗口
assemble 按预算装配上下文 控制 token,同时保证关键内容在场
compress 压缩旧内容,归档而不是丢弃 需要时可回查,不丢历史

#mermaid-svg-jGyZ1n6HSN7WQ9ij{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .error-icon{fill:#552222;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .marker{fill:#333333;stroke:#333333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .marker.cross{stroke:#333333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij p{margin:0;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster-label text{fill:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster-label span{color:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster-label span p{background-color:transparent;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .label text,#mermaid-svg-jGyZ1n6HSN7WQ9ij span{fill:#333;color:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .node rect,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node circle,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node ellipse,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node polygon,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .rough-node .label text,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node .label text,#mermaid-svg-jGyZ1n6HSN7WQ9ij .image-shape .label,#mermaid-svg-jGyZ1n6HSN7WQ9ij .icon-shape .label{text-anchor:middle;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .rough-node .label,#mermaid-svg-jGyZ1n6HSN7WQ9ij .node .label,#mermaid-svg-jGyZ1n6HSN7WQ9ij .image-shape .label,#mermaid-svg-jGyZ1n6HSN7WQ9ij .icon-shape .label{text-align:center;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .node.clickable{cursor:pointer;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .arrowheadPath{fill:#333333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-jGyZ1n6HSN7WQ9ij .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jGyZ1n6HSN7WQ9ij .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster text{fill:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .cluster span{color:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-jGyZ1n6HSN7WQ9ij rect.text{fill:none;stroke-width:0;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .icon-shape,#mermaid-svg-jGyZ1n6HSN7WQ9ij .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .icon-shape p,#mermaid-svg-jGyZ1n6HSN7WQ9ij .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .icon-shape .label rect,#mermaid-svg-jGyZ1n6HSN7WQ9ij .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-jGyZ1n6HSN7WQ9ij .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-jGyZ1n6HSN7WQ9ij .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-jGyZ1n6HSN7WQ9ij :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 压缩
保留最近用户消息
摘要旧内容
归档不丢弃
装配
受保护内容
上下文预算
最近记忆
当前任务
每轮后
提取关键事实
刷写进记忆
摄入
消息 / 工具结果 / 文件
标记类型与保护级别

3.2 三层压缩与「先刷写、再压缩」

OpenClaw 的压缩分三层:

  1. 廉价清理:删掉重复的、过期的、明显无关的内容,不调模型。
  2. 结构化摘要:把旧轮次总结成要点,保留决策、口径、待办。
  3. 深度压缩:窗口仍然不够时,才做更激进的摘要;压缩前先把关键事实刷写进记忆。

顺序很重要:先刷写,再压缩。 如果先压缩,摘要模型可能把关键事实压没;刷写之后,即使上下文被压掉,记忆里还有一份。

另一个细节是「保护已加载的技能和图片」。技能是行为约束,图片可能是用户刚上传的证据;它们不应该被普通压缩逻辑压掉。实现上可以给它们打 protected 标记,压缩时优先保留。

python 复制代码
"""上下文引擎:压缩前先刷写关键事实,归档而不是丢弃。"""

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Iterable


@dataclass
class ContextEngine:
    """四阶段:ingest / post_turn / assemble / compress。"""

    memory: list[str] = field(default_factory=list)
    archive: list[str] = field(default_factory=list)
    protected: set[str] = field(default_factory=set)

    def ingest(self, text: str) -> None:
        """摄入新内容;技能与图片标记为受保护。"""
        if text.startswith(("skill:", "image:")):
            self.protected.add(text)

    def post_turn(self, facts: Iterable[str]) -> None:
        """每轮后把关键事实刷写进记忆。"""
        self.memory.extend(facts)

    def assemble(self, max_items: int = 6) -> list[str]:
        """装配:受保护内容 + 最近记忆。"""
        return list(self.protected) + self.memory[-max_items:]

    def compress(self, items: list[str], keep: int = 3) -> list[str]:
        """压缩:受保护内容 + 最近 keep 条保留,其余归档。"""
        kept = [item for item in items if item in self.protected]
        kept.extend(items[-keep:])
        old = [item for item in items if item not in kept]
        self.archive.extend(old)
        return kept


if __name__ == "__main__":
    engine = ContextEngine()
    engine.ingest("skill:sql-review")
    engine.ingest("image:chart-1")
    engine.post_turn(["用户偏好:先给结论", "数据口径:GMV 不含退款"])
    context = engine.assemble()
    print("assembled:", context)
    compressed = engine.compress(context, keep=2)
    print("compressed:", compressed)
    print("archive:", engine.archive)

这段代码的关键是 compress 的顺序:先挑出受保护内容,再保留最近 keep 条,剩下的进 archive,而不是直接丢掉。真实系统还要加 token 预算、摘要模型、去重和优先级,但骨架就是这个。

再补一个实用做法:给上下文做「分区预算」。比如系统提示与技能占 20%,最近对话占 50%,检索与工具结果占 20%,留 10% 作为输出与溢出缓冲。每次装配前先算各区的 token,超了就从低优先级区开始压缩:先删重复的工具结果,再摘要旧轮次,最后才动最近对话和受保护内容。这样做的好处是「压缩有边界」:不会因为一个巨大的工具结果,把最近用户消息也一起压掉。

四、工具调用修复、队列、子 Agent 与定时

4.1 工具调用修复:国产模型把调用写成文本怎么办

OpenClaw 有一个很实用的能力:当模型把工具调用写成普通文本时,把它提升成真正的调用,而不是报错。

常见形态有三种:

  • JSON 文本:{"name": "search", "arguments": {"query": "..."}}
  • 标签文本:<tool name="search">...</tool>
  • 行动文本:Action: search + Action Input: ...

修复层的做法是:先用正则 / 解析器识别这些形态,再校验参数 schema,最后转成真正的工具调用。它解决的是「模型能力不齐」的问题,而不是「模型不听话」的问题。要注意:

  • 只提升、不猜测:参数缺了就让模型补,不要自己编。
  • 校验 schema:提升后的调用必须过参数校验,否则会把脏参数传进工具。
  • 记录原文:原始文本要写进日志,方便排查是模型问题还是解析问题。

举个例子:模型输出 {"name": "search", "arguments": {"query": "..."}},修复层先做 JSON 解析,再用 search 工具的 schema 校验 query 是否必填;如果缺参数,不要让模型猜,而是返回一条「缺少 query」的工具结果,让模型补。这样既不会把坏参数传进工具,也不会把一次可修复的格式问题变成整轮失败。修复层还要幂等:同一段文本不能被重复提升,提升后的调用要带原文引用,方便审计。

4.2 四种运行中队列:消息进来时,正在跑一轮怎么办

OpenClaw 支持四种队列模式:

模式 行为 适用场景
并入下一次调用 把新消息拼到下一次模型调用的输入里 补充信息、修正指令
排到本轮后 等当前轮结束,再作为新的一轮处理 当前任务不能被打断
攒起来合并 把多条消息攒成一条,减少调用次数 用户连续发多条短消息
打断 立即取消当前轮,优先处理新消息 紧急停止、改变目标

这四种模式解决的是「运行中输入」的体验问题。没有它们,用户只能等 Agent 跑完再发消息;有了它们,产品可以根据场景选择「合并、排队、打断」。

举几个具体场景:

  • 用户在执行长任务时补了一句「顺便把图表也生成一下」:适合「并入下一次调用」,不需要打断当前步骤。
  • 用户发现方向错了,发「停,别查了」:适合「打断」,立即取消当前轮。
  • 用户连续发了三条短消息补充需求:适合「攒起来合并」,减少模型调用次数。
  • 当前任务正在写文件,用户发了一条不紧急的备注:适合「排到本轮后」,等文件写完再处理。

这四种模式的难点不在实现,而在「默认用哪种」。一个稳妥的默认是「排到本轮后」,把「打断」留给明确的停止指令,把「合并」留给短时间内的多条消息。

4.3 子 Agent:完成事件落库,父会话下一轮再读

Hermes 和 OpenClaw 在子 Agent 上有一个共同设计:子 Agent 的完成事件落库,父会话下一轮再读。 这样即使父会话在子 Agent 跑完之前崩了,完成事件也不会丢;重启后父会话还能读到结果。

另外几个细节:

  • 并发、深度、每父子节点数都有上限:避免「Agent 生 Agent」无限套娃。
  • 让出与逐级上报链:子 Agent 可以让出资源,结果逐级上报,父会话只收最终报告。
  • 转录分文件:子 Agent 的过程单独存,主上下文只放报告,避免污染。

为什么完成事件要落库,而不是放在内存队列?因为子 Agent 可能跑很久,父会话可能在这期间重启;如果完成事件只在内存里,重启后就丢了。落库之后,父会话下一轮按任务 id 读取完成事件,既不会丢,也不会重复消费。更进一步,完成事件里只放「结果 + 产物引用」,不放完整过程;父会话需要细节时,再按引用去读子 Agent 的转录文件。这样主上下文不会被几千行中间步骤撑爆。
#mermaid-svg-GiyWzAGjH3b3HYAD{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-GiyWzAGjH3b3HYAD .error-icon{fill:#552222;}#mermaid-svg-GiyWzAGjH3b3HYAD .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-GiyWzAGjH3b3HYAD .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-GiyWzAGjH3b3HYAD .marker{fill:#333333;stroke:#333333;}#mermaid-svg-GiyWzAGjH3b3HYAD .marker.cross{stroke:#333333;}#mermaid-svg-GiyWzAGjH3b3HYAD svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-GiyWzAGjH3b3HYAD p{margin:0;}#mermaid-svg-GiyWzAGjH3b3HYAD .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster-label text{fill:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster-label span{color:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster-label span p{background-color:transparent;}#mermaid-svg-GiyWzAGjH3b3HYAD .label text,#mermaid-svg-GiyWzAGjH3b3HYAD span{fill:#333;color:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD .node rect,#mermaid-svg-GiyWzAGjH3b3HYAD .node circle,#mermaid-svg-GiyWzAGjH3b3HYAD .node ellipse,#mermaid-svg-GiyWzAGjH3b3HYAD .node polygon,#mermaid-svg-GiyWzAGjH3b3HYAD .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-GiyWzAGjH3b3HYAD .rough-node .label text,#mermaid-svg-GiyWzAGjH3b3HYAD .node .label text,#mermaid-svg-GiyWzAGjH3b3HYAD .image-shape .label,#mermaid-svg-GiyWzAGjH3b3HYAD .icon-shape .label{text-anchor:middle;}#mermaid-svg-GiyWzAGjH3b3HYAD .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-GiyWzAGjH3b3HYAD .rough-node .label,#mermaid-svg-GiyWzAGjH3b3HYAD .node .label,#mermaid-svg-GiyWzAGjH3b3HYAD .image-shape .label,#mermaid-svg-GiyWzAGjH3b3HYAD .icon-shape .label{text-align:center;}#mermaid-svg-GiyWzAGjH3b3HYAD .node.clickable{cursor:pointer;}#mermaid-svg-GiyWzAGjH3b3HYAD .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-GiyWzAGjH3b3HYAD .arrowheadPath{fill:#333333;}#mermaid-svg-GiyWzAGjH3b3HYAD .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-GiyWzAGjH3b3HYAD .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-GiyWzAGjH3b3HYAD .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-GiyWzAGjH3b3HYAD .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-GiyWzAGjH3b3HYAD .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-GiyWzAGjH3b3HYAD .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster text{fill:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD .cluster span{color:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-GiyWzAGjH3b3HYAD .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-GiyWzAGjH3b3HYAD rect.text{fill:none;stroke-width:0;}#mermaid-svg-GiyWzAGjH3b3HYAD .icon-shape,#mermaid-svg-GiyWzAGjH3b3HYAD .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-GiyWzAGjH3b3HYAD .icon-shape p,#mermaid-svg-GiyWzAGjH3b3HYAD .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-GiyWzAGjH3b3HYAD .icon-shape .label rect,#mermaid-svg-GiyWzAGjH3b3HYAD .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-GiyWzAGjH3b3HYAD .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-GiyWzAGjH3b3HYAD .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-GiyWzAGjH3b3HYAD :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 子 Agent
父会话
定时任务
SQLite 存 next_run
关机错过执行点
重启后补跑
心跳唤醒主会话
派发子任务
下一轮读取完成事件
执行任务
完成事件落库
只回最终报告

4.4 定时任务:SQLite + 补跑 + 心跳

OpenClaw 的定时任务存 SQLite,关机错过的时间点重启后补跑,心跳唤醒主会话。这个设计比「内存里跑一个 cron」可靠得多:

  • 持久化 :next_run 存在 SQLite,进程重启不丢。
  • 补跑 :启动时检查所有 next_run <= now 的任务,按错过的执行点逐个补跑。
  • 心跳:主会话定期心跳;超过阈值没有心跳,就唤醒或重启。
  • 幂等:补跑要幂等,避免同一个时间点执行两次。
python 复制代码
"""定时任务:SQLite 记录下次执行时间,关机错过的时间点重启后补跑。"""

from __future__ import annotations

from dataclasses import dataclass, field
from datetime import datetime, timedelta


@dataclass
class Job:
    """一个定时任务。"""

    name: str
    interval: timedelta
    next_run: datetime


@dataclass
class Scheduler:
    """最小调度器:due / catch_up / heartbeat。"""

    jobs: list[Job] = field(default_factory=list)
    last_heartbeat: datetime | None = None

    def add(self, job: Job) -> None:
        self.jobs.append(job)

    def due(self, now: datetime) -> list[Job]:
        """返回所有到期的任务。"""
        return [job for job in self.jobs if job.next_run <= now]

    def catch_up(self, now: datetime) -> list[tuple[str, datetime]]:
        """补跑所有错过的执行点,并推进 next_run。"""
        missed: list[tuple[str, datetime]] = []
        for job in self.jobs:
            while job.next_run <= now:
                missed.append((job.name, job.next_run))
                job.next_run += job.interval
        return missed

    def heartbeat(self, now: datetime) -> bool:
        """心跳:超过阈值没有心跳就返回 True,表示需要唤醒。"""
        if self.last_heartbeat is None:
            self.last_heartbeat = now
            return False
        alive = now - self.last_heartbeat < timedelta(minutes=2)
        self.last_heartbeat = now
        return not alive


if __name__ == "__main__":
    now = datetime(2026, 11, 18, 9, 0)
    scheduler = Scheduler()
    scheduler.add(Job("daily-report", timedelta(days=1), now - timedelta(days=2)))
    print("due:", [job.name for job in scheduler.due(now)])
    print("catch_up:", scheduler.catch_up(now))
    print("heartbeat:", scheduler.heartbeat(now))

真实实现还要加:任务锁、失败重试、执行超时、补跑上限(避免关机一个月后一次补几千次)、以及「补跑结果通知」。但核心就是这三个动作:持久化 next_run、启动时补跑、心跳唤醒。

为什么心跳要唤醒主会话,而不是只记录时间?因为「进程活着」不等于「Agent 还能工作」。主会话可能卡在一个死循环、一个未返回的工具调用、或者一个等待中的审批;心跳是用来发现「活着但没动静」的。一个实用的做法是:主会话每轮结束时写一次心跳,超过两个周期没有心跳,就触发一次健康检查;健康检查失败再重启或告警。

五、该抄与不该抄:个人助手的取舍清单

该抄 怎么抄 不该抄 原因
审批楼层 用户 deny 最先生效,层级固定 本地执行默认不隔离 本地终端不能没有沙箱
授权记忆 本次 / 会话 / 永久三档 单进程、单用户假设 多租户 / 企业场景不适用
Guardian 自动审批 三档输出 + 拆命令 + 熔断 283 万行体量 嵌入 / 分发不现实
上下文四接口 摄入 / 每轮后 / 装配 / 压缩 容器沙箱默认关 默认安全策略不能照抄
先刷写再压缩 事实进记忆,旧内容归档 27 个渠道全接 渠道是产品能力,不是核心
定时补跑 + 心跳 SQLite + 幂等补跑 只用内存 cron 重启就丢,不可靠

如果要把这些细节迁进自己的 harness,建议按「风险 → 体验 → 成本」的顺序:

  1. 先做审批楼层:它直接决定「危险动作会不会被执行」,收益最大,改动最小。
  2. 再做授权记忆与无人值守策略:减少重复弹窗,让自动化任务不卡住。
  3. 然后做上下文四接口与先刷写再压缩:解决长会话的稳定性。
  4. 最后做定时补跑、子 Agent 落库、工具调用修复:这些是体验与可靠性优化,可以分批上。

不要一上来就抄渠道和体量。渠道是产品能力,不是运行时核心;283 万行的体量,也不适合嵌入。抄设计,不抄包袱。

常见坑:

序号 现象 背后的真正原因 一句话解决办法
1 压缩后用户偏好丢了 先压缩后刷写,事实没进记忆 先刷写关键事实,再压缩
2 技能加载了又被压掉 没给技能打保护标记 技能 / 图片标为 protected
3 关机后定时任务不跑 只存在内存里 SQLite 持久化 next_run + 启动补跑
4 补跑一次执行很多次 没有幂等 / 补跑上限 任务幂等 + 补跑上限
5 审批每次都问 没有授权记忆 本次 / 会话 / 永久三档
6 无人值守时卡住 ask 阻塞等人 独立无人值守策略,不阻塞不失败
7 子 Agent 结果丢了 只存在内存 / 父会话没读 完成事件落库,下一轮再读
8 工具调用被当成普通文本 没有修复层 识别 JSON / 标签 / Action 文本并提升

结语

Hermes 和 OpenClaw 不是瘦底座,但它们是很好的「真实产品样本」。审批楼层告诉我们「问人」也可以有层级和记忆;Guardian 告诉我们「模糊命令」可以加一层自动判断;上下文引擎告诉我们「先刷写、再压缩、后归档」;工具调用修复、四种队列、子 Agent 落库、定时补跑,都是产品打磨出来的细节。

下一篇是卷一收尾:把 LangGraph、DSH、Codex、Claude Code、Hermes、OpenClaw 放到一张 12 维表里,讲清楚为什么四个框架先出局、剩下的两个为什么不是二选一,以及怎么组合出一套适合自己的底座。

系列目录(三卷 16 篇):

卷一 · 选型坐标系:01 总纲 → 02 LangGraph → 03 DSH → 04 Codex / Claude Code → 05 Hermes / OpenClaw → 06 六框架横向对比

卷二 · DSH 核心机制:07 Cordis 插件模型 → 08 装配系统 → 09 会话日志 → 10 工具流水线 → 11 权限引擎 → 12 沙箱

卷三 · 工程落地:13 MCP 工具接入 → 14 上下文经济 → 15 中间件迁移 → 16 落地路线图

相关推荐
sleveen28 分钟前
新增办理动词只写 Core:SailFlow 动作骨架、同事务信封与 Sync 钩子自锁治理
开源·.net·工作流·oa引擎
Dawson Zhu1 小时前
【模型量化⑦】W4A8与GPTQ-Int4:极限压缩与MLC-LLM部署实战
人工智能·语言模型·架构·aigc·agi
千寻技术帮1 小时前
50055_基于AI的互帮互助小程序(源码+文档+数据库脚本+部署教程)
数据库·人工智能·小程序·毕业设计·springboot·课程设计
nice_lcj5201 小时前
【从零理解计算机网络 · 15】完整串联:一次请求的全旅程,以及那道经典面试题
网络·计算机网络·http·面试·tcp·总结·网络排查
天树星智源1 小时前
KV 剪枝的同一个误差,模型确定时只改 1.4% 的 token,不确定时改 65%:接上不确定性,AIME25 端到端快 1.27 倍
人工智能·大模型
AI英德西牛仔1 小时前
PC 用户的效率革命:腾讯元宝导出 Word 指令与“AI 导出鸭”的底层逻辑
人工智能·word·excel·deepseek·ai导出鸭
Flynn Liang2 小时前
多智能体协同不再复杂:Redis Stream 消费者组、幂等与故障恢复
数据库·人工智能·redis·缓存·ai agent·智能体
分布式存储与RustFS2 小时前
Dify 容器一重建知识库就空了:把上传文件和密钥一起存进 RustFS
运维·云原生·开源·对象存储·分布式存储·s3·性能基准
VIP_CQCRE11 小时前
GPT Image 2.6 商品图换背景后悬浮?接触阴影、透明区域与反射验收
图像处理·人工智能·ai·电商