第十二章：Hermes Agent vs OpenClaw Agent

发表于 2026-05-08 分类于 python ， rd Changyan：本文字数： 4.7k 阅读时长 ≈ 17 分钟

两大开源Agent框架的深度对比：Hermes的自改进运行时 vs OpenClaw的多智能体协作，帮你理解不同架构设计选择与选型建议。

两大开源 Agent 框架的深度对比：设计哲学、底层原理、核心差异与选型建议。
理解它们的差异，也是理解 Agent 架构设计选择的好机会。

12.1 它们是什么

Hermes Agent

Hermes Agent 是由 Nous Research（Hermes/Nomos/Psyche LLM 模型家族的开发者）开发的自改进 AI Agent 框架。2026 年 2 月发布，MIT 许可证。

它不是一个编程副驾驶、不是聊天机器人包装器、也不是 IDE 插件。它是一个持久化的自主 Agent 运行时，运行在你的服务器上，通过内置的闭环学习机制越用越聪明。

GitHub：github.com/NousResearch/hermes-agent
语言：Python
许可证：MIT
Stars：~52K+（截至 2026 年 4 月）

OpenClaw Agent

OpenClaw（前身 Clawdbot / Moltbot）是一个本地优先的个人 AI 助手运行时，由 Peter Steinberger（2026 年 2 月加入 OpenAI）最初开发，现由基金会维护。2025 年 11 月首发，MIT 许可证。它是 GitHub 历史上增长最快的开源 AI Agent 项目，240K+ Stars。

它是一个多通道网关 + Agent 运行时 — 一个长驻守护进程，连接你的消息平台并在本地运行 AI 任务。强调本地优先的数据控制、企业级稳定性和深度 IDE 集成。

GitHub：github.com/openclaw/openclaw
语言：TypeScript / Node.js
许可证：MIT
Stars：240K+（截至 2026 年 4 月）

12.2 设计哲学对比

维度	Hermes Agent	OpenClaw
核心隐喻	自改进 Agent（越用越聪明）	企业网关（按配置编排）
设计方向	深度/进化	广度/连接
谁在控制	Agent 自主性 — 学会自己做事	人类控制 — 定义规则，Agent 执行
运行时模型	Agent 进程 + 执行后端	长驻守护进程（Gateway）+ Agent 运行时 Worker
记忆哲学	原生自动，零维护	手动/可配置，深度定制
技能哲学	自动生成、自优化	手动/社区驱动，成熟生态
安全模型	内置沙箱，开箱即用	用户配置，最大控制
扩展方式	MCP + agentskills.io	插件系统（4 个注入点）

一句话概括：

Hermes：让 Agent 自己学会做事
OpenClaw：让人精确控制 Agent 做事

12.3 架构对比

Hermes Agent 架构

flowchart TD
subgraph MG["消息网关 15+ 平台"]
    M1[CLI]
    M2[Telegram]
    M3[Discord]
    M4[Slack]
end

subgraph AO["Agent 编排 run_agent.py"]
    A1[任务分解]
    A2["execute_code<br/>程序化工具调用"]
    A3[子 Agent 生成与并行]
end

subgraph SM["状态与记忆 hermes_state.py"]
    S1["SQLite + FTS5<br/>会话存储"]
    S2["Honcho<br/>辩证式用户建模"]
    S3["技能程序性记忆"]
end

subgraph EB["执行后端 6 种"]
    E1[Local]
    E2[Docker]
    E3[SSH]
    E4[Daytona]
    E5[Singularity]
    E6[Modal]
end

subgraph RL["RL 与研究 environments/"]
    R1["Atropos RL 训练集成"]
    R2["批量轨迹生成"]
    R3["自进化管道"]
end

MG --> AO
AO --> SM
AO --> EB
SM --> RL

style MG fill:#e3f2fd
style AO fill:#fff9c4
style SM fill:#f3e5f5
style EB fill:#e8f5e9
style RL fill:#ffebee

OpenClaw Agent 架构

flowchart TD
subgraph CLI["CLI 层 entry.ts → run-main.ts"]
    CL1[系统启动入口]
    CL2[命令分发]
end

subgraph GW["Gateway 层 控制面"]
    G1["WebSocket/HTTP 守护进程 :18789"]
    G2["连接 / 协议 / 方法 / 事件"]
    G3["配置热更新 / 认证 / 审计"]
end

subgraph CRP["Channel + 路由 + 插件层"]
    CR1[多协议适配器]
    CR2["会话键路由 8 级匹配"]
    CR3[插件注册与查找]
end

subgraph AE["Agent 执行层 5 子层"]
    AE1[Dispatch]
    AE2[Message]
    AE3[Decision]
    AE4[Assembly]
    AE5["Agent Scheduling Lane"]
    AE1 --> AE2 --> AE3 --> AE4 --> AE5
end

subgraph AI["AI 提供商层"]
    AI1["Anthropic / OpenAI / Ollama"]
    AI2[认证配置轮换与降级]
end

subgraph INF["基础设施层"]
    I1["Nodes / Media / Config"]
    I2["Sessions / Security"]
    I3[Scheduled Tasks]
end

CLI --> GW
GW --> CRP
CRP --> AE
AE --> AI
AI --> INF

style CLI fill:#e3f2fd
style GW fill:#fff9c4
style CRP fill:#f3e5f5
style AE fill:#ffebee
style AI fill:#e8f5e9
style INF fill:#e0e0e0

架构差异核心

差异	Hermes Agent	OpenClaw
核心进程	Agent 进程（可以随时启停）	Gateway 守护进程（必须常驻）
状态存储	SQLite + FTS5（结构化、可索引）	JSONL 追加写入（简单、但不可查询）
通信方式	CLI + Gateway 双入口，共享核心	WebSocket 协议（req/res/event 帧）
插件系统	MCP 服务器 + agentskills.io	4 层插件模型（manifest → enable → register → registry）
部署方式	本地 / Docker / SSH / Daytona / Modal	本地 / Docker / systemd + 反向代理
数据目录	`~/.hermes/`	`~/.openclaw/`

12.4 核心能力对比

工具调用

方面	Hermes Agent	OpenClaw
内置工具	68 个开箱即用	通过插件注册（bash、浏览器、文件等）
程序化编排	`execute_code` — 将多步管道折叠为单次推理	顺序工具调用循环
MCP 支持	✅ 连接任意 MCP 服务器	插件式技能系统
危险工具审批	内置沙箱 + 审批门	可配置审批工作流
子 Agent 委派	通过 RPC 生成隔离子 Agent	基于 Lane 的会话级并发
工具执行	在执行后端（本地/Docker/SSH）	在 Gateway 进程中

关键创新对比：

Hermes 的 execute_code：让 Agent 编写并运行 Python 代码，在单次推理步骤中程序化地编排多个工具调用，而非需要多轮 LLM 往返。显著降低延迟，提高可靠性。
OpenClaw 的 Lane 并发模型：6 种队列模式（interrupt、steer、steer-backlog、followup、collect、queue），精细控制新消息如何与进行中的 Agent 运行交互。

上下文管理

方面	Hermes Agent	OpenClaw
存储	SQLite + FTS5 全文搜索	JSONL 追加写入文件
上下文窗口	动态，定期”推播”持久化知识	硬最小值（16K tokens）+ 软警告（32K）+ 压缩
压缩	LLM 摘要	上下文守护者：窗口预检 + 历史卫生 + 配对修复 + 压缩重试 + 超时快照降级
跨会话	FTS5 搜索所有会话 + LLM 摘要	会话级 JSONL，内存缓存，懒加载
上下文文件	`SOUL.md`（人格），项目级上下文	`SOUL.md`、`AGENTS.md`，Markdown 驱动身份系统

关键创新对比：

Hermes：上下文是动态的，Agent 会定期将知识”推播”到持久存储，实现跨会话知识传递。
OpenClaw 的上下文守护者：5 阶段保护管道（预检 → 历史卫生 → 修复 → 压缩重试 → 超时快照），系统性地防止”上下文爆炸” — 这是 Agent 的常见故障模式。

记忆系统

方面	Hermes Agent	OpenClaw
架构	多层原生：SQLite + FTS5 + Honcho + Skills	多类型：内置记忆引擎 + Markdown 文件 + 插件
持久化	自动，零维护	手动/可配置（Markdown 驱动）
用户建模	Honcho — 辩证推理，深度用户画像	基础记忆边车；高级能力需插件
召回	FTS5 全文搜索 + Honcho 语义搜索	记忆搜索能力；Dreaming（后台记忆整合）
自动组织	✅ 记忆自动组织和检索	❌ 需要用户主动维护

Honcho 是 Hermes 的独门武器：

Honcho 在基本记忆之上增加了辩证推理。每次对话后，它分析交流并推导出关于用户偏好、习惯和目标的洞察。它支持多轮推理（深度 1-3）、冷/热提示选择、会话启动预热、查询自适应推理级别。这创建了一个”关于你是谁的不断深化的模型”，而非简单的事实存储。

1
2
3

传统记忆：存储 "用户喜欢 Python"
Honcho：  推导 "用户是后端开发者，偏好 Python 生态，可能对 Django/Flask 项目更有价值"
          → 自动调整后续任务的工具选择和建议方向

规划能力

方面	Hermes Agent	OpenClaw
方式	隐式：通过 `execute_code` + 子 Agent 委派	显式：Lane 调度 + Agent 分发管道
定时任务	内置 cron 系统，可投递到任意平台	需要安装单独的技能包
子任务并行	子 Agent 有独立对话和终端，RPC 通信	会话 Lane + 全局并发控制
失败处理	子 Agent 隔离 — 一个失败不影响其他	模型降级 + 多 Profile 轮换

12.5 关键技术创新

Hermes Agent 的创新

1. 闭环自改进循环

Hermes 是唯一内置学习循环的 Agent：

flowchart TD
A[执行任务] --> B[提取经验]
B --> C[自动创建技能]
C --> D["技能优化<br/>DSPy + GEPA"]
D --> E["持久化记忆<br/>SQLite + FTS5"]
E --> F["用户建模<br/>Honcho 辩证推理"]
F --> G[更好的体验]
G -->|下一轮任务| A

style A fill:#e3f2fd
style C fill:#fff9c4
style D fill:#f3e5f5
style F fill:#e8f5e9

这不是附带功能，而是架构性设计。Agent 越用越聪明，不需要人工干预。

2. 自进化管道

独立的优化管道，使用进化算法（DSPy + GEPA）自动优化：

技能描述
工具描述
系统提示词
甚至工具代码

无需 GPU 训练 — 全部通过 API 调用（每次约 $2-10）。GEPA（遗传-帕累托提示词进化）是 ICLR 2026 Oral 论文。

3. execute_code 程序化编排

传统 Agent：LLM 推理 → 调工具 A → LLM 推理 → 调工具 B → LLM 推理 → 调工具 C（3 轮 LLM）

Hermes：LLM 推理 → 写 Python 代码调用 A、B、C → 执行（1 轮 LLM）

延迟降低 3 倍+，可靠性显著提高。

4. 自动技能创建

当 Hermes 解决了一个困难问题，它自动写一个可复用的 SKILL.md 文档。技能是活着的、不断进化的程序，而非静态工具定义。

OpenClaw 的创新

1. Gateway-as-Control-Plane

单一长驻守护进程，作为 Hub-and-Spoke 架构的中心 — 管理连接、会话、路由和 Agent 执行。通过类型化的 WebSocket 协议通信。

2. Lane 并发模型

精细的会话级并发控制，6 种队列模式：

stateDiagram-v2
[*] --> Idle: Agent 空闲
Idle --> Running: 用户发送消息

Running --> Interrupt: interrupt模式<br/>新消息立即打断
Running --> Steer: steer模式<br/>新消息注入引导
Running --> SteerBacklog: steer-backlog模式<br/>引导+排队
Running --> Followup: followup模式<br/>等完成后处理
Running --> Collect: collect模式<br/>收集后批量处理

state Running {
    [*] --> Processing
    Processing --> WaitingLLM: 等待LLM响应
    WaitingLLM --> ToolCall: 调用工具
    ToolCall --> Processing
}

Interrupt --> Running: 新消息替换
Steer --> Running: 方向调整
SteerBacklog --> Running: 引导+排后续
Followup --> Running: 当前完成
Collect --> Running: 批量处理

Running --> Idle: 任务完成
Idle --> [*]

模式	行为
`interrupt`	新消息立即打断当前 Agent 运行
`steer`	新消息注入当前运行，引导方向
`steer-backlog`	引导 + 排队后续消息
`followup`	等当前运行完成后再处理
`collect`	收集所有消息后批量处理
`queue`	严格排队，FIFO

这是对”用户连续发消息时 Agent 该怎么处理”这个通用问题的最系统化解决方案。

3. 上下文守护者

5 阶段保护管道防止上下文爆炸：

flowchart TD
A["输入消息"] --> B{"阶段1: 窗口预检<br/>Token 数超硬限制?"}
B -->|超限| REJECT["❌ 拒绝请求"]
B -->|通过| C["阶段2: 历史卫生<br/>清理重复/无效消息"]
C --> D["阶段3: 配对修复<br/>修复截断的工具调用/响应对"]
D --> E{"阶段4: 压缩重试<br/>LLM 摘要压缩"}
E -->|成功| OK["✅ 上下文准备就绪"]
E -->|失败| F{"阶段5: 超时快照<br/>全部失败?"}
F -->|是| SNAP["💾 保存当前状态快照<br/>降级处理"]
F -->|重试成功| OK

style B fill:#ffebee
style REJECT fill:#ffcdd2
style C fill:#fff9c4
style D fill:#fff9c4
style E fill:#e3f2fd
style OK fill:#e8f5e9
style SNAP fill:#f3e5f5

4. 8 级路由优先级

flowchart TD
A["会话请求"] --> B{Peer 级别}
B -->|匹配| P1["1. Peer<br/>直接对话方"]
B -->|不匹配| C{Parent Peer 级别}
C -->|匹配| P2["2. Parent Peer<br/>父对话方"]
C -->|不匹配| D{Guild+Roles 级别}
D -->|匹配| P3["3. Guild+Roles<br/>群组+角色"]
D -->|不匹配| E{Guild 级别}
E -->|匹配| P4["4. Guild<br/>群组默认"]
E -->|不匹配| F{Team 级别}
F -->|匹配| P5["5. Team<br/>团队默认"]
F -->|不匹配| G{Account 级别}
G -->|匹配| P6["6. Account<br/>账户默认"]
G -->|不匹配| H{Channel 级别}
H -->|匹配| P7["7. Channel<br/>频道默认"]
H -->|不匹配| P8["8. Default Agent<br/>全局默认"]

style P1 fill:#e8f5e9
style P2 fill:#e8f5e9
style P3 fill:#fff9c4
style P4 fill:#fff9c4
style P5 fill:#e3f2fd
style P6 fill:#e3f2fd
style P7 fill:#f3e5f5
style P8 fill:#ffebee

对多租户、多上下文部署至关重要 — 不同的对话上下文自动路由到最合适的 Agent。

5. 配置热更新

Gateway 配置变更无需杀进程 — 支持热更新字段和优雅重启请求。

12.6 性能特征对比

特征	Hermes Agent	OpenClaw
工具调用延迟	更低 — `execute_code` 折叠多步为单次	标准 — 顺序工具调用循环
吞吐量	子 Agent 并行处理并发任务	Lane 并发 + 全局限制
内存效率	SQLite + FTS5（结构化、可索引）	JSONL 追加（简单、但不可查询）
上下文稳定性	定期推播 + LLM 摘要	5 阶段守护者 + 硬/软限制
启动权重	轻量 Python	较重的 Node.js 栈
空闲成本	近零（Daytona/Modal 无服务器休眠）	Gateway 必须常驻

12.7 生态与成熟度对比

维度	Hermes Agent	OpenClaw
GitHub Stars	~52K	240K+
发布时间	2026 年 2 月	2025 年 11 月
语言生态	Python（数据/ML 社区）	TypeScript/Node.js（Web 开发社区）
LLM 提供商	Nous Portal、OpenRouter（200+ 模型）、OpenAI、自定义、本地 vLLM	Anthropic、OpenAI、Ollama、AWS Bedrock、Gemini、Qwen、Moonshot、Together、HuggingFace
通道支持	15+ 平台（含微信、钉钉、飞书）	15+ 平台（含 iMessage、Google Chat、Teams、Matrix）
技能生态	40+ 内置 + 自动生成 + agentskills.io	成熟的社区市场 + 热更新
稳定性	较新，快速迭代	曾有稳定性问题（2026.4 版本崩溃），但大规模更成熟
中国生态	增长中（小米 MiMo 集成、腾讯云部署）	强中国社区版（DeepSeek/Qwen 原生、npmmirror、飞书/企业微信）

12.8 优劣势总结

Hermes Agent

优势	劣势
✅ 唯一内置闭环学习循环的 Agent	❌ 项目较新（2026.2 发布），大规模验证较少
✅ 自动技能创建，能力边界有机扩展	❌ 自进化可能不可预测 — 质量依赖评估数据
✅ Honcho 辩证式用户建模	❌ Honcho 增加 API 依赖和成本
✅ 自进化管道（DSPy+GEPA）是前沿 ML 研究	❌ 社区和生态比 OpenClaw 小
✅ 轻量部署 — $5 VPS 或无服务器即可运行	❌ IDE 集成不够成熟
✅ 内置 RL 研究平台（Atropos）	❌ 自动技能创建可能产出低质量技能
✅ 原生 cron 调度
✅ 内置沙箱，默认安全

OpenClaw Agent

优势	劣势
✅ 庞大社区（240K+ Stars）和成熟生态	❌ 无内置自改进 — 技能必须手动编写或下载
✅ 企业级稳定性（上下文守护者、模型降级、审计日志）	❌ 记忆需要手动维护（Markdown 文件）
✅ 精细化并发控制（6 种 Lane 模式）	❌ 较重的运行时 — Node.js 守护进程常驻
✅ 深度 IDE 集成	❌ 曾有稳定性问题（2026.4 崩溃事件）
✅ 强中国社区版（DeepSeek/Qwen/飞书/企业微信）	❌ 安全必须显式配置 — 默认不安全
✅ 插件架构（4 个注入点）	❌ 配置和定制学习曲线较陡
✅ 配置热更新	❌ 定时任务需要安装额外技能
✅ 基金会治理 — 社区驱动	❌ 上下文窗口管理更刚性（硬 16K 最小值）

12.9 与 DeepAgents 的关系

理解 Hermes 和 OpenClaw 的差异，也能帮我们更好地理解 DeepAgents 的定位：

维度	DeepAgents	Hermes Agent	OpenClaw
定位	Agent Harness（开发框架）	Agent Runtime（自改进运行时）	Agent Gateway（企业网关）
使用者	开发者（写代码构建 Agent）	终端用户/研究者（部署使用）	终端用户/企业（部署使用）
语言	Python（库）	Python（应用）	TypeScript（应用）
自定义程度	高 — 你写所有逻辑	中 — 通过配置和技能	中 — 通过插件和配置
与其他的关系	可以作为 Hermes/OpenClaw 的底层	可以用 DeepAgents 构建类似能力	—

简单理解：

DeepAgents 是”给你零件让你组装 Agent”
Hermes 是”给你一个会自己学习的 Agent”
OpenClaw 是”给你一个企业级 Agent 网关”

12.10 选型建议

选择 Hermes Agent 当：

你想要一个随使用增长的 Agent — 自动创建技能，构建用户模型
你需要零维护记忆 — 设好就忘
你在做 AI/ML 研究 — 批量轨迹生成、RL 训练、自进化实验
你要轻量部署 — 低成本服务器或无服务器
你优先开箱即用的安全性
你的用例涉及不可预测的任务，Agent 需要学习新能力
你要程序化多工具编排（execute_code）

选择 OpenClaw 当：

你优先完全本地控制和数据主权
你需要深度 IDE 集成的编程工作流
你想要成熟的技能生态，大量现成集成
你在企业环境部署，需要审计、审批和合规
你需要精细化并发控制，多用户、多通道
你重视可配置性胜过自动化 — 你想定义精确规则
你在中国市场，需要 DeepSeek/Qwen/飞书/企业微信原生支持
你需要事件驱动架构（Webhook、定时器、系统事件）

互补使用

两者可以协同工作：

Hermes 作为指挥中心 — 记忆积累、技能生成、任务规划
OpenClaw 作为执行端 — 利用丰富技能和多平台能力进行具体操作

这组合了 Hermes 的自动成长能力和 OpenClaw 的高效执行能力。

12.11 核心启示

对比 Hermes 和 OpenClaw，我们可以得出关于 Agent 架构设计的几个重要启示：

自改进 vs 人类控制 — 这是最根本的设计选择。Hermes 选择让 Agent 自己进化，OpenClaw 选择让人精确控制。没有对错，取决于场景。
上下文管理的两种范式 — Hermes 用动态推播 + FTS5 搜索（类似”按需拉取”），OpenClaw 用守护者管道 + 硬软限制（类似”防护式管理”）。
并发模型很重要 — Lane 的 6 种模式解决了一个真实痛点：用户不会乖乖等 Agent 回复完再发下一条消息。
工具调用的优化空间巨大 — Hermes 的 execute_code 证明了，减少 LLM 往返次数是提升 Agent 性能的最有效手段之一。
社区规模 ≠ 技术优势 — OpenClaw 社区远大于 Hermes，但 Hermes 的自进化管道和 Honcho 是技术创新。选择时看的是功能匹配度，不是 Star 数。

本章小结

对比维度	Hermes Agent	OpenClaw
一句话	自改进的自主 Agent	企业级 Agent 网关
语言	Python	TypeScript
核心理念	Agent 越用越聪明	人精确控制 Agent
独门武器	Honcho 辩证式用户建模	Lane 并发模型
上下文	动态推播 + FTS5	5 阶段守护者
技能	自动创建 + 自优化	社区市场 + 热更新
部署	轻量，支持无服务器	Gateway 常驻
适合	研究、学习型场景	企业、多通道、中国生态

选择建议：如果你是 Web 开发者转型，OpenClaw 的 TypeScript 生态和中国社区支持可能更友好；如果你对 AI/ML 研究感兴趣，Hermes 的自进化和 RL 集成更具吸引力。两者都值得了解，因为它们代表了 Agent 架构设计的两种主流范式。