从龙虾到爱马仕：一个老虾农的"叛逃"实录

从龙虾到爱马仕：一个老虾农的"叛逃"实录

深度拆解 Hermes Agent（江湖人称"爱马仕"）的 Skills 闭环、三层记忆、五道安全防线——以及为什么它让我养了三个月的龙虾"下岗"了。

导语

养了三个月龙虾（OpenClaw），换了十几个 Skills，调了无数次 MEMORY.md，折腾得我一度怀疑自己在养一只电子宠物。

然后上周五，我装了 Hermes Agent——圈子里都叫它"爱马仕"。

两小时后我做了一个决定：把龙虾的笼子拆了。

不是因为 Hermes 功能比 OpenClaw 多——说实话，功能层面两者打得有来有回。而是因为用了 Hermes 之后我才意识到，龙虾这三个月一直在"假装"记住我，而 Hermes 是真的在学我。

这种感觉怎么描述呢？就好像你一直以为养了只聪明的鹦鹉，能学你说话，能按指令做事。突然有一天你领回来一只金毛，它不仅听得懂你说话，还能看你脸色行事，而且你越养它越懂你。

这篇文章不是评测，也不是教程。就是一个养了三个月龙虾的"老虾农"，装了 Hermes 之后真实的心路历程和技术深度拆解。如果你只想看结论，直接跳到末尾的总对比表格。

一、先交代背景：三个月龙虾，三个痛点

2026 年 1 月，OpenClaw 爆了，GitHub 三天 6 万 Star。我属于第一批跳进去的——写技术文章、研究开源项目、搞自动化脚本、偶尔炒个币，确实需要一个能干活的 AI 助手。

装完之后爽了一阵，但三个月下来，三个问题越来越让我难受：

痛点 具体表现
记忆是"假"的 说了五次"默认用 Go 不要 Python"，它记的是"用户喜欢喝咖啡"。本质是往 MEMORY.md 写东西，写不写全靠模型抽签
Skills 是"死"的 5700+ 技能全是社区手写 Markdown，写完永不更新。我用的"GitHub PR Review"还在调已弃用的 API v3
安全是"裸"的 让它清理测试目录，它"聪明"地 rm -rf 了 /tmp 下一堆东西。安全全靠模型"判断"——让大模型当安检，你觉得靠谱？

忍了三个月。直到 Hermes Agent 在 GitHub Trending 连续霸榜。

二、装 Hermes：一行命令，无痛切换

先说安装体验，因为这是我对 Hermes 的第一个"卧槽"时刻。

OpenClaw 当年装的时候是这样的：

# 先装 Node.js 22+
# 再跑三条命令
curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon
openclaw dashboard

三条命令，大概 5 分钟。还行，不算复杂。

Hermes 呢？

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

一行。

这个安装脚本会自动搞定 Python 3.11、Node.js、所有依赖项、仓库克隆，最后给你设好全局 hermes 命令。装完之后 source ~/.zshrc，然后输入 hermes，直接就能聊。

但真正让我震惊的是这一步：

hermes claw migrate

它会自动检测你本地的 OpenClaw 配置——你的 API Key、记忆文件、Skills、偏好设置——然后一键导入 Hermes。

三个月的龙虾配置，5 秒钟搬家完毕。

我确认了一下，之前在 OpenClaw 里配的 OpenRouter API Key 过来了，自定义的几个 Skills 也过来了，甚至 MEMORY.md 里那些七零八落的记忆也被导入到了 Hermes 的记忆系统里。

当然，导入只是第一步。真正让我决定"杀虾"的，是后面两小时的体验。

三、Hermes 架构全景：先看整体再看细节

在深入各个子系统之前，先给一张全景图。Hermes 的架构可以拆成 五大核心模块：

┌─────────────────────────────────────────────────────────┐
│                    Hermes Agent 架构                      │
├─────────────┬─────────────┬──────────────┬──────────────┤
│  三层记忆系统  │  Skills 闭环  │   安全框架     │  消息网关     │
│             │   系统       │              │              │
│ ┌─────────┐ │ ┌─────────┐ │ ┌──────────┐ │ ┌──────────┐ │
│ │会话记忆  │ │ │经验提取  │ │ │用户授权   │ │ │Telegram  │ │
│ │(Working) │ │ │知识存储  │ │ │命令审批   │ │ │Discord   │ │
│ ├─────────┤ │ │智能检索  │ │ │容器隔离   │ │ │Slack     │ │
│ │持久记忆  │ │ │上下文注入│ │ │凭证过滤   │ │ │WhatsApp  │ │
│ │(SQLite   │ │ │执行验证  │ │ │注入扫描   │ │ │Signal    │ │
│ │ +FTS5)   │ │ │自动改进  │ │ ├──────────┤ │ │Terminal  │ │
│ ├─────────┤ │ │知识复用  │ │ │skills    │ │ └──────────┘ │
│ │技能记忆  │ │ └─────────┘ │ │ _guard    │ │              │
│ │(Skills)  │ │             │ │免疫系统   │ │              │
│ └─────────┘ │             │ └──────────┘ │              │
├─────────────┴─────────────┴──────────────┴──────────────┤
│              模型层：Nous Portal / OpenRouter 200+        │
│              / OpenAI / 本地 vLLM / Claude 原生           │
├─────────────────────────────────────────────────────────┤
│              执行层：并行子 Agent（独立进程 + RPC）         │
│              + 可选 Docker 沙箱                           │
└─────────────────────────────────────────────────────────┘

核心设计理念：每个模块独立演进，但通过统一的 Memory + Skill 层串联。记忆回答"用户是谁、偏好什么"，技能回答"遇到这个问题该怎么做"，安全框架确保"做的时候不出事"，消息网关让"在哪都能用"。

下面逐一深入。

四、记忆系统：从"抽签"到"刻骨铭心"

OpenClaw 是"你来指挥的系统"，Hermes 是"自己会长大的助手"。 这个区别在记忆系统上体现得最明显。

Hermes 的记忆：三层大脑

Hermes 的记忆系统是我见过的 Agent 项目里设计最精密的。它分三层：

Layer 1：会话记忆（Working Memory）

当前对话的上下文。这一层所有 Agent 都有，没什么特别的。但 Hermes 加了一个细节：当会话过长时，它不是简单地截断，而是用 LLM 生成摘要替换旧内容。你不会因为聊久了就失去上下文。

Layer 2：持久记忆（Persistent Memory）

这是 Hermes 的杀手锏。所有跨会话的信息——你的偏好、项目背景、工作习惯——都存在本地 SQLite 数据库里，用 FTS5 全文检索索引。

关键是它的写入机制。Hermes 不是让模型"自行判断"要不要记，而是有一套规则引擎：

  • 主动记忆：当你明确说"记住这个"或者纠正它的行为时，100% 写入
  • 被动记忆：完成任务后，自动提取关键决策点和偏好信号
  • 定期巩固：后台会定期整理记忆，合并重复项、淘汰过时信息

实际效果是什么呢？

我第一天跟 Hermes 说"我写代码默认用 Go"。第二天让它帮我写一个 HTTP 服务，它直接用 Go + Gin 框架——没有问我用什么语言，也没有默认给我写 Python。

我在第三天的一次对话中提到"最近在研究量化交易"，之后每次我说"帮我写个策略"，它会默认理解为"量化交易策略"而不是"内容策略"或"市场策略"。

这不是记忆，这是理解。

Layer 3：技能记忆（Skill Memory）

这个我放到下一节详细说，因为它太重要了。

记忆系统对比

维度 OpenClaw Hermes
存储方式 MEMORY.md 平铺文本 SQLite + FTS5 全文检索
写入机制 模型"自行判断"，不可控 规则引擎（主动 / 被动 / 定期巩固）
记忆层级 单层，无优先级、无分类 三层（会话 / 持久 / 技能）
衰减机制 ❌ 用久了变信息垃圾场 ✅ 定期整理，合并重复、淘汰过时
跨会话延续 依赖 MEMORY.md 碰运气 持久层精确召回
会话过长处理 简单截断 LLM 生成摘要替换旧内容

实测验证

测试场景 OpenClaw Hermes
第 1 天说"文章要口语化"，第 3 天让它写文章 "本文将介绍……首先我们需要了解……" "最近刷 GitHub 看到个有意思的东西，今天来聊聊。"
周一聊 Go 项目架构到一半，周三说"继续上次的" "我不太确定您指的是上次哪个话题" "上次聊到网关层要不要用 gRPC，你倾向用但担心调试复杂度。我想了几个思路……"

就这种体验上的差距，足以让我弃虾了。

五、Skills 闭环系统：Hermes 的灵魂所在

如果说记忆系统让我心动，那 Hermes 的 Skills 系统就是让我彻底"杀虾"的最后一刀。

这不是我一个人的判断。腾讯云开发者社区最近发了一篇深度拆解文章，把 Hermes 的 Skills 系统称为"认知科学中'程序性记忆'的工程化模拟"——说人话就是，它让 AI 像人类专家一样积累经验，把成功的做法变成可复用、可迭代的"方法资产库"。

我深以为然。下面先简单说说 OpenClaw 的做法，然后重点拆 Hermes。

OpenClaw 的 Skills：一句话概括

5700+ 个社区手写 Skill，数量厉害但写完就不会变。社区热度一过，大量技能变成"代码遗产"。（我用的"GitHub PR Review"技能还在调已弃用的 API v3 接口……）

Hermes 的 Skills：七阶段闭环生命周期

Hermes 的技能系统建立在一个完全不同的理念上：技能不是人写的，是 Agent 自己从经验中提炼的。 而且它不是简单的"存一下"，而是实现了一个完整的 7 阶段闭环：

经验提取 → 知识存储 → 智能检索 → 上下文注入 → 执行验证 → 自动改进 → 知识复用
    ↑                                                              ↓
    └──────────────────────────────────────────────────────────────┘

每个阶段都有精心设计的工程细节。下面逐一拆解。

阶段 1：经验提取——什么时候创建 Skill？

不是每次对话都会生成 Skill。Hermes 的 System Prompt 里有明确的触发规则，Agent 自主判断何时"值得"创建技能：

  • 修复了一个棘手的错误
  • 任务涉及 5 次以上工具调用
  • 发现了非显而易见的解决路径
  • 执行了特定平台或环境的配置流程

核心原则是："过时的 Skill 比没有 Skill 更危险"——宁缺毋滥，但一旦值得记录，就立刻记。

阶段 2：知识存储——Skill 文件长什么样？

每个 Skill 是一个 YAML Frontmatter + Markdown Body 的文件，大概长这样：

---
name: go-dependency-audit
version: 2
requires_toolsets:
  - shell
  - web_search
platforms:
  - linux
  - macos
triggers:
  - "审计依赖"
  - "dependency security"
---

# Go 项目依赖安全审计

## 前置条件
- Go 1.21+ 已安装
- 项目使用 Go Modules

## 步骤
1. 运行 `govulncheck ./...` 做初筛（v2 新增）
2. 对标记为 vulnerable 的依赖，查询 NVD 数据库获取详情
3. 如果项目使用 workspace 模式，需要逐个 module 分别检查
4. 生成安全报告，按严重等级排序

## 注意事项
- govulncheck 只检测实际调用路径中的漏洞，间接依赖需手动确认

Frontmatter 是给机器读的——触发条件、平台要求、依赖工具；正文是给 Agent 理解的——步骤、注意事项、边界情况。机器和 AI 各取所需。

存储过程还有两个安全细节值得一提：

  • 原子写入：先写临时文件，再原子替换，防止进程崩溃导致文件损坏
  • 写入后扫描：避免"检查与使用之间的时间差"（TOCTOU 竞态条件），确保扫描的是最终落盘内容

阶段 3：智能检索——两层缓存索引

技能多了之后，每次对话都全量扫描一遍 Skill 目录显然不现实。Hermes 设计了两层缓存来解决这个问题：

层级 机制 命中耗时
L1（进程内 LRU 缓存） 热路径缓存，键值包含当前可用工具 + 平台信息，确保不同配置下的隔离性 ~0.001ms
L2（磁盘快照） 对比文件修改时间和大小来验证快照有效性，避免全量扫描 ~1ms
全扫描（兜底） 遍历所有 Skill 文件 50-500ms

日常使用中，绝大多数请求在 L1 就命中了——从"有几百个 Skill"到"加载完全无感"。

阶段 4：条件激活——智能可见性控制

并非所有 Skill 都需要时刻可见。Hermes 通过 Frontmatter 中的元数据实现智能过滤：

  • 如果你已经配置了强大的 Web Search API，那个"手动网页搜索"的 Skill 会自动隐藏
  • 如果你在 macOS 上，Linux-only 的 Skill 不会出现在列表里
  • 某个 Skill 标记为 fallback_for_toolsets: [web_search]，只有在 web_search 工具不可用时才会激活

结果：Agent 永远只看到当前环境下真正有用的技能，上下文干净、Token 省了。

阶段 5：渐进式加载——三级披露策略

这是受 Anthropic Claude 的设计哲学启发的精妙设计：

级别 加载内容 Token 消耗
Tier 1（索引） System Prompt 中仅注入技能名称 + 一句话描述 ~20 tokens/个
Tier 2（内容） Agent 判断需要时，调用 skill_view 加载完整 Markdown 按需
Tier 3（支撑文件） 加载 Skill 引用的外部 API 文档、脚本等附件 按需

100 个 Skill 在 Tier 1 阶段只占 ~2000 tokens——日常对话几乎无感。加载过程还内置了三道安全检查：Prompt Injection 检测（过滤恶意指令）、路径穿越防护（防止访问 ../../.env）、环境变量依赖检查。

OpenClaw 没有这个机制，技能多了上下文就炸了。

阶段 6：注入策略——一个反直觉的架构决策

Skill 内容加载后，怎么注入到对话里？直觉上应该放到 System Prompt 里，对吧？

Hermes 偏不。它把 Skill 内容作为 User Message 插入对话历史。

为什么？两个字：缓存。

现在主流模型都支持 Prompt Cache——System Prompt 不变的情况下，首次计算后会被缓存，后续调用成本大幅降低。但如果你每次往 System Prompt 里塞不同的 Skill 内容，缓存就废了，每轮对话都要重新处理完整的 System Prompt。

User Message 注入的代价是什么？指令跟随的"权威性"稍低一点（模型对 System Prompt 的遵从度高于 User Message）。但这个微小的牺牲，换来的是数十倍的成本节约。

这种"反直觉但算过账"的工程决策，是 Hermes 团队工程素养的体现。

阶段 7：自动改进——闭环的闭合点

这是整个系统最酷的部分。当 Agent 在使用某个 Skill 时发现指令过时或有误，它会立刻修补，而不是"记个笔记等下次处理"。

修补过程有两个工程亮点：

  • 模糊匹配引擎：LLM 回忆 Skill 内容时经常有空格、缩进等微小差异，精确匹配几乎必定失败。Hermes 使用 fuzzy match 来定位需要修改的内容，大幅提高修补成功率
  • 级联缓存清理：修补成功后，自动清理 L1/L2 缓存和磁盘快照，确保下一次对话加载的是最新版本

真实案例：从 8 分钟到 3 分钟

我让 Hermes 帮我分析一个 Go 项目的依赖安全性。

第一次：go list -m all → 逐个去 NVD 数据库查漏洞 → 生成报告。8 分钟，调用了 12 个工具。完成后，它自动生成了 go-dependency-audit Skill v1。

第二次（一周后）：加载 Skill，发现可以先用 govulncheck 做初筛，只对有问题的依赖再查详情。3 分钟搞定。 然后自动把 govulncheck 步骤更新到 Skill v2。

你什么都没教它，它自己变强了。

Skill 与 Memory 的分工

很多人搞不清 Hermes 的 Skill 和 Memory 是什么关系。简单说：

Memory（记忆） Skill（技能）
回答的问题 "是什么" "怎么做"
存储内容 用户偏好、项目背景、事实性知识 执行特定任务的步骤、SOP、最佳实践
例子 "用户写代码用 Go" "审计 Go 依赖安全性的 7 个步骤"

Memory 让 Hermes 了解你，Skill 让 Hermes 帮你做事。两者协同，才是"越用越懂你"的完整体验。

学术溯源：从 Minecraft 到现实世界

Hermes 的 Skills 系统并非凭空设计。它的概念源于 2023 年 NVIDIA 发表的 Voyager 论文——一个在 Minecraft 中自探索、自学习的 Agent。Voyager 证明了"Agent 可以从经验中自动提炼可复用技能"这个想法是可行的。

Hermes 做的事情，是把这个学术原型工程化为真实世界产品，解决了 Voyager 没碰过的问题：并发安全、成本控制、恶意防护、多平台适配。它站在了巨人的肩膀上，但走得比巨人远。

Skills 系统对比

维度 OpenClaw Hermes
技能来源 社区手写 + ClawHub 审核 Agent 自动创建 + 社区共享
技能格式 Markdown YAML Frontmatter + Markdown（agentskills.io 标准）
自动进化 ❌ 写完不变，需人工维护 ✅ 7 阶段闭环，使用中自动迭代
技能数量 5700+ 社区 + ~1700 内置 40 内置 + 无限自创建
技能加载 全量加载，技能多上下文爆炸 三级渐进披露（~20 tokens/Skill）
条件激活 ❌ 全部可见 ✅ 按平台/工具集/回退策略智能过滤
缓存优化 无 L1 LRU（~0.001ms）+ L2 磁盘快照（~1ms）
注入策略 直接塞 System Prompt User Message 注入，保全 Prompt Cache
自修补 ❌ ✅ Fuzzy Match + 级联缓存清理
安全扫描 依赖社区审核 skills_guard 90+ 正则 + 信任分级

六、安全性：从"模型级"到"框架级"

这个话题我想单独拎出来说，因为安全性是 OpenClaw 最大的短板，也是 Hermes 最被低估的优势。

OpenClaw 的安全：一句话

让大模型自己判断某个操作是否安全。 社区已有误删邮件、误改配置的事故报告，开发者的回应是"优化 prompt"——用 prompt 修补安全漏洞，你品品。

Hermes 的安全：五道防火墙 + 技能免疫系统

Hermes 的安全是在框架层面实现的，不依赖模型的"判断力"。先说五层运行时防线：

第一层：用户授权检查
每个操作都会检查当前用户的权限级别。你可以配置哪些操作需要确认、哪些可以自动执行。

第二层：危险命令审批
对高风险命令（rm、chmod、kill、sudo 等），无论模型怎么判断，框架都会强制要求用户确认。不是 prompt 里告诉它"小心点"，而是代码逻辑直接拦截。

第三层：容器隔离
可选的 Docker 执行环境——只读根目录、权限降级、PID 限制。即使 Agent 发疯了，它也被关在笼子里。

第四层：MCP 凭证过滤
当 Agent 调用外部工具（通过 MCP 协议）时，框架会自动过滤敏感凭证，防止 token 泄露。

第五层：上下文注入扫描
对输入内容做 prompt injection 检测——如果有人试图通过恶意输入劫持 Agent 的行为，框架会告警并拦截。

这五层防护里，没有一层依赖模型的判断。全是框架级的硬逻辑。

技能免疫系统：skills_guard

上面五层是运行时的安全。但 Hermes 的 Skill 可以自创建、可以从社区导入——如果有人写了一个恶意 Skill 怎么办？

Hermes 实现了 skills_guard.py，相当于技能系统的免疫系统：

威胁检测：内置 90+ 种正则模式，检测 Skill 内容中的可疑行为——密钥泄露（硬编码的 API Key）、恶意命令（隐藏的 curl 窃取数据）、危险操作（未经确认的 rm -rf）。

信任分级：不同来源的 Skill，安全策略不同：

来源 信任级别 策略
内置 Skill 完全信任 直接加载
受信任来源 高信任 允许警告级别，阻止危险操作
社区 Skill 低信任 最严格，任何高于 safe 的级别均阻止
Agent 自创 中信任 较宽松，但遇到危险操作会询问用户

结构性检查：限制 Skill 文件数量（<50）和大小（<1MB），检测符号链接逃逸——防止有人通过软链接让 Skill 读取 /etc/passwd 之类的系统文件。

用人话说就是：OpenClaw 是让 AI 自己决定"我该不该做这件事"，Hermes 是让系统规则决定"AI 能不能做这件事"。哪个靠谱，不用我说了吧？

安全性对比

维度 OpenClaw Hermes
安全模型 模型级（prompt 约束） 框架级（代码逻辑硬拦截）
危险命令 模型自行判断 框架强制拦截 rm/chmod/sudo 等
执行隔离 ❌ 宿主机裸奔 ✅ 可选 Docker 沙箱（只读根 + 权限降级）
凭证保护 无特殊处理 MCP 调用自动过滤敏感凭证
注入防护 无 Prompt Injection 检测 + 告警拦截
Skill 安全 依赖社区审核 skills_guard（90+ 正则 + 信任分级 + 结构检查）

七、使用体验细节差异

除了三大核心模块（记忆 / Skills / 安全），日常体验中还有一堆"Hermes 真的想清楚了"的细节：

维度 OpenClaw Hermes
消息网关 10+ 平台，但各平台会话隔离 同样多平台，且跨平台对话连续——早上 Telegram 聊到一半，晚上终端说"继续"它知道你说的是什么
模型支持 主流模型 Nous Portal / OpenRouter 200+ / OpenAI / 本地 vLLM / Claude 原生支持
TUI 交互 基础命令行 多行编辑、Slash 命令补全、流式工具调用、对话历史搜索、Ctrl+C 中断不退出
并行能力 串行执行 spawn 隔离子 Agent 并行工作（独立进程 + RPC 通信）
迁移 — hermes claw migrate 一键导入龙虾全部配置

几个值得展开说的：

跨平台连续性：你早上在 Telegram 上说"帮我分析那个项目的性能瓶颈"，它分析到一半你出门了。晚上在终端里说"继续"——它知道你说的是早上 Telegram 上的话题。这背后是三层记忆系统在跨平台共享会话上下文。

模型自由：一条命令切换模型，零代码改动。最惊喜的是原生支持 Claude 额度——有 Anthropic 订阅直接用。

hermes model  # 交互式选择模型

并行子 Agent：让它"同时审计三个项目的依赖安全性"，它会开三个子进程并行处理，最后汇总报告。不是"排队"，是真并行。

八、也说说 Hermes 的不足

写到这里好像我在给 Hermes 写广告。不是的，它确实也有明显的短板：

1. 中文生态几乎为零

OpenClaw 的中文社区极其活跃——教程、视频、微信群、公众号、翻译文档……你遇到任何问题都能找到中文资源。

Hermes 目前的中文资料几乎为零。官方文档是全英文的（虽然官网有中文页面但内容还很粗略），社区讨论也以英文为主。如果你英文不太好，上手成本会比 OpenClaw 高不少。

2. Dashboard 缺失

OpenClaw 有一个漂亮的 Web Dashboard，不懂命令行的人也能通过网页管理一切。

Hermes 没有 Dashboard。一切都在终端里完成。它的理念是"AI 原生交互"——不需要 GUI，直接跟 Agent 说就行。这个理念我认同，但对非技术用户来说确实不太友好。

3. 生态规模差距

OpenClaw 34 万+ Star、5700+ Skills、130+ 贡献者。Hermes 3.9 万 Star、40 内置技能 + 自创建、327 贡献者。

数量上差距明显。虽然 Hermes 的技能可以自进化，但初始的内置技能覆盖面确实不如 OpenClaw 的社区库丰富。

4. Windows 原生不支持

Hermes 目前只支持 Linux、macOS 和 WSL2。如果你是纯 Windows 用户且不想折腾 WSL，这是个硬伤。

5. 技术层面的已知改进空间

说完用户侧感知，再说几个技术层面的：

  • Skill 缺少版本控制：Patch 后旧版本永久丢失，无法回滚误修正。如果 Agent 改错了一个关键 Skill，你只能手动恢复
  • 安全扫描依赖正则：skills_guard 的 90+ 正则模式可以被 Base64 编码等方式绕过，团队计划引入 LLM 辅助语义审查
  • 索引匹配依赖 LLM：当前 Skill 检索靠 LLM 理解自然语言描述来匹配，可能遗漏语义相关但措辞不同的 Skill。未来计划引入 Embedding 语义匹配
  • 单机存储限制：记忆和技能都存在本地，缺乏多设备间的原生同步机制

这些不是致命问题，但说明 Hermes 还在快速迭代中。好消息是，这些都是工程问题而非架构缺陷——修起来只是时间问题。

九、总对比：一张表看清全貌

维度 OpenClaw Hermes Agent
产品哲学 用户指挥，AI 执行 AI 学习用户，主动进化
记忆系统 MEMORY.md 平铺文本，模型自行判断写入 三层记忆（会话 / 持久 SQLite+FTS5 / 技能），规则引擎 + 定期巩固
技能来源 社区手写 5700+ Skill Agent 自创建 + 40 内置 + 社区共享
技能进化 ❌ 写完不变，需人工维护 ✅ 使用中自动迭代（7 阶段闭环）
技能加载 全量加载，技能多了上下文爆炸 三级渐进披露，~20 tokens/Skill
安全模型 模型级（prompt 约束） 框架级（5 层防线 + skills_guard 免疫系统）
Skill 安全 依赖社区审核 90+ 正则检测 + 信任分级 + 结构检查
跨平台会话 ❌ 各平台隔离 ✅ 跨平台对话连续性
并行能力 串行执行 子 Agent 并行（独立进程 + RPC 通信）
模型支持 主流模型 Nous Portal / OpenRouter 200+ / 本地 vLLM / Claude 原生
迁移成本 — hermes claw migrate 一键导入
中文生态 ✅ 极其丰富 ❌ 几乎为零
GUI ✅ Web Dashboard ❌ 纯终端 TUI
平台支持 全平台 Linux / macOS / WSL2
GitHub Star 34 万+ 3.9 万+
成本优化 无特殊设计 Skill 注入走 User Message，保全 Prompt Cache

十、我的结论：龙虾不是死了，是进化了

说"龙虾已死"其实是标题党。OpenClaw 没有死，它依然是功能最全、生态最大、中文支持最好的开源 Agent。如果你是非技术用户、需要中文支持、或者已经在 OpenClaw 生态里玩得很舒服，完全没必要急着换。

但如果你是这几类人：

  • 开发者，习惯命令行，英文没问题
  • 长期主义者，想要一个越用越懂你的 AI 助手
  • 安全敏感，不放心让 AI 在宿主机上裸奔
  • Claude 用户，想复用已有的 Anthropic 额度
  • AI 研究者，需要一个可以做 RL 训练的 Agent 框架

那我强烈建议你试试 Hermes。

龙虾（OpenClaw）是你指挥的工具。Hermes 是跟你一起成长的伙伴。

这是两种完全不同的产品哲学。OpenClaw 相信"用户最懂自己的需求，AI 负责执行"。Hermes 相信"AI 应该学会理解用户，主动变得更好"。

谁对谁错？可能都对。但作为一个用了三个月龙虾的人，我更想要后者。

因为我请 AI 助手的初衷，不是多一个"需要我不断调教的工具"，而是少操一点心。

十一、快速上手指南

如果你看完想试试，这是最简路径：

# 1. 一行安装
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# 2. 重载 shell
source ~/.zshrc  # 或 source ~/.bashrc

# 3. 如果你之前用 OpenClaw，一键迁移
hermes claw migrate

# 4. 选模型（推荐 OpenRouter，200+ 模型可选）
hermes model

# 5. 开聊
hermes

# 6.（可选）接入 Telegram，随时随地用
hermes gateway setup   # 选 Telegram，填 Bot Token
hermes gateway         # 启动网关

整个过程不到 10 分钟。如果你之前有 OpenClaw，迁移过程 5 秒钟。

十二、写在最后

2026 年的 AI Agent 赛道，卷得像 2015 年的共享单车。OpenClaw 打了样之后，各种"龙虾杀手"跟下饺子似的往外冒——Nanobot、NanoClaw、Hermes、还有一堆叫不上名字的。

但 Hermes 不一样。它不是又一个"我也能做 OpenClaw 做的事"的 me-too 产品。它提出了一个根本性的问题：

AI 助手应不应该随着使用变得更好？

OpenClaw 的答案是"不需要，用户自己会调教"。Hermes 的答案是"当然应该，这才是 Agent 存在的意义"。

我选后者。

不是因为 Hermes 现在比 OpenClaw 更完善——它显然还没有。而是因为它的天花板更高。一个会自我进化的 Agent，理论上没有能力上限。而一个依赖人工维护技能库的 Agent，它的上限就是社区的勤奋程度。

从技术角度看，Hermes 最让我佩服的不是某个单点功能，而是贯穿始终的工程品味：用 User Message 注入保全 Prompt Cache、用模糊匹配提高 Skill 自修补成功率、用两层缓存让百级 Skill 检索无感、用信任分级而非一刀切处理安全问题——每一个决策都是"反直觉但算过账"的。

这种品味不是靠堆功能堆出来的，是靠在真实场景中反复踩坑、反复权衡练出来的。

三个月前我养了一只龙虾。今天我换了一只爱马仕。

龙虾很好。但爱马仕，更懂我。

相关链接

关注公众号「coft」，获取更多 AI 实战干货和开源项目深度解析。

posted @ 2026-04-15 20:32  warm3snow  阅读(47)  评论(0)    收藏  举报