大家好，我是讯享网，很高兴认识大家。这里提供最前沿的Ai技术和互联网信息。



随着大模型能力的提升，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 ）拥有独立的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如何接收输入、构建上下文、调用模型、执行工具、返回结果。

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模式是一个独特的设计：

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

3.3 Loop对比总结

---

记忆系统是区分"一次性聊天机器人"和"持久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后端选项：

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（会话历史存储） 

两个核心记忆文件：

冻结快照模式：

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种外部记忆提供者插件，与内置记忆并行运行（不替代）：

容量管理：

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

4.3 记忆系统对比总结

---

技能系统是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 工具自主创建、更新和删除技能：

Agent什么时候会创建技能？

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

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

Skills Hub 多源市场：

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

条件激活机制：

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 技能系统对比总结

---

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类型，每个插件注册一个或多个：

双层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 扩展性对比总结

---

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

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的"学习"本质上是文件管理——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 平台覆盖对比

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

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 安全对比总结

---

9.1 系统要求

9.2 安装体验

OpenClaw：

# npm全局安装# 初始化配置 

Hermes Agent：

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

9.3 部署灵活性

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

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

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

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

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

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

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

结合上述资源，给大家整理了一份可直接落地的四阶段学习规划，总时长约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 项目
• 内容安全
• 互联网信息服务算法备案
• …

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

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

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

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