随着大模型能力的提升，AI Agent开发进入新阶段。本文对比了OpenClaw和Hermes Agent两大开源项目。OpenClaw以Gateway为中心的微内核架构著称，强调可控性与隐私安全；Hermes Agent由Nous Research打造，内置学习闭环，主打“越用越聪明”的自主进化能力。文章从架构设计、通信协议、Agent循环、记忆系统、技能体系、插件生态、自我进化机制、消息通道、安全机制、部署运维、选型指南等十一个维度进行全方位技术对比，为技术选型中的架构师和开发者提供参考。无论你是技术选型中的架构师，还是想深入了解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. 1. 一台机器一个Gateway：OpenClaw 严格遵循单实例原则，一个Gateway控制一个Baileys会话。这简化了状态管理，避免了多实例冲突。
2. 2. WebSocket统一通信：所有客户端（包括macOS应用、CLI、Web UI）和节点都通过WebSocket连接Gateway。协议使用JSON Schema验证，TypeBox定义类型。
3. 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. 1. Platform-agnostic core：一个AIAgent类服务于CLI、Gateway、ACP、Batch和API Server。平台差异存在于入口点，而非Agent本身。
2. 2. 6种终端后端：Local、Docker、SSH、Daytona、Modal、Singularity。这意味着Hermes可以在$5的VPS上运行，也可以在GPU集群上运行，甚至可以利用Daytona和Modal的serverless能力实现按需启动、空闲休眠。
3. 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_conversationself        # 1. Provider Resolution                # 2. Prompt Assemblyselfselfselfself                # 3. API Call (支持3种模式)        #    chat_completions / codex_responses / anthropic_messages self                # 4. Tool Dispatch        if            for in            # 循环回到API调用                # 5. Context Compression (如果需要)        if self                # 6. Persist to SessionDB                return

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. 1. MEMORY.md：长期记忆，存储持久性事实、偏好和决策。在每次DM会话开始时自动加载到上下文。
2. 2. memory/YYYY-MM-DD.md：每日笔记，记录当天的事件和观察。今天和昨天的笔记自动加载，更早的通过 memory_search 按需检索。
3. 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: weatherdescription: 获取当前天气和预报（无需API密钥）---# 天气查询技能## 使用场景当用户询问天气、温度、是否需要带伞时使用。## 执行步骤1. 确定用户所在城市2. 使用 wttr.in 获取天气数据3. 格式化输出，包含温度、湿度、风速## 注意事项- wttr.in 免费，无需API key- 支持中文城市名

技能发现机制：

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

<available_skills>  <skill>    <name></name>    <description></description>    <location></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. 1. ~/.hermes/plugins/（用户级）
2. 2. .hermes/plugins/（项目级）
3. 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. 1. 完成复杂任务后：当一个任务需要5个以上工具调用才能完成时，Agent会考虑将整个流程总结为一个技能
2. 2. 发现正确路径后：当Agent遇到错误或死胡同，最终找到可行方案时，会记录这个"从错误到成功"的路径
3. 3. 用户纠正后：当用户纠正Agent的方法时，Agent会创建技能来记住"正确做法"
4. 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. 1. 字符限制约束：MEMORY.md的2200字符限制意味着Agent不能记住太多东西，需要在信息密度和覆盖面之间取舍
2. 2. 黑盒风险：Agent自主创建的技能对用户来说不够透明，用户可能不知道Agent"学会"了什么
3. 3. 错误固化：如果Agent从一次错误经验中创建了技能，可能会在后续反复犯同样的错误
4. 4. Token消耗：技能渐进式加载虽然高效，但随着技能数量增长，Level 0的列表仍会消耗更多tokens

OpenClaw的对应优势：

1. 1. 完全透明：所有技能代码可见可审查
2. 2. 精确控制：用户决定Agent学什么、不学什么
3. 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. 1. 危险命令检测：tools/approval.py 会在执行前检测危险命令，需要用户确认。
2. 2. 记忆安全扫描：记忆条目在存入前会扫描注入和渗出模式。匹配威胁模式（prompt注入、凭证渗出、SSH后门）或包含不可见Unicode字符的内容会被阻止。
3. 3. 环境变量隔离：通过 env_passthrough 配置明确控制哪些环境变量可以传递到代码执行沙箱和终端沙箱。
4. 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全局安装# 初始化配置

Hermes Agent：

# 一键安装（Linux/macOS/WSL2）# 配置        # 全量配置向导        # 选择模型

9.3 部署灵活性

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

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

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

9.4 运维工具

OpenClaw：

# Gateway状态       # 启动Gateway     # 重启Gateway      # 插件诊断       # 记忆状态

Hermes Agent：

# 配置状态                # 环境诊断               # 版本检查                # 更新         # 记忆状态          # 技能更新检查          # 安全审计

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

10.3 选Hermes Agent的场景

1. 1. 自主学习：需要Agent从使用经验中自动积累技能
2. 2. 低门槛：非技术用户，希望开箱即用
3. 3. Serverless部署：利用Daytona/Modal的按需计费
4. 4. IDE集成：需要在VS Code/Zed/JetBrains中使用
5. 5. 研究用途：需要RL训练环境、轨迹生成
6. 6. 快速迭代：项目需要快速验证，3-5天一个大版本
7. 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架构的本质，然后在需要时切换或互补使用。毕竟，框架只是工具，真正重要的是你用它构建了什么。

那么如何学习大模型 AI ？

对于刚入门大模型的小白，或是想转型/进阶的程序员来说，最头疼的就是找不到系统、全面的学习资源，要么零散不成体系，要么收费高昂，白白浪费时间走弯路。今天就给大家精心整理了一份全面且免费的AI大模型学习资源包，覆盖从入门到实战、从理论到面试的全流程，所有资料均已整理完毕，免费分享给各位！

核心包含：AI大模型全套系统化学习路线图（小白可直接照做）、精品学习书籍+电子文档、干货视频教程、可直接上手的实战项目+源码、2026大厂面试真题题库，一站式解决你的学习痛点，不用再到处搜集拼凑！

👇👇扫码免费领取全部内容👇👇

1、大模型系统化学习路线

学习大模型，方向比努力更重要！很多小白入门就陷入“盲目看视频、乱刷资料”的误区，最后越学越懵。这里给大家整理的这份学习路线，是结合2026年大模型行业趋势和新手学习规律设计的，最科学、最系统，从零基础到精通，每一步都有明确指引，帮你节省80%的无效学习时间，少走弯路、高效进阶。

2、大模型学习书籍&文档

理论是实战的根基，尤其是对于程序员来说，想要真正吃透大模型原理，离不开优质的书籍和文档支撑。本次整理的书籍和电子文档，均由大模型领域顶尖专家、大厂技术大咖撰写，涵盖基础入门、核心原理、进阶技巧等内容，语言通俗易懂，既有理论深度，又贴合实战场景，小白能看懂，程序员能进阶，为后续实战和面试打下坚实基础。

3、AI大模型最新行业报告

无论是小白了解行业、规划学习方向，还是程序员转型、拓展业务边界，都需要紧跟行业趋势。本次整理的2026最新大模型行业报告，针对互联网、金融、医疗、工业等多个主流行业，系统调研了大模型的应用现状、发展趋势、现存问题及潜在机会，帮你清晰了解哪些行业更适合大模型落地，哪些技术方向值得重点深耕，避免盲目学习，精准对接行业需求。值得一提的是，报告还包含了多模态、AI Agent等前沿方向的发展分析，助力大家把握技术风口。

4、大模型项目实战&配套源码

对于程序员和想落地能力的小白来说，“光说不练假把式”，只有动手实战，才能真正巩固所学知识，将理论转化为实际能力。本次整理的实战项目，涵盖基础应用、进阶开发、多场景落地等类型，每个项目都附带完整源码和详细教程，从简单的ChatPDF搭建，到复杂的RAG系统开发、大模型部署，难度由浅入深，小白可逐步上手，程序员可直接参考优化，既能练手提升技术，又能丰富简历，为求职和职业发展加分。

5、大模型大厂面试真题

2026年大模型面试已从单纯考察原理，转向侧重技术落地和业务结合的综合考察，很多程序员和新手因为缺乏针对性准备，明明技术不错，却在面试中失利。为此，我精心整理了各大厂最新大模型面试真题题库，涵盖基础原理、Prompt工程、RAG系统、模型微调、部署优化等核心考点，不仅有真题，还附带详细解题思路和行业踩坑经验，帮你精准把握面试重点，提前做好准备，面试时从容应对、游刃有余。

6、四阶段精细化学习规划（附时间节点，可直接照做）

结合上述资源，给大家整理了一份可直接落地的四阶段学习规划，总时长约2个月，小白可循序渐进，程序员可根据自身基础调整节奏，高效掌握大模型核心能力，快速实现从“入门”到“能落地、能面试”的跨越。

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型

• 带你了解全球大模型

• 使用国产大模型服务

• 搭建 OpenAI 代理

• 热身：基于阿里云 PAI 部署 Stable Diffusion

• 在本地计算机运行大模型

• 大模型的私有化部署

• 基于 vLLM 部署大模型

• 案例：如何优雅地在阿里云私有部署开源大模型

• 部署一套开源 LLM 项目

• 内容安全

• 互联网信息服务算法备案

• …

👇👇扫码免费领取全部内容👇👇

3、这些资料真的有用吗？

这份资料由我和鲁为民博士(北京清华大学学士和美国加州理工学院博士)共同整理，现任上海殷泊信息科技CEO，其创立的MoPaaS云平台获Forrester全球’强劲表现者’认证，服务航天科工、国家电网等1000+企业，以第一作者在IEEE Transactions发表论文50+篇，获NASA JPL火星探测系统强化学习专利等35项中美专利。本套AI大模型课程由清华大学-加州理工双料博士、吴文俊人工智能奖得主鲁为民教授领衔研发。

资料内容涵盖了从入门到进阶的各类视频教程和实战项目，无论你是小白还是有些技术基础的技术人员，这份资料都绝对能帮助你提升薪资待遇，转行大模型岗位。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】