拆了OpenClaw、Hermes、Claude Code、Codex四个生产级Agent的源码和官方文档,发现它们的架构设计惊人地一致——都在围绕同一个核心问题:怎么让AI Agent既能干活又不乱搞

权限要分级(不是一刀切),记忆要主动策展(不是被动记日志),Skill要自描述可热加载(不是写死在代码里),对话循环要串行化(不是两条消息同时跑抢跑道),上下文要自动压缩(不是session无限膨胀直到爆)。

我把这7条设计原则提炼出来,手敲了一个6文件的Mini Harness——串行化Session、三层分级权限、MEMORY.md记忆策展、SKILL.md热加载、SiliconFlow+GLM-5.1真实LLM对话。跑通的那一刻,才真正理解了这些设计原则不是理论,是血泪教训。

下面逐个拆解四大Agent的架构差异,然后用代码告诉你怎么把7条原则落地。

四大Agent的身份证

先看一张总览图,一眼看出各自的性格:

&"Codex&"

&"对话循环
Rust实时引擎
基于OpenAI Responses API&"

&"权限
三阶段ExecPolicy管线
Rule匹配→Safety评估→沙箱执行&"

&"记忆
memories crate
多策略compaction+Pre/Post Hooks&"

&"子Agent
spawn_child隔离进程
codex_delegate代表架构&"

&"Skill
codex-core-skills crate
loader+manager+injection+render
YAML frontmatter+SkillPolicy&"

&"Claude Code&"

&"对话循环
agentic coding tool
5种入口: 终端/IDE/Desktop/Web/JetBrains&"

&"权限
三层分级权限
Read-only免批/Bash需批/File需批
6种模式+deny优先&"

&"记忆
CLAUDE.md+Auto memory双系统
4级存储+Auto memory自动积累&"

&"子Agent
3内置Subagent: Explore/Plan/GP
不可嵌套+persistent memory&"

&"Skill
SKILL.md+agentskills.io标准
4级存储+Live change detection
Dynamic context injection&"

&"Hermes&"

&"对话循环
AIAgent同步编排引擎
CLI/Gateway/ACP/Batch/API 5入口&"

&"工具系统
70+注册工具/28 toolsets
Central Registry自动注册&"

&"权限
approval.py危险命令检测
DM pairing+allowlists
sudo确认+容器隔离&"

&"记忆
MEMORY.md+USER.md双文件
nudge驱动自动策展
FTS5 SQLite跨session搜索&"

&"子Agent
delegate_tool.py spawn
execute_code沙箱零context&"

&"Skill
自创建自进化
agentskills.io标准
Skills Hub社区共享&"

&"OpenClaw&"

&"对话循环
Gateway RPC → Queue → agentCommand
per-session串行&"

&"工具系统
内置+Skill热加载+MCP+插件
SKILL.md自描述&"

&"权限
exec security allowlist/full
tool policy+delegate身份&"

&"记忆
MEMORY.md+日志+向量检索
纯文件存储&"

&"子Agent
sessions_spawn隔离
delegate代表组织&"

&"Skill
多级目录热加载
SKILL.md注入prompt&"

一句话总结:OpenClaw稳如老狗、Hermes越用越聪明、Claude Code权限最精细、Codex沙箱最硬核

怎么理解?

  • OpenClaw是消息总线型——Gateway守门、Session串行、文件记忆,最稳最通用,WhatsApp/Telegram/飞书/Slack十几个通道都能跑
  • Hermes是学习型——最大的亮点是自进化Skill(用完自动创建、越用越聪明)和nudge驱动的双文件记忆,还有70+工具的Central Registry
  • Claude Code是权限管型编程工具——三层分级权限(只读随便看、Shell要你批准、写文件只记到session结束)是最精细的安全设计
  • Codex是沙箱管型编程工具——Rust写的,三阶段权限管线(规则匹配→安全评估→沙箱执行),macOS Seatbelt/Linux landlock/Windows sandbox三平台自适应,最硬核的安全沙箱

权限管线:谁管得最严

权限就是"Agent能做什么、不能做什么"的规矩。四个Agent的规矩差别很大:

&"OpenClaw 渐进式&"

&"exec security allowlist/full&"

&"tool policy过滤&"

&"delegate身份隔离&"

&"Hermes 多层权限&"

&"approval.py危险命令检测&"

&"DM pairing授权+allowlists&"

&"sudo确认+中断式用户审批&"

&"容器隔离
6终端后端&"

&"Codex 三阶段ExecPolicy&"

&"1.Rule匹配
PolicyParser解析规则
BANNED_PREFIX拦截python/bash/sudo&"

&"2.Safety评估
SafetyCheck枚举
AutoApprove/AskUser/Reject&"

&"3.沙箱执行
Seatbelt/landlock/Windows&"

&"网络隔离
CODEX_SANDBOX_NETWORK_DISABLED&"

&"Claude Code 三层分级权限&"

&"Read-only工具
File reads/Grep
无需批准&"

&"Bash commands
Shell执行
需批准,永久记住per项目&"

&"File modification
Edit/Write文件
需批准,仅session记住&"

&"规则评估
deny优先
6种权限模式&"

四个Agent的权限哲学完全不同:

Claude Code最精细——三层分级,不是一刀切。只读工具(grep、读文件)免批随便看;Shell命令(bash)要你批准,你点"不再询问"后永久记住(下次同项目同命令不再问);写文件(edit/write)也要你批准,但"不再询问"只记到session结束(下次新session还要问)。规则评估顺序是 deny→ask→allow,deny永远优先——一旦deny就不可能allow。还有6种模式:default(标准)、plan(只看不动手)、auto(自动批准+后台安全检查)、bypassPermissions(全放开,只有rm -rf /还会拦你一下)。

Codex最硬核——三阶段管线,Rust实现的。第一阶段Rule匹配:PolicyParser解析规则文件,还有个BANNED_PREFIX列表(python、bash、sudo这些命令直接拦截不让跑)。第二阶段Safety评估:SafetyCheck枚举决定AutoApprove(自动放进去沙箱跑)、AskUser(问你)、Reject(直接拒绝给你理由)。第三阶段沙箱执行:根据操作系统选Seatbelt(macOS)、landlock(Linux)、Windows sandbox,还能切断网络(设置CODEX_SANDBOX_NETWORK_DISABLED=1)。

OpenClaw最简单——两种exec security模式(allowlist=只跑白名单命令、full=全部允许),tool policy过滤工具,delegate身份隔离(子Agent用不同身份跑)。

Hermes最务实——approval.py检测危险命令(类似Codex的BANNED_PREFIX),DM pairing授权(消息平台谁能跟Agent聊要配对审批),sudo确认(中断式问你),容器隔离(6种后端可选,从本地到云VM)。

一句话对比:Claude Code是"精细分级"、Codex是"硬核沙箱"、OpenClaw是"简单白名单"、Hermes是"多层+容器"

我手敲Mini Harness时选了Claude Code的三层分级——因为最实用。Shell的"永久记住"和File的"仅session记住"这个区分太精妙了:Shell命令重复率高(npm run build你每天跑几十次),所以永久记住省心;文件修改每次可能不同(今天改main.py明天改config.py),所以每次都要问。

记忆系统:谁记得最牢

记忆就是"Agent怎么记住你说过什么"。四个Agent的记忆设计各有巧思:

Codex memories+compact crate

memories crate
read/write子模块
持久化记忆读写

多策略compaction
compact/compact_remote/compact_remote_v2
CompactionStrategy+Trigger+Reason
CompactionImplementation/Phase/Status

Pre+Post Hooks
run_pre/run_post_compact_hooks
PreCompactHookOutcome
PostCompactHookOutcome

Claude Code 双系统记忆

CLAUDE.md 4级存储
Managed/User/Project/Local
用户编写的持久指令

Auto memory
Claude自动积累
基于纠错和偏好
前200行/25KB加载

@import语法
引用其他文件
最大4层深度

路径匹配规则
.claude/rules/
按文件类型/子目录限定

OpenClaw 文件记忆

MEMORY.md长期

日志YYYY-MM-DD

memory_search向量检索

wiki companion知识库

Hermes 双文件+8 Provider记忆

MEMORY.md
Agent笔记(2200字符/800token)
环境事实+约定+教训

USER.md
用户画像(1375字符/500token)
偏好+风格+技能水平

FTS5 SQLite
跨session搜索
所有对话持久化

8外部Provider
Honcho/Mem0/OpenViking
知识图谱+语义搜索+自动抽取

Hermes的记忆最"智能"——双文件设计。MEMORY.md(Agent自己写的笔记,2200字符/800token限制)记环境事实、项目约定、踩过的坑;USER.md(用户画像,1375字符/500token限制)记你叫什么、你喜欢简短回复还是详细解释、你讨厌什么。nudge驱动:Agent自己判断什么时候该写笔记,不是被动记录日志,是"主动策展"。FTS5 SQLite把所有对话都存下来,几周前的讨论也能搜出来。还有8个外部memory provider(Honcho/Mem0/OpenViking等),想用知识图谱、语义搜索、自动抽取?插件式扩展。容量管理最严格:满了就不让你加,必须先合并旧的再写新的。

Claude Code的记忆最"灵活"——双系统设计。CLAUDE.md(你写的,4级存储:组织→个人→项目→本地)放"永远用pnpm不用npm"这种规则;Auto memory(Claude自己写的,基于你纠正它的内容自动积累)——你说"别用npm"它就记下来。@import语法:CLAUDE.md里可以@README引用其他文件,最多4层深度。.claude/rules/路径匹配:只在编辑.py文件时才加载Python规则,不浪费context。

OpenClaw的记忆最"透明"——全是文件,你能看、能改、能删,没有黑盒。MEMORY.md长期记忆+日志每天一个+memory_search向量检索+wiki companion知识库。

Codex的记忆最"工程化"——Rust crate实现。memories crate有read/write两个子模块,专门读写持久化记忆。多策略compaction:compact(本地压缩)、compact_remote(远程压缩)、compact_remote_v2。Pre+Post Hooks:压缩前后都能跑自定义脚本。

一句话对比:Hermes是"主动策展+容量管理"、Claude Code是"你写+我写双轨道"、OpenClaw是"纯文件透明"、Codex是"Rust crate工程化"

Mini Harness我选了OpenClaw的纯文件记忆+Hermes的容量管理——MEMORY.md有2000字符上限,满了必须先合并旧的再写新的。这个"满了不让加"的设计太重要了,否则MEMORY.md会无限膨胀变成垃圾堆。

Skill系统:谁学得最快

Skill就是"Agent能学会的新技能"。四个Agent的Skill设计哲学完全不同:

&"Codex codex-core-skills crate&"

&"SkillsLoader加载
YAML frontmatter解析&"

&"SkillsManager管理
skill发现+注册&"

&"SkillInjection注入&"

&"SkillRender渲染&"

&"agentskills.io标准
12个内置skill&"

&"OpenClaw 热加载Skill&"

&"多级目录
workspace/project/personal/bundled&"

&"SKILL.md自描述&"

&"注入prompt+工具&"

&"Claude Code SKILL.md+agentskills.io&"

&"4级存储
Enterprise/Personal/Project/Plugin
Enterprise优先&"

&"Live change detection
文件变更立即生效
无需重启&"

&"Dynamic context injection
!cmd语法
运行时注入动态内容&"

&"内置skill
/code-review/debug/run/verify&"

&"Hermes 自进化Skill&"

&"复杂任务后
自动创建skill
skill_commands.py调用&"

&"使用中自改进
按平台启用/禁用&"

&"agentskills.io标准
Skills Hub社区共享
bundled+optional双目录&"

Hermes的Skill最"活"——完成一个复杂任务后,Agent自动创建Skill记住怎么做,下次遇到类似任务直接调用。Skill在使用中自改进——跑了几次后发现更好的方式,自己更新Skill内容。按平台启用/禁用——Telegram上只用聊天类Skill,CLI上用编码类Skill。Skills Hub社区共享——别人写的Skill你也能用。

Claude Code的Skill最"规范"——SKILL.md文件定义,YAML frontmatter写description告诉Claude什么时候该用。4级存储(Enterprise→Personal→Project→Plugin),企业级优先。Live change detection:改了Skill文件立即生效,不用重启。Dynamic context injection:Skill里写!git diff HEAD就能自动注入当前diff,不是静态文本而是运行时动态内容。

OpenClaw的Skill最"简单"——多级目录(workspace/project/personal/bundled),SKILL.md自描述,自动发现自动注入。简单但够用。

Codex的Skill最"工程化"——独立的Rust crate(codex-core-skills),8+模块文件(loader/manager/injection/render/model/config_rules/system/remote)。loader.rs解析YAML frontmatter,manager.rs管理发现注册,injection.rs注入prompt。

一句话对比:Hermes是"活的"(自进化)、Claude Code是"规范的"(开放标准+动态注入)、OpenClaw是"简单的"(热加载)、Codex是"工程化的"(Rust crate模块化)

对话循环:谁跑得最稳

对话循环就是"Agent处理用户消息的流水线"。核心差异在于消息怎么排队、怎么防竞态:

OpenClaw最"守规矩"——所有消息先经过Gateway RPC验证身份,再排队串行化(一个session同时只处理一条消息,防止抢跑道),然后组装上下文+注入Skill→模型推理→工具执行→流式输出→写记忆。不会打架,不会乱。

Hermes最"灵活"——5个入口(CLI/Gateway/ACP/Batch/API)全部走同一个AIAgent类。Prompt分三层(stable/context/volatile),Provider18+家随便选。最特别的是自学习评估环节——每次对话完都会评估要不要写笔记、要不要创建新Skill。

Claude Code最"安全"——启动时先加载CLAUDE.md+Auto memory,然后三层权限检查,可选子Agent委托(Explore用Haiku只读搜代码、Plan只读做方案、General-purpose全能干活)。

Codex最"硬核"——Rust写的实时引擎,权限在推理之前就三阶段评估完,执行在沙箱里,网络可以完全切断。

我手敲Mini Harness时选了OpenClaw的per-session串行化——用asyncio.Queue+is_processing标志,同一session同时只处理一条消息。这个设计看起来"保守",但它解决了最根本的问题:两条消息同时跑会争抢context,导致Agent回复混乱

手敲实战:6文件Mini Harness

拆完四大Agent,提炼出7条可迁移的设计原则。但光看图不够,必须手敲才能真正理解

Mini Harness的6个文件,每个对应一条原则:

文件 对应原则 核心实现 参考来源
session.py 串行化对话循环 asyncio.Queue + is_processing标志 OpenClaw
permissions.py 渐进式权限信任 三层分级 + deny优先 + 6种模式 Claude Code
memory.py Agent主动策展记忆 MEMORY.md + 2000字符容量管理 Hermes
skills.py Skill自描述可热加载 SKILL.md YAML frontmatter + 隐式/显式匹配 OpenClaw/Claude Code
llm_client.py SiliconFlow + GLM-5.1 API调用
agent_loop.py 9步串起5大模块 OpenClaw

9步对话循环的完整流程:

  1. 消息到达 → Session入队(串行化)
  2. 串行取出 → 同一Session同时只处理一条
  3. 加载记忆 → MEMORY.md + 最近日志
  4. Skill注入 → 根据用户输入自动匹配Skill,注入prompt
  5. 权限评估 → deny→ask→allow检查
  6. Agent处理 → 组装prompt → 调用LLM
  7. 权限交互 → 如果需要批准,交互式询问
  8. 记忆写入 → 重要结论写入MEMORY.md或日志
  9. 输出回复 → 返回给用户

几个踩坑点值得记一下:

踩坑1:dataclass字段顺序。ApprovalRecord的字段顺序是timestamp:float然后session_id:str,但我构造时把session_id传给了timestamp——导致"不再询问"机制完全失效。教训:用关键字参数传值,不要用位置参数

踩坑2:Python模块名冲突。session.py和memory.py不是Python内置模块,但Python 3.12+默认不把当前目录加入sys.path——导致agent_loop.py找不到同目录模块。解决:在agent_loop.py开头加sys.path.insert(0, 当前目录)

踩坑3:LLM没有实时时间。GLM-5.1不知道今天是周六——因为LLM的训练数据截止后就没有时间信息了。解决:在system prompt里注入当前时间。

7条可迁移的设计原则

拆了四大Agent,手敲了Mini Harness,最终提炼出7条原则。不是理论,是四大生产级Agent都在用的实践:

  1. 串行化对话循环 — per-session队列防止竞态。两条消息同时跑会争抢context,导致Agent回复混乱。(OpenClaw验证)

  2. 渐进式权限信任 — 三层分级/三阶段管线不一刀切。只读免批、Shell需批但可永久记住、文件修改需批但仅session记住。规则评估deny永远优先。(Claude Code/Codex验证)

  3. Agent主动策展记忆 — nudge驱动+容量管理不是被动日志。MEMORY.md满了不让加,必须先合并旧的再写新的。(Hermes验证)

  4. Skill自描述可热加载 — SKILL.md+agentskills.io让Agent自动发现能力。YAML frontmatter定义何时触发,文件变更立即生效无需重启。(OpenClaw/Claude Code/Codex验证)

  5. 自动上下文压缩 — compaction防止session无限膨胀。超过token上限时自动压缩历史消息为summary。(四大Agent都有)

  6. 子Agent上下文隔离 — spawn+delegate+subagent防止上下文污染。子Agent在自己的上下文窗口运行,不可嵌套。(Claude Code不可嵌套验证)

  7. 沙箱平台自适应 — macOS Seatbelt/Linux landlock/Windows sandbox。根据操作系统自动选沙箱后端。(Codex源码验证)

这7条原则不是某个Agent独有的——是四大Agent都在用的共识性设计。不管你用什么语言、什么框架、什么模型,这7条都是你做Agent时的baseline。

下次预告

Mini Harness v1.0的6个文件只是骨架。下一步要加的:

  • Tool执行层——让Agent真正能执行Shell命令、读写文件(而不是echo)
  • 上下文压缩——超过token上限时自动压缩历史消息(原则5的落地)
  • 子Agent spawn——sessions_spawn隔离子Agent执行复杂任务(原则6的落地)

下次带你手敲Tool执行层,让Mini Harness真正能干活。


更多推荐