OpenClaw vs Hermes Agent:两大AI Agent架构深度对比

OpenClaw（🦞）——由社区驱动的开源个人AI助手，以Gateway为中心的微内核架构著称
Hermes Agent（🧠）——由Nous Research打造的自我进化AI智能体，内置学习闭环

引言

2026年的AI Agent赛道已经从"能不能做"进入"怎么做得更好"的阶段。随着大模型能力的飞速提升，开发者们不再满足于简单的对话机器人，而是追求真正能够持久运行、自主执行任务、持续积累知识的智能体。

在这个浪潮中，两个开源项目脱颖而出：OpenClaw 和 Hermes Agent。前者由社区驱动，以Gateway为中心的微内核架构著称，强调可控性和隐私安全；后者由Nous Research（知名模型训练实验室）打造，以内置学习闭环为核心卖点，主打"越用越聪明"的自主进化能力。

本文将从架构设计、通信协议、Agent循环、记忆系统、技能体系、插件生态、自我进化机制、消息通道、安全机制、部署运维、选型指南等十一个维度，对这两个框架进行全方位的技术对比。无论你是技术选型中的架构师，还是想深入了解Agent框架实现的开发者，这篇文章都值得收藏。

第一章：两个项目的诞生与定位

1.1 OpenClaw：从个人项目到社区生态

OpenClaw 的起源可以追溯到 Clawdbot 项目，经历了 Clawdbot → Moltbot → OpenClaw 的演进过程。它由独立开发者 Peter Steinberg 创建，最终发展为一个拥有超过24万开发者的开源社区项目。

OpenClaw 的核心理念是"控制平面优先，人在决策链中心"。它将用户放在第一位——所有操作需要显式授权，系统行为完全透明，用户可以审查每一行代码。这种设计哲学深受Linux系统管理员和DevOps工程师的青睐。

OpenClaw 的技术栈选择也反映了它的定位：Node.js/TypeScript 运行时，原生支持 Windows、macOS 和 Linux，WebSocket 通信协议，TypeBox 类型定义系统。这些选择使得它在工程成熟度和类型安全性方面具有天然优势。

1.2 Hermes Agent：训练实验室的Agent实验

Hermes Agent 由 Nous Research 于2026年2月正式发布。Nous Research 是什么来头？他们就是那个做了 Nous-Hermes 系列开源模型的团队，背后有着浓厚的模型训练和强化学习背景。

Hermes Agent 的定位非常清晰："The agent that grows with you"——随你成长的Agent。这不是一句营销话术，而是它的核心架构设计理念。Hermes 内置了一个完整的学习闭环：Agent能从每次交互中创建技能、改进技能、持久化知识，并在下次对话中直接复用。

技术栈方面，Hermes 选择了 Python 3.11 作为运行时，SQLite + FTS5 作为存储引擎，支持6种终端后端（本地、Docker、SSH、Daytona、Modal、Singularity）。值得注意的是，Hermes 不支持原生 Windows 环境，需要通过 WSL2 运行。

1.3 定位差异的本质

两个框架的定位差异可以用一个简单的比喻来理解：

• OpenClaw 是一把精心打造的瑞士军刀——每个工具都由你选择、安装、控制，完全透明，100%可控。
• Hermes Agent 是一个会学习的智能助手——它能记住你的习惯、自动积累技能，越用越懂你，但部分行为对你来说是黑盒。

这种差异不是好坏之分，而是设计哲学的根本不同。理解这一点，是正确选型的基础。

第二章：核心架构对比

2.1 OpenClaw：Gateway为中心的微内核

OpenClaw 的架构核心是一个长驻的 Gateway 守护进程。它是整个系统的"大脑"和"中枢"，负责管理所有消息通道、客户端连接和设备节点。

┌─────────────────────────────────────────────────────────────┐
│                     OpenClaw Gateway                         │
│                    (单进程守护进程)                             │
├─────────────────────────────────────────────────────────────┤
│  WebSocket Server (默认 127.0.0.1:18789)                    │
├──────────┬──────────┬──────────┬───────────────────────────┤
│ Clients  │  Nodes   │ Channels │    Agent Runtime          │
│ (macOS/  │ (iOS/    │ (WA/TG/  │  (pi-agent-core)          │
│  CLI/Web)│  Android)│  Slack/  │                           │
│          │          │  Discord)│  ┌───────────────────┐    │
│          │          │          │  │ Session Manager   │    │
│          │          │          │  │ Skill Loader      │    │
│          │          │          │  │ Command Queue     │    │
│          │          │          │  │ Compaction Engine │    │
│          │          │          │  └───────────────────┘    │
├──────────┴──────────┴──────────┴───────────────────────────┤
│  Plugin System (4层: 发现→验证→加载→消费)                     │
│  Capability Registry (Provider/Speech/Image/Channel...)     │
├─────────────────────────────────────────────────────────────┤
│  Canvas Host (HTTP Server)                                  │
└─────────────────────────────────────────────────────────────┘

关键设计决策：

1. 一台机器一个Gateway：OpenClaw 严格遵循单实例原则，一个Gateway控制一个Baileys会话。这简化了状态管理，避免了多实例冲突。
2. WebSocket统一通信：所有客户端（包括macOS应用、CLI、Web UI）和节点都通过WebSocket连接Gateway。协议使用JSON Schema验证，TypeBox定义类型。
3. Canvas Host集成：Gateway的HTTP服务器同时提供Canvas服务（/__openclaw__/canvas/），允许Agent生成和展示HTML/CSS/JS内容。

2.2 Hermes Agent：AIAgent为中心的模块化

Hermes Agent 的架构以 AIAgent 类为核心，这是一个约10,700行的Python类，承载了整个对话循环。

┌─────────────────────────────────────────────────────────────┐
│                      Entry Points                            │
│  CLI (cli.py) │ Gateway (gateway/run.py) │ ACP (acp_adapter)│
│  Batch Runner │ API Server               │ Python Library  │
└──────────┬──────────────┬───────────────────────┬───────────┘
           │              │                       │
           ▼              ▼                       ▼
┌─────────────────────────────────────────────────────────────┐
│                    AIAgent (run_agent.py)                     │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐         │
│  │   Prompt     │ │  Provider    │ │    Tool      │         │
│  │   Builder    │ │  Resolution  │ │   Dispatch   │         │
│  └──────┬───────┘ └──────┬───────┘ └──────┬───────┘         │
│  ┌──────┴───────┐ ┌──────┴───────┐ ┌──────┴───────┐         │
│  │ Compression  │ │ 3 API Modes  │ │Tool Registry │         │
│  │ & Caching    │ │ chat/codex/  │ │ 47 tools     │         │
│  │              │ │ anthropic    │ │ 19 toolsets  │         │
│  └──────────────┘ └──────────────┘ └──────────────┘         │
└─────────────────────────────────────────────────────────────┘
           │                              │
           ▼                              ▼
┌───────────────────┐        ┌──────────────────────┐
│ Session Storage   │        │   Tool Backends      │
│ (SQLite + FTS5)   │        │ Terminal (6 backends) │
│                   │        │ Browser (5 backends)  │
│                   │        │ Web (4 backends)      │
│                   │        │ MCP (dynamic)         │
│                   │        │ File, Vision, etc.    │
└───────────────────┘        └──────────────────────┘

关键设计决策：

1. Platform-agnostic core：一个AIAgent类服务于CLI、Gateway、ACP、Batch和API Server。平台差异存在于入口点，而非Agent本身。
2. 6种终端后端：Local、Docker、SSH、Daytona、Modal、Singularity。这意味着Hermes可以在$5的VPS上运行，也可以在GPU集群上运行，甚至可以利用Daytona和Modal的serverless能力实现按需启动、空闲休眠。
3. Profile隔离：每个Profile（hermes -p <name>）拥有独立的HERMES_HOME、配置、记忆、会话和Gateway进程。多个Profile可以并发运行。

2.3 通信协议对比

这是两个框架最根本的技术差异之一。

OpenClaw的WebSocket协议：

OpenClaw使用精心设计的WebSocket协议，具有严格的类型约束：

// 首帧必须是connect
{ type: "req", id: "1", method: "connect", params: {
    auth: { token: "shared-secret" },
    challenge: "...",
    signature: "..."
  }
}

// 后续请求
{ type: "req", id: "2", method: "agent", params: {
    sessionKey: "...",
    message: "Hello"
  }
}

// 响应
{ type: "res", id: "2", ok: true, payload: { runId: "...", status: "accepted" } }

// 服务端推送事件
{ type: "event", event: "agent", payload: { stream: "assistant", delta: "..." } }

关键特性：

• JSON Schema验证：每个帧都经过Schema校验
• TypeBox类型定义：从TypeBox Schema生成JSON Schema和Swift模型
• 幂等键：副作用方法（send、agent）需要幂等键，安全重试
• 设备配对：新设备需要审批，Gateway颁发设备令牌

Hermes Agent的通信方式：

Hermes的Gateway采用Python原生的适配器模式，18个平台各有独立适配器：

# Hermes Gateway 消息处理流程
# Platform event → Adapter.on_message() → MessageEvent
# → GatewayRunner._handle_message()
# → authorize user → resolve session key
# → create AIAgent with session history
# → AIAgent.run_conversation()
# → deliver response back through adapter

Hermes没有像OpenClaw那样定义严格的Wire Protocol。它的Gateway更接近传统的Python Web服务，平台适配器直接处理各平台的SDK差异。

2.4 数据流对比

OpenClaw 数据流：

用户消息 → 平台通道 → Gateway WebSocket
→ agent RPC → Session Manager（获取/创建session）
→ Command Queue（排队等待）
→ runEmbeddedPiAgent（执行agent循环）
→ pi-agent-core（LLM推理 + 工具调用）
→ 事件流推送 → Gateway → 平台通道 → 用户

Hermes Agent 数据流：

用户消息 → 平台适配器 → MessageEvent
→ GatewayRunner._handle_message()
→ 用户授权 → Session解析
→ 创建AIAgent + 加载会话历史
→ AIAgent.run_conversation()
→ Prompt Builder构建系统提示
→ Provider Resolution选择模型
→ API调用 → 工具调用循环
→ 通过适配器投递响应

两者在数据流上的主要差异在于：

• OpenClaw有显式的Command Queue排队机制，保证session内串行、全局可控并发
• Hermes依赖SQLite的会话存储和Python的异步机制处理并发

第三章：Agent Loop 机制对比

Agent Loop是框架的心脏——它决定了Agent如何接收输入、构建上下文、调用模型、执行工具、返回结果。

3.1 OpenClaw的Agent Loop

OpenClaw的Agent Loop是一个精心设计的流水线，包含多个阶段：

┌─────────────────────────────────────────────────────────┐
│                  OpenClaw Agent Loop                     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 入口验证                                             │
│     agent RPC → 验证参数 → 解析sessionKey                │
│     → 持久化session元数据 → 返回 {runId, acceptedAt}    │
│                                                         │
│  2. 队列排队                                             │
│     per-session lane（保证串行）                         │
│     → global lane（控制总并发，默认maxConcurrent）        │
│                                                         │
│  3. 会话准备                                             │
│     workspace解析 → skills加载/快照                      │
│     → bootstrap context注入 → session写锁获取            │
│                                                         │
│  4. Prompt组装                                           │
│     基础prompt + skills prompt + bootstrap context       │
│     + per-run覆盖 → 模型限制和compaction reserve检查     │
│                                                         │
│  5. 推理执行                                             │
│     runEmbeddedPiAgent → 序列化执行                      │
│     → 解析model + auth profile → 构建pi session         │
│     → 订阅pi事件 → 流式推送                              │
│                                                         │
│  6. 事件流                                               │
│     tool事件 → stream: "tool"                           │
│     assistant delta → stream: "assistant"               │
│     lifecycle → stream: "lifecycle"                     │
│                                                         │
│  7. 回复组装                                             │
│     assistant文本 + inline工具摘要                       │
│     + NO_REPLY过滤 + 消息去重                            │
│                                                         │
└─────────────────────────────────────────────────────────┘

序列化队列是OpenClaw的一大亮点。它通过lane-aware FIFO队列解决了Agent并发执行的竞态问题：

• per-session lane：每个session key对应一个lane，保证同一会话同时只有一个agent run
• global lane：控制全局并行度（main默认4，subagent默认8）
• 队列模式：steer（注入当前run）、followup（排队等下一个turn）、collect（合并为单个turn）、steer-backlog（注入+保留）、interrupt（中断当前run）

这种设计保证了session状态的一致性，避免了工具调用和session历史的竞态条件。

3.2 Hermes Agent的Agent Loop

Hermes的AIAgent.run_conversation()是一个同步编排引擎，处理provider选择、prompt构建、工具执行、重试、fallback、回调、压缩和持久化。

# Hermes Agent Loop 核心流程（简化）
class AIAgent:
    def run_conversation(self):
        # 1. Provider Resolution
        provider = runtime_provider.resolve_runtime_provider()
        
        # 2. Prompt Assembly
        system_prompt = prompt_builder.build_system_prompt(
            personality=self.load_soul_md(),
            memory=self.load_memory(),
            skills=self.get_available_skills(),
            context_files=self.load_context_files()
        )
        
        # 3. API Call (支持3种模式)
        #    chat_completions / codex_responses / anthropic_messages
        response = self.call_api(system_prompt, messages)
        
        # 4. Tool Dispatch
        if response.tool_calls:
            for tool_call in response.tool_calls:
                result = model_tools.handle_function_call(tool_call)
                messages.append(tool_result(result))
            # 循环回到API调用
        
        # 5. Context Compression (如果需要)
        if self.context_exceeds_threshold():
            context_compressor.compress(messages)
        
        # 6. Persist to SessionDB
        session_store.save_conversation(messages)
        
        return final_response

Hermes的3种API模式是一个独特的设计：

API模式	适用场景	代表提供商
chat_completions	OpenAI兼容接口	OpenAI、DeepSeek、自定义端点
codex_responses	OpenAI Codex格式	OpenAI Coding Plan
anthropic_messages	Claude原生接口	Anthropic

这种设计让Hermes可以无缝切换不同的模型提供商，无需修改核心代码。

3.3 Loop对比总结

特性	OpenClaw	Hermes Agent
并发控制	显式队列（per-session + global lane）	依赖Python异步和SQLite锁
流式输出	事件流（tool/assistant/lifecycle）	回调系统（CLI spinner + gateway messages）
Prompt缓存	Provider级别支持	Anthropic cache breakpoints
可中断性	支持（steer/interrupt模式）	支持（信号和用户输入）
Compaction	自动+手动，可插拔	上下文压缩（lossy summarization）
子代理	sessions_spawn（推送式完成通知）	delegate_tool（子代理委派）

第四章：记忆系统深度对比

记忆系统是区分"一次性聊天机器人"和"持久Agent"的关键。两个框架在记忆实现上走了完全不同的路线。

4.1 OpenClaw：Markdown文件 + 语义搜索

OpenClaw的记忆系统基于一个极其简洁的理念：用人类可读的Markdown文件存储一切。

~/.openclaw/workspace/
├── MEMORY.md              # 长期记忆（每次DM会话加载）
├── memory/
│   ├── 2026-04-20.md      # 每日笔记
│   ├── 2026-04-19.md      # 昨天的笔记（自动加载）
│   └── 2026-04-18.md      # 更早的笔记（按需搜索）
├── DREAMS.md              # 可选：梦境日记
└── .dreams/               # 梦境系统短期存储

三层记忆架构：

1. MEMORY.md：长期记忆，存储持久性事实、偏好和决策。在每次DM会话开始时自动加载到上下文。
2. memory/YYYY-MM-DD.md：每日笔记，记录当天的事件和观察。今天和昨天的笔记自动加载，更早的通过 memory_search 按需检索。
3. DREAMS.md（可选）：梦境日记，配合Dreaming系统使用。

语义搜索引擎：

OpenClaw的 memory_search 工具使用混合搜索——结合向量相似度（语义含义）和关键词匹配（精确术语如ID和代码符号）。当配置了OpenAI、Gemini、Voyage或Mistral的API key时，自动启用。

Memory后端选项：

后端	特点	适用场景
Builtin（默认）	SQLite，开箱即用，支持关键词+向量+混合搜索	大多数用户
QMD	本地优先sidecar，支持重排序、查询扩展、索引外部目录	高级用户
Honcho	AI原生跨会话记忆，用户建模，语义搜索	需要深度记忆的用户

Dreaming系统：

这是OpenClaw记忆系统中最有趣的部分。Dreaming是一个可选的后台巩固机制：

• 自动管理一个cron job执行深度扫描
• 收集短期信号，评分候选条目
• 只有通过分数、召回频率和查询多样性门槛的条目才能晋升到MEMORY.md
• 阶段摘要写入DREAMS.md供人工审查

Memory Wiki：

对于需要结构化知识管理的用户，OpenClaw提供了Memory Wiki插件。它将持久记忆编译为一个带有来源追踪的wiki vault，支持确定性页面结构、结构化声明和证据、矛盾和新鲜度追踪。

自动Memory Flush：

在compaction之前，OpenClaw会自动运行一个静默turn，提醒Agent将重要上下文保存到memory文件。这防止了压缩过程中的上下文丢失。

4.2 Hermes Agent：有界记忆 + 多层检索

Hermes的记忆系统设计哲学是"有界、精选的持久记忆"——不是越多越好，而是越精越好。

~/.hermes/memories/
├── MEMORY.md              # Agent个人笔记（2200字符限制）
└── USER.md                # 用户画像（1375字符限制）

~/.hermes/state.db         # SQLite + FTS5（会话历史存储）

两个核心记忆文件：

文件	用途	字符限制	Token估算	典型条目数
MEMORY.md	Agent的个人笔记：环境事实、约定、经验教训	2,200	~800	8-15条
USER.md	用户画像：偏好、沟通风格、期望	1,375	~500	5-10条

冻结快照模式：

Hermes的记忆在session开始时一次性加载到system prompt，之后不再变化。这是为了保持LLM的prefix cache以提升性能。Agent在session中添加/删除记忆时，变更立即持久化到磁盘，但不会出现在当前session的system prompt中，直到下一个session。

System prompt中的记忆呈现格式：

══════════════════════════════════════════════
MEMORY (your personal notes) [67% — 1,474/2,200 chars]
══════════════════════════════════════════════
User's project is a Rust web service at ~/code/myapi using Axum + SQLx
§
This machine runs Ubuntu 22.04, has Docker and Podman installed
§
User prefers concise responses, dislikes verbose explanations

Session Search：

除了MEMORY.md和USER.md，Hermes还提供了跨会话搜索能力：

• 所有CLI和messaging会话存储在SQLite中，支持FTS5全文搜索
• 搜索查询返回相关历史对话，附带LLM摘要（使用Gemini Flash）
• Agent可以找到几周前讨论的内容，即使不在活跃记忆中

外部记忆提供者：

Hermes提供了8种外部记忆提供者插件，与内置记忆并行运行（不替代）：

提供者	核心能力
Honcho	对话式用户建模
OpenViking	知识图谱
Mem0	语义搜索
Hindsight	自动事实提取
Holographic	全息记忆
RetainDB	持久化数据库
ByteRover	字节级检索
Supermemory	增强记忆

容量管理：

与OpenClaw的无限制Markdown文件不同，Hermes对记忆有严格的字符限制。当记忆满时，Agent需要合并或替换现有条目。这种设计强制Agent保持记忆的高信噪比。

4.3 记忆系统对比总结

维度	OpenClaw	Hermes Agent
存储格式	无限制Markdown文件	有界字符限制文件
长期记忆	MEMORY.md（无限制）	MEMORY.md（2200字符）
每日笔记	memory/YYYY-MM-DD.md	无（依赖Session Search）
语义搜索	混合搜索（向量+关键词）	FTS5全文搜索 + LLM摘要
记忆巩固	Dreaming系统（自动晋升）	无自动巩固机制
知识管理	Memory Wiki插件	外部提供者插件
自动保存	Memory Flush（compaction前）	Agent自主判断保存
安全扫描	无内置	注入/渗出模式检测
跨会话检索	memory_search + memory_get	Session Search + 外部提供者
可观测性	文件直接可读	DREAMS.md审查日志

第五章：技能系统对比

技能系统是Agent框架的"能力扩展"机制。两个框架在技能的创建、管理、分发上走了截然不同的路线。

5.1 OpenClaw：声明式技能 + 社区市场

OpenClaw的技能系统是声明式的——每个技能是一个包含SKILL.md的文件夹，描述了技能的触发条件、执行步骤和注意事项。

~/.openclaw/skills/
├── weather/                    # 官方bundled技能
│   └── SKILL.md
├── github/                     # 官方bundled技能
│   └── SKILL.md
├── my-custom-skill/            # 用户自定义技能
│   ├── SKILL.md
│   ├── scripts/
│   │   └── main.py
│   └── references/
│       └── guide.md
└── [workspace]/                # workspace技能
    └── baoyu-image-gen/
        └── SKILL.md

SKILL.md 示例：

---
name: weather
description: 获取当前天气和预报（无需API密钥）
---

# 天气查询技能

## 使用场景
当用户询问天气、温度、是否需要带伞时使用。

## 执行步骤
1. 确定用户所在城市
2. 使用 wttr.in 获取天气数据
3. 格式化输出，包含温度、湿度、风速

## 注意事项
- wttr.in 免费，无需API key
- 支持中文城市名

技能发现机制：

OpenClaw在system prompt中注入一个紧凑的技能列表，包含每个技能的名称、描述和文件路径。Agent需要使用 read 工具加载SKILL.md才能获取完整内容。

<available_skills>
  <skill>
    <name>weather</name>
    <description>获取当前天气和预报（无需API密钥）</description>
    <location>D:\soft\nodejs\node_global\node_modules\openclaw\skills\weather\SKILL.md</location>
  </skill>
</available_skills>

ClawdHub 技能市场：

OpenClaw拥有ClawdHub（clawhub.com）作为官方技能市场，支持搜索、安装、更新和发布技能。

特点：

• ✅ 完全透明：技能代码完全可见，可审查
• ✅ 社区驱动：24,000+社区贡献技能
• ✅ 精细控制：按需安装，每个技能独立权限
• ❌ 手动操作：需要命令行安装和配置
• ❌ 无自学习：技能不会自动创建或优化

5.2 Hermes Agent：渐进式技能 + 自动创建

Hermes的技能系统兼容 agentskills.io 开放标准，并在之上加入了Agent自主创建和管理能力。

渐进式加载（Progressive Disclosure）：

这是Hermes技能系统的一大亮点。它使用三级加载模式来最小化token消耗：

Level 0: skills_list() → [{name, description, category}, ...]  (~3k tokens)
         ↓ (Agent决定需要某个技能时)
Level 1: skill_view(name) → 完整SKILL.md内容 + metadata
         ↓ (Agent需要引用文件时)
Level 2: skill_view(name, path) → 特定参考文件内容

相比OpenClaw的"先注入列表，再read加载"模式，Hermes的渐进式加载更加token高效，因为Level 0只需要约3k tokens就能覆盖所有技能。

Agent自主技能管理：

这是Hermes最独特的功能。Agent可以通过 skill_manage 工具自主创建、更新和删除技能：

动作	用途	关键参数
create	从零创建新技能	name, content, category
patch	定向修复（推荐）	name, old_string, new_string
edit	重大结构重写	name, content（完整替换）
delete	完全删除技能	name
write_file	添加/更新支持文件	name, file_path, file_content
remove_file	删除支持文件	name, file_path

Agent什么时候会创建技能？

• 完成一个复杂任务（5+工具调用）后
• 遇到错误或死胡同后找到可行路径时
• 用户纠正其方法时
• 发现非平凡的工作流时

这实际上就是Hermes的程序性记忆（Procedural Memory）——Agent像人类一样，通过"经验"积累"技能"。

Skills Hub 多源市场：

Hermes的技能市场支持多种来源：

来源	示例	说明
official	`official/security/1password`	Hermes官方可选技能
skills.sh	`skills-sh/vercel-labs/...`	Vercel公共技能目录
well-known	`well-known:https://...`	网站发现协议
github	`openai/skills/k8s`	直接GitHub安装
clawhub	-	OpenClaw技能市场兼容
lobehub	-	LobeChat技能市场

条件激活机制：

Hermes技能支持根据当前环境自动显示或隐藏：

metadata:
  hermes:
    fallback_for_toolsets: [web]    # 仅当web工具集不可用时显示
    requires_toolsets: [terminal]   # 仅当terminal工具集可用时显示
    fallback_for_tools: [web_search] # 仅当web_search不可用时显示
    requires_tools: [terminal]       # 仅当terminal可用时显示

例如，内置的duckduckgo-search技能使用 fallback_for_toolsets: [web]。当你配置了FIRECRAWL_API_KEY时，web工具集可用，Agent使用web_search，DuckDuckGo技能自动隐藏。反之则自动显示作为后备。

5.3 技能系统对比总结

维度	OpenClaw	Hermes Agent
技能格式	SKILL.md（自定义格式）	SKILL.md（agentskills.io标准）
技能来源	手动编写/安装	自动创建 + 手动安装
加载方式	列表注入 + read加载	三级渐进式加载
Token效率	中等（列表+read两步）	高（渐进式，按需加载）
自主创建	❌ 不支持	✅ skill_manage工具
条件激活	❌ 不支持	✅ fallback/requires机制
技能市场	ClawdHub	Skills Hub（多源）
外部目录	不支持	✅ 只读扫描外部目录
配置集成	无	✅ 声明config settings
安全设置	无	✅ required_environment_variables

第六章：插件与扩展性对比

6.1 OpenClaw的四层插件架构

OpenClaw的插件系统是业界最精心设计的之一，分为四个明确的层级：

┌─────────────────────────────────────────────────────────┐
│              Layer 4: Surface Consumption               │
│  暴露tools、channels、provider setup、hooks、            │
│  HTTP routes、CLI commands、services                     │
├─────────────────────────────────────────────────────────┤
│              Layer 3: Runtime Loading                    │
│  Native插件通过jiti加载，注册capabilities到中央注册表     │
│  Compatible bundles归一化为注册表记录                    │
├─────────────────────────────────────────────────────────┤
│              Layer 2: Enablement + Validation            │
│  Core决定插件是enabled/disabled/blocked/selected        │
│  支持exclusive slot（如memory）                          │
├─────────────────────────────────────────────────────────┤
│              Layer 1: Manifest + Discovery               │
│  从配置路径、workspace roots、全局扩展根、bundled扩展     │
│  读取openclaw.plugin.json manifests                     │
└─────────────────────────────────────────────────────────┘

Capability模型：

OpenClaw定义了一套清晰的Capability类型，每个插件注册一个或多个：

Capability	注册方法	示例插件
Text inference	registerProvider	openai, anthropic
Speech	registerSpeechProvider	elevenlabs, microsoft
Image generation	registerImageGenerationProvider	openai, google, fal
Web fetch	registerWebFetchProvider	firecrawl
Web search	registerWebSearchProvider	google
Channel/messaging	registerChannel	msteams, matrix
Media understanding	registerMediaUnderstandingProvider	openai, google
Video generation	registerVideoGenerationProvider	qwen

双层Hook系统：

OpenClaw的Hook系统覆盖了Agent生命周期的方方面面：

Gateway Hooks（内部钩子）：

• agent:bootstrap：构建bootstrap文件时拦截

Plugin Hooks（插件钩子），按执行顺序：

• before_model_resolve：模型解析前（无messages，确定性覆盖）
• before_prompt_build：session加载后（有messages，注入context）
• before_agent_reply：内联动作后，LLM调用前（可声明turn或静默）
• before_tool_call / after_tool_call：工具调用前后拦截
• agent_end：完成后检查最终消息
• before_compaction / after_compaction：压缩前后
• before_install：技能/插件安装前扫描
• tool_result_persist：工具结果持久化前转换
• message_received / message_sending / message_sent：消息生命周期
• session_start / session_end：会话边界
• gateway_start / gateway_stop：Gateway生命周期

Hook决策规则（严格且明确）：

• before_tool_call: { block: true } 是终态，阻止低优先级handler
• before_tool_call: { block: false } 是空操作，不清除之前的block
• message_sending: { cancel: true } 是终态
• message_sending: { cancel: false } 是空操作

6.2 Hermes Agent的插件系统

Hermes的插件系统相对简洁，但功能完备：

三个发现源：

1. ~/.hermes/plugins/（用户级）
2. .hermes/plugins/（项目级）
3. pip entry points（包级）

插件注册方式：

• Tools（工具）
• Hooks（钩子）
• CLI Commands（命令行命令）

两种专用插件类型：

• Memory Providers：单选，同时只能激活一个
• Context Engines：单选，同时只能激活一个

6.3 扩展性对比总结

维度	OpenClaw	Hermes Agent
架构层级	4层（发现→验证→加载→消费）	3源发现 + context API
Capability模型	✅ 10+种明确类型	❌ 无正式Capability模型
Hook点数量	20+	较少（未公开精确数字）
Hook类型	双层（Gateway + Plugin）	单层
Channel插件	共享message tool + 独立适配器	18个独立适配器
Provider插件	Capability注册 + 多供应商	runtime resolver + 18+提供商
版本兼容性	兼容性信号系统（config valid/legacy warning）	无公开兼容性机制
技能标准	自定义格式	agentskills.io开放标准

第七章：Hermes Agent的自我进化机制（核心差异）

这是两个框架最本质的差异。如果说前面的章节比较的是"功能多少"，那么这一章比较的是"有没有灵魂"。

7.1 什么是自我进化？

传统AI Agent（包括OpenClaw）的模式是：人类定义规则 → Agent执行规则。无论你安装了多少技能、配置了多么复杂的Hook，Agent本身不会变得"更聪明"——它只是在忠实地执行你给它的指令。

Hermes Agent打破了这个范式。它的核心理念是：Agent应该从使用经验中学习，像人类一样积累"经验"和"技能"。

这不是简单的"记住用户偏好"（两个框架都能做到），而是一整套闭环学习系统——Agent能自主发现问题、总结经验、创建技能、优化流程，并在未来的交互中应用这些积累。

7.2 自我进化的六大支柱

┌─────────────────────────────────────────────────────────────┐
│              Hermes Agent 自我进化闭环                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐           │
│   │ ① 经验   │────▶│ ② 总结   │────▶│ ③ 技能   │           │
│   │   积累   │     │   提炼   │     │   创建   │           │
│   └──────────┘     └──────────┘     └──────────┘           │
│         ▲                                 │                 │
│         │                                 ▼                 │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐           │
│   │ ⑥ 持续   │◀────│ ⑤ 效果   │◀────│ ④ 复用   │           │
│   │   优化   │     │   评估   │     │   执行   │           │
│   └──────────┘     └──────────┘     └──────────┘           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

支柱一：经验积累（Experience Accumulation）

Hermes Agent的每一次交互都不会被丢弃。它通过多层系统捕获经验：

• 会话历史持久化：所有CLI和messaging会话存储在SQLite中，支持FTS5全文搜索。这不是简单的聊天记录——Agent可以跨会话检索过去几周甚至几个月的对话。
• Memory自动管理：Agent在运行过程中自动识别值得记住的信息（用户偏好、环境事实、错误教训、成功路径），并通过 memory 工具写入MEMORY.md和USER.md。这个过程不需要用户提示——Agent自主判断什么值得记住。
• 外部记忆提供者：对于需要更深层记忆的场景，Hermes提供了8种外部记忆插件。例如Honcho可以进行对话式用户建模——不仅记住你说了什么，还理解你是谁、你关心什么、你的工作模式是什么。

与OpenClaw的对比：
OpenClaw也有记忆系统（MEMORY.md + memory_search），但它的记忆管理更多依赖人工触发或Agent被动执行。OpenClaw的Dreaming系统（可选）提供了一定的自动巩固能力，但需要手动启用，且不涉及技能层面的学习。

支柱二：总结提炼（Summarization & Distillation）

经验积累只是第一步。Hermes的进化关键在于从原始经验中提炼出可复用的知识。

• FTS5 + LLM摘要：当Agent需要查找过去的经验时，Session Search不仅返回原始对话，还会用LLM（Gemini Flash）生成摘要。这意味着即使几周前的对话细节已经模糊，Agent仍然能获取精确的知识精华。
• 容量驱动的精炼：MEMORY.md有严格的2200字符限制。这种限制不是缺陷——它是一种设计约束，强制Agent不断精炼和压缩记忆。当记忆满时，Agent必须合并相关条目、淘汰过时信息、保留最核心的知识。
• 安全扫描过滤：记忆在写入前会经过注入/渗出模式检测。这确保了"学习"过程不会被恶意输入污染。

与OpenClaw的对比：
OpenClaw的MEMORY.md没有字符限制，Agent可以无限写入。这看起来更自由，但实际上容易导致记忆膨胀、信噪比下降。OpenClaw的Dreaming系统提供了一定程度的精炼（通过评分和门槛晋升），但不如Hermes的容量约束来得直接和持续。

支柱三：技能创建（Skill Creation）

这是Hermes自我进化最核心的能力。Agent可以通过 skill_manage 工具自主创建技能——不是简单的笔记或备忘，而是完整的、可复用的、结构化的技能文档。

Agent什么时候会创建技能？

1. 完成复杂任务后：当一个任务需要5个以上工具调用才能完成时，Agent会考虑将整个流程总结为一个技能
2. 发现正确路径后：当Agent遇到错误或死胡同，最终找到可行方案时，会记录这个"从错误到成功"的路径
3. 用户纠正后：当用户纠正Agent的方法时，Agent会创建技能来记住"正确做法"
4. 发现非平凡工作流后：当Agent发现一个值得复用的多步骤工作流时

一个真实的例子：

假设你让Hermes帮你部署一个Kubernetes应用。第一次，Agent可能需要6个步骤：读取Dockerfile、构建镜像、推送到镜像仓库、编写K8s YAML、应用配置、验证部署状态。

这6个步骤执行完成后，Hermes会自动创建一个 deploy-k8s 技能，记录整个流程。下次你再需要部署时，Agent直接加载这个技能，可能只需要2-3个步骤就能完成。

更关键的是，这个技能会被持续优化。后续使用中如果发现 buildah 比 docker push 更好，Agent会用 patch 动作更新技能。这就是"从经验中学习"的具体体现。

与OpenClaw的对比：
OpenClaw的技能必须由人类手动编写和安装。Agent可以读取技能，但不能创建技能。如果你想给OpenClaw添加一个新能力，你需要自己写SKILL.md、测试、安装。Hermes的Agent可以自己做这些。

支柱四：复用与执行（Reuse & Execution）

创建的技能不是放在那里吃灰的。Hermes有一整套机制确保技能被高效复用：

• Slash命令：每个技能自动注册为斜杠命令，如 /deploy-k8s
• 渐进式加载：三级加载模式确保token消耗最小化
• 条件激活：技能可以根据当前环境自动显示或隐藏
• Skills Hub：技能可以从社区安装，也可以发布到社区

支柱五和六：效果评估与持续优化

Hermes的进化不是一次性的——它是一个持续循环：

• 使用反馈：每次使用技能时，Agent会评估效果
• 自主修复：如果技能执行失败，Agent会诊断问题并更新技能
• 版本演进：技能通过patch/edit动作持续迭代，而不是一次写死

7.3 自我进化的技术实现

记忆层级：有界精选 + 外部扩展

┌─────────────────────────────────────────────────────────────┐
│                   Hermes 记忆层级                             │
├─────────────────────────────────────────────────────────────┤
│  Level 0: MEMORY.md / USER.md (系统提示注入，~1300 tokens)   │
│           ↓ 始终在线，快速访问                                │
│  Level 1: Session Search (SQLite FTS5 + LLM摘要)            │
│           ↓ 按需检索，覆盖所有历史对话                         │
│  Level 2: 外部记忆提供者 (Honcho/Mem0/OpenViking...)         │
│           ↓ 深度知识图谱、语义搜索、用户建模                    │
│  Level 3: Skills (自主创建 + 社区安装)                        │
│           ↓ 程序性记忆，可复用的工作流                          │
└─────────────────────────────────────────────────────────────┘

技能生命周期：自主管理 + 社区共享

┌─────────────────────────────────────────────────────────────┐
│                   Hermes 技能生命周期                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  任务执行 ──▶ 成功/失败 ──▶ 经验评估                          │
│                              │                              │
│                    ┌─────────┴─────────┐                    │
│                    ▼                   ▼                    │
│              值得记录？           已有类似技能？               │
│              ┌────┴────┐         ┌────┴────┐                │
│              ▼         ▼         ▼         ▼                │
│           创建新技能  更新记忆  Patch现有  无需操作          │
│                               技能                        │
│                                                             │
│  技能使用 ──▶ 执行效果 ──▶ 需要优化？──▶ Patch/Edit/Delete  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

社区层：开放标准 + 多源市场

Hermes兼容 agentskills.io 开放标准，这意味着：

• 技能在不同Agent框架间可移植
• 社区贡献的技能可以被任何人使用
• Skills Hub聚合了多个来源（official、skills.sh、well-known、GitHub、clawhub）

7.4 OpenClaw的"学习"能力

公平地说，OpenClaw并非完全没有"学习"能力，但它走的路线完全不同：

能力	OpenClaw	Hermes Agent
记住用户偏好	✅ MEMORY.md	✅ MEMORY.md + USER.md
记住环境信息	✅ TOOLS.md	✅ memory工具
自动保存重要信息	✅ Memory Flush（compaction前）	✅ Agent自主判断
跨会话搜索	✅ memory_search（语义）	✅ Session Search（FTS5+LLM）
记忆巩固	✅ Dreaming（可选，自动晋升）	❌ 无自动巩固
知识管理	✅ Memory Wiki	✅ 外部记忆提供者
自主创建技能	❌	✅ skill_manage
自主优化技能	❌	✅ patch/edit
技能社区共享	✅ ClawdHub	✅ Skills Hub（多源）
用户建模	✅ Honcho（可选插件）	✅ Honcho（内置插件）

OpenClaw的"学习"本质上是文件管理——Agent把信息写到Markdown文件中，下次读取。这种方式透明、可控，但Agent本身不会因为积累了更多文件而变得"更聪明"。它只是有了更多的参考资料。

Hermes的"学习"是行为改变——Agent不仅记住信息，还改变自己的行为模式。它创建了新技能，意味着它在未来遇到类似任务时会采取不同的（更高效的）行动。

7.5 自我进化的局限与风险

公平地看，Hermes的自我进化也不是万能的：

局限：

1. 字符限制约束：MEMORY.md的2200字符限制意味着Agent不能记住太多东西，需要在信息密度和覆盖面之间取舍
2. 黑盒风险：Agent自主创建的技能对用户来说不够透明，用户可能不知道Agent"学会"了什么
3. 错误固化：如果Agent从一次错误经验中创建了技能，可能会在后续反复犯同样的错误
4. Token消耗：技能渐进式加载虽然高效，但随着技能数量增长，Level 0的列表仍会消耗更多tokens

OpenClaw的对应优势：

1. 完全透明：所有技能代码可见可审查
2. 精确控制：用户决定Agent学什么、不学什么
3. 无错误固化风险：技能由人类编写，质量有保障

7.6 总结：两种进化路线

OpenClaw 路线：                     Hermes Agent 路线：
  人类定义规则                        人类设定目标
       │                                  │
       ▼                                  ▼
  Agent执行规则                        Agent探索方法
       │                                  │
       ▼                                  ▼
  结果反馈给人类                        结果反馈给Agent
       │                                  │
       ▼                                  ▼
  人类更新规则                        Agent自我优化
       │                                  │
       ▼                                  ▼
  Agent执行新规则                      Agent变得更高效
       │                                  │
  （循环：人在回路）                   （循环：自主进化）

OpenClaw选择了"人在回路"的进化路线——每次改进都需要人类参与，确保可控性和安全性。

Hermes选择了"自主进化"的路线——Agent自己从经验中学习，速度更快但透明度更低。

两种路线没有绝对的好坏。对于高风险场景（医疗、金融、安全），OpenClaw的路线更合适。对于效率优先场景（日常自动化、开发辅助），Hermes的路线更有优势。

第八章：消息通道与多平台对比

两个框架都支持广泛的即时通讯平台，但在实现方式和覆盖范围上有所不同。

7.1 平台覆盖对比

平台	OpenClaw	Hermes Agent
Telegram	✅ grammY	✅ 适配器
Discord	✅	✅ 适配器
Slack	✅	✅ 适配器
WhatsApp	✅ Baileys	✅ Web
Signal	✅	✅ 适配器
iMessage	✅ BlueBubbles	✅ BlueBubbles
Matrix	✅	✅ 适配器
Mattermost	-	✅ 适配器
Email	-	✅ SMTP
SMS	-	✅
QQ	✅ QQBot（原生）	✅ QQBot
钉钉	✅ DingTalk	✅ DingTalk
飞书	✅ Feishu	✅ Feishu
企业微信	✅ WeCom	✅ WeCom
微信公众号	✅ Weixin	✅ Weixin
Home Assistant	-	✅
Webhook	-	✅

Hermes在平台数量上略有优势（18个vs 15个），多了Matrix、Mattermost、Email、SMS、Home Assistant和Webhook。但在国产平台（QQ、钉钉、飞书、企业微信、微信公众号）的支持上，两者基本持平。

7.2 实现方式差异

OpenClaw：每个通道是一个Channel Plugin，通过Capability模型注册。核心拥有统一的 message tool，channel插件负责channel-specific的发现和执行。这种方式保证了消息处理的一致性，但每个新通道需要编写完整的Plugin。

Hermes：每个平台是一个独立的Adapter，直接处理各平台的SDK。GatewayRunner统一路由。这种方式更加直接，开发新适配器更快。

7.3 Node/设备控制

这是OpenClaw独有的优势。OpenClaw支持Nodes概念——macOS/iOS/Android/headless设备可以通过WebSocket连接到Gateway，提供以下能力：

• canvas.*：远程Canvas展示
• camera.*：摄像头拍照和录制
• screen.record：屏幕录制
• location.get：位置获取

Hermes没有对应的Node概念，设备控制需要依赖外部工具或SSH连接。

第九章：安全机制对比

8.1 OpenClaw的安全模型

OpenClaw的安全模型是多层防护但偏重于配置：

┌─────────────────────────────────────────────────────────┐
│                   OpenClaw 安全层级                        │
├─────────────────────────────────────────────────────────┤
│  Layer 1: Advisory安全提示（System Prompt中的guardrails） │
│  Layer 2: 工具策略（exec security模式：deny/allowlist/   │
│           full）                                         │
│  Layer 3: Exec审批（ask模式需人工确认）                   │
│  Layer 4: 沙箱（可选，sandboxed运行时）                   │
│  Layer 5: Channel Allowlists（限制哪些channel可以触发）   │
│  Layer 6: 设备配对（新设备需要审批）                      │
│  Layer 7: 共享密钥认证（WebSocket连接认证）               │
└─────────────────────────────────────────────────────────┘

重要特点：

• System Prompt中的安全提示是advisory（建议性的），指导模型行为但不强制执行
• 真正的强制执行靠工具策略、exec审批、沙箱和channel allowlists
• 操作员可以禁用这些保护措施

8.2 Hermes Agent的安全模型

Hermes在安全设计上更加系统化，默认内置了多层防护：

┌─────────────────────────────────────────────────────────┐
│                  Hermes Agent 安全层级                     │
├─────────────────────────────────────────────────────────┤
│  Layer 1: 危险命令审批（approval.py检测）                 │
│  Layer 2: 用户授权机制（allowlists + DM pairing）         │
│  Layer 3: 容器隔离（6种终端后端，Docker/Singularity等）   │
│  Layer 4: 上下文扫描（记忆注入/渗出检测）                  │
│  Layer 5: 环境变量传递控制（env_passthrough配置）          │
│  Layer 6: 技能安全设置（required_environment_variables）   │
│  Layer 7: 技能审计（hub install时安全扫描）                │
└─────────────────────────────────────────────────────────┘

独特之处：

1. 危险命令检测：tools/approval.py 会在执行前检测危险命令，需要用户确认。
2. 记忆安全扫描：记忆条目在存入前会扫描注入和渗出模式。匹配威胁模式（prompt注入、凭证渗出、SSH后门）或包含不可见Unicode字符的内容会被阻止。
3. 环境变量隔离：通过 env_passthrough 配置明确控制哪些环境变量可以传递到代码执行沙箱和终端沙箱。
4. 技能安全审计：从Skills Hub安装技能时会进行安全扫描，有quarantine机制。

8.3 安全对比总结

维度	OpenClaw	Hermes Agent
安全提示	Advisory（建议性）	Advisory
命令审批	exec ask模式	内置危险命令检测
沙箱	可选配置	6种终端后端内置隔离
记忆安全	无内置扫描	注入/渗出模式检测
环境变量	无特殊控制	env_passthrough配置
技能审计	无	Hub安装时安全扫描
设备配对	✅	✅（DM pairing）
默认安全	偏松（需手动配置）	偏紧（开箱即用）

第十章：部署与运维对比

9.1 系统要求

项目	OpenClaw	Hermes Agent
操作系统	Windows/macOS/Linux（原生）	Linux/macOS/WSL2
运行时	Node.js v24+	Python 3.11+
内存	推荐4GB+	推荐16GB+
存储	1GB+	20GB+
安装方式	npm	curl脚本或 git clone

9.2 安装体验

OpenClaw：

# npm全局安装
npm install -g openclaw

# 初始化配置
openclaw configure

Hermes Agent：

# 一键安装（Linux/macOS/WSL2）
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# 配置
hermes setup        # 全量配置向导
hermes model        # 选择模型

9.3 部署灵活性

Hermes在部署灵活性上有明显优势，支持6种终端后端：

后端	特点	成本
Local	直接在本机运行	免费
Docker	容器隔离	免费
SSH	远程服务器	服务器费用
Daytona	Dev环境管理	按使用计费
Modal	Serverless	空闲时近乎免费
Singularity	HPC集群	集群费用

Daytona和Modal特别值得一提——它们提供serverless持久化，环境在空闲时休眠，成本几乎为零。这意味着你可以在$5的VPS上运行Hermes，不用时自动休眠，有消息时自动唤醒。

9.4 运维工具

OpenClaw：

openclaw gateway status      # Gateway状态
openclaw gateway start       # 启动Gateway
openclaw gateway restart     # 重启Gateway
openclaw plugins doctor      # 插件诊断
openclaw memory status       # 记忆状态

Hermes Agent：

hermes status                # 配置状态
hermes doctor                # 环境诊断
hermes version               # 版本检查
hermes update                # 更新
hermes memory status         # 记忆状态
hermes skills check          # 技能更新检查
hermes skills audit          # 安全审计

9.5 IDE集成

Hermes通过ACP（Agent Communication Protocol）提供原生IDE集成，支持VS Code、Zed和JetBrains。这意味着你可以直接在编辑器中使用Hermes作为编程助手。

OpenClaw目前没有原生的ACP支持，主要通过终端和消息平台交互。

第十一章：选型指南

10.1 决策树

                    ┌──────────────────┐
                    │   你需要什么？    │
                    └────────┬─────────┘
                             │
                ┌────────────┼────────────┐
                │            │            │
          ┌─────▼─────┐ ┌───▼────┐ ┌────▼─────┐
          │  完全控制  │ │ 自主学习 │ │ 两者都要  │
          └─────┬─────┘ └───┬────┘ └────┬─────┘
                │            │            │
          ┌─────▼─────┐ ┌───▼────┐ ┌────▼─────────┐
          │ 隐私敏感？ │ │ 长期运行│ │ 互补部署方案  │
          └─────┬─────┘ └───┬────┘ └──────────────┘
           是↙     ↘是      │
      ┌────▼──┐ ┌──▼────┐ ┌▼──────────┐
      │OpenClaw│ │Hermes │ │Hermes指挥  │
      │       │ │Agent  │ │+OpenClaw执行│
      └───────┘ └───────┘ └───────────┘

10.2 选OpenClaw的场景

1. 隐私优先：处理医疗、金融等敏感数据，需要100%本地化
2. 深度定制：需要集成特殊硬件、协议或内部系统
3. Windows原生：需要在Windows上直接运行（不支持WSL2的环境）
4. 设备控制：需要控制iOS/Android设备的摄像头、屏幕、位置
5. 精细权限：需要对每个技能、每个工具调用进行精确控制
6. 已有生态：已经在使用OpenClaw的Skill生态，不想迁移
7. 工程严谨：需要WebSocket协议的类型安全、JSON Schema验证

10.3 选Hermes Agent的场景

1. 自主学习：需要Agent从使用经验中自动积累技能
2. 低门槛：非技术用户，希望开箱即用
3. Serverless部署：利用Daytona/Modal的按需计费
4. IDE集成：需要在VS Code/Zed/JetBrains中使用
5. 研究用途：需要RL训练环境、轨迹生成
6. 快速迭代：项目需要快速验证，3-5天一个大版本
7. 跨平台记忆：需要8种外部记忆提供者的深度记忆能力

10.4 互补部署方案

一个有趣的实践是混合部署：用Hermes当"指挥位"，OpenClaw当"执行位"。

• Hermes负责：记住偏好设定、使用习惯和Skill迭代，具备完整的对话收录和自主学习能力
• OpenClaw负责：实际执行任务，因为Skills数量和接入平台广度仍有优势

两者配合使用，各取所长。

结语

OpenClaw和Hermes Agent代表了AI Agent发展的两条不同路线：

OpenClaw选择的是"可控性"路线——精心设计的WebSocket协议、类型安全的插件系统、透明的Markdown记忆、手动管理的技能生态。它的每一层都可以被审查、被控制、被替换。这种设计哲学适合那些需要完全掌控系统行为的技术团队。

Hermes Agent选择的是"智能性"路线——内置学习闭环、自动技能创建、有界精选记忆、多终端后端部署。它像一个真正的"数字员工"，越用越懂你，但也接受了一定的不透明性。这种设计哲学适合那些追求自动化效率、需要快速产生价值的团队。

没有绝对的好坏，只有适合不适合。理解两个框架的设计哲学和架构差异，才能做出正确的技术选型。

更重要的是，这两个项目都在快速进化。OpenClaw在加强其安全机制和企业级能力，Hermes在完善其文档和社区生态。未来的AI Agent框架，很可能融合两者的优势——既有OpenClaw的工程严谨性和可控性，又有Hermes的自主进化能力。

对于开发者来说，最好的策略可能是：先用一个框架深入实践，理解Agent架构的本质，然后在需要时切换或互补使用。毕竟，框架只是工具，真正重要的是你用它构建了什么。

本文参考文档

1. OpenClaw 官方文档^[1]
2. OpenClaw GitHub^[2]
3. Hermes Agent 官方文档^[3]
4. Hermes Agent GitHub^[4]

引用链接

[1] OpenClaw 官方文档: https://docs.openclaw.ai
[2] OpenClaw GitHub: https://github.com/openclaw/openclaw
[3] Hermes Agent 官方文档: https://hermes-agent.nousresearch.com/docs/
[4] Hermes Agent GitHub: https://github.com/NousResearch/hermes-agent