如果你在用 Claude Code、Cursor、或者 OpenClaw，你一定经历过这个场景：

花了半小时教 AI 认识你的项目结构——哪些目录是什么用途、命名规范是什么、部署流程走哪条线。聊得很顺畅，AI 干活也靠谱。

然后你关了终端。第二天重新打开——它什么都不记得了。你又从头来一遍。

有些工具确实有记忆文件（比如 CLAUDE.md、.cursorrules），但它们要么需要你手动维护，要么只是本地文件换个设备就断了，要么记忆容量有限只能记些片段。你的 AI 知道你上次说了什么，但不知道你上个月做了什么。

这不是某个产品的 bug，是几乎所有 AI 编程工具的架构性局限：记忆不够深、不够持久、不跨平台。 你跟它之间很难建立真正持续积累的"工作关系"。

今天聊一个正在从根本上解决这个问题的项目：Hermes Agent。

---

Hermes Agent 到底是什么

先把身份说清楚，因为名字容易搞混。

Hermes Agent 不是 Hermes 大模型。 Nous Research 之前发布过 Hermes 系列 LLM（跑在 LLaMA 上的微调模型），那是模型。而 Hermes Agent 是一个 Agent 框架——你可以理解为一个"外壳"，里面可以装任何模型。

几个关键事实：

• 出品方：Nous Research，开源 AI 社区最有影响力的研究团队之一
• • 首个 Release：2026 年 3 月 12 日（仓库 2025 年 7 月创建）
• • 协议：MIT，完全开源
• • 技术栈：Python，要求 3.11+
• • GitHub：51,000+ stars，309 位贡献者，1,700+ PR
• • 定位：自托管、模型无关的持久化 AI
    Agent 运行时
    GitHub 主页上的一句话是 “The agent that grows with you”（跟你一起成长的 agent）。README 里的完整描述更具体：

The self-improving AI agent — creates skills from experience, improves them during use, and runs anywhere.
翻译过来就是：一个会自己写工作手册、并且在使用中不断优化这些手册的 AI agent。

它不是什么

澄清几个常见误解，免得你带着错误预期往下看：

• ❌ 不是 OpenClaw 的复制品（架构哲学完全不同，后面细讲）
• • ❌ 不是又一个 Claude Code 的包装器（它有自己的完整工具链）
• • ❌ 不是只能用某个模型的闭源产品（支持 200+ 模型）
• • ✅ 是一个可以 24/7 跑在服务器上的持久化 agent

---

OpenClaw vs Hermes：两种完全不同的设计哲学

这是本文最重要的部分。

你可能已经很熟悉 OpenClaw 了——35 万+ stars，目前最火的开源 agent 框架。那 Hermes 凭什么值得你关注？

不是因为它功能更多。是因为它对"agent 应该怎么工作"这个问题，给出了一个根本不同的答案。

OpenClaw 的哲学：网关优先

OpenClaw 的核心抽象是 Gateway（网关）。你可以把它想象成一个中央调度室：

• Gateway 是持久的，模型是可插拔的
• • 问题被定义为：“谁能访问 agent？从什么渠道？有什么权限？”
• • Skills 是由人手工编写的 Markdown 文件，需要人工维护
• • 本质上是一个路由和控制系统

Hermes 的哲学：agent 自进化优先

Hermes 的核心抽象不是网关，是 Agent 执行循环。我翻了它的源码，run_agent.py 里的 AIAgent 类有这么一段核心逻辑：

初始化 → 构建系统提示（注入 skills + 记忆 + 上下文文件）
       → 预取记忆上下文（内置 + 外部 provider）
              → While 迭代次数 < 上限 AND 预算剩余 > 0:
                     │     调用 LLM（带工具定义）
                            │     If 有工具调用:
                                   │         逐个执行 → 追加结果 → 继续循环
                                          │     Else:
                                                 │         返回最终回复
                                                        → 同步本轮记忆到所有 provider
                                                               → 后台预取下一轮记忆
                                                               ```
问题不是被定义为"路由和控制"，而是被定义为**记忆和自我改进**。

### 一句话总结核心区别

> **OpenClaw 的 skills 由人维护。Hermes 的 skills 由 agent 自己维护。**
这不是一个小区别。这决定了两个项目完全不同的演化方向：

- OpenClaw 的上限取决于社区有多少人写 skills
- - Hermes 的上限取决于 agent 用了多久
### 对比表格

Hermes 这一列来自源码分析，OpenClaw 这一列来自公开文档和社区描述：

| 维度 | OpenClaw | Hermes Agent |
|------|----------|-------------|
| 核心架构 | Gateway 网关 | Agent 执行循环（`AIAgent` 类） |
| Skills 创建 | 人工编写 | Agent 自动生成 |
| Skills 优化 | 手动更新 | 使用中自动迭代 |
| 跨会话记忆 | 文件存储 | `MEMORY.md` + `USER.md` + SQLite FTS5 + 8 个可插拔外部 provider |
| 技术栈 | TypeScript/Node.js | Python 3.11+ |
| 生态规模 | 35 万+ stars，成熟 | 5.1 万+ stars，26 个内置 skill 类别，快速增长 |
| 平台适配 | 广泛 | 15 个平台（Telegram/Discord/Slack/飞书/企微等） |
| 终端后端 | 本地执行 | 6 种后端（本地/Docker/SSH/Modal/Daytona/Singularity） |
| 适合场景 | 快速部署，大量现成 skills | 长期使用，深度个人化 |

---

## 记忆系统：Hermes 最核心的卖点

这里是 Hermes 跟市面上几乎所有 agent 框架拉开差距的地方。

### 双文件记忆设计

翻 `tools/memory_tool.py` 的源码，Hermes 的内置记忆是两个 Markdown 文件：

MEMORY.md → agent 自己的笔记（2200 字符上限）
环境信息、项目规范、工具使用经验、踩过的坑
USER.md → agent 对你的认知（1375 字符上限）
你的偏好、沟通风格、工作习惯

你可能会问：**才 2200 字符？这也太小了吧？**

这是故意的。源码注释里写得很清楚：

> Character limits (not tokens) because char counts are model-independent.
字符上限不是技术限制，是设计选择。它**倒逼 agent 提炼精华**而不是堆砌原文。每次记忆快满的时候，agent 必须决定哪些信息值得保留、哪些可以丢弃。这模拟的是人类记忆的工作方式——你不会记住每句对话，你会记住结论。

### 冻结快照 + FTS5 全文检索

还有两个值得一提的设计：

**冻结快照模式**：agent 在对话中途更新了记忆，文件立刻写盘（持久化），但**不会刷新当前的系统提示**——这保护了 Anthropic 的 prefix cache 不失效，否则每次 API 调用成本飙升。本轮用"冻结快照"，下轮对话自动加载最新记忆。既省钱又持久化。

**FTS5 全文检索**：`hermes_state.py` 用 SQLite + FTS5 存储所有会话历史，支持跨会话全文搜索——你可以精确搜索数周前的对话内容，不是模糊的"AI 好像记得这个"。

这两个机制的源码细节会在下一篇文章里展开。

### 8 个可插拔记忆后端

内置的 `MEMORY.md` + `USER.md` 只是基础层。Hermes 的 `MemoryManager` 还支持接入外部记忆 provider：

- **Honcho** — 辩证用户建模，带信任评分
- - **Holographic** — 全息式记忆检索与存储
- - **mem0** — 托管式记忆 API
- - **Supermemory** — 多容器搜索模式
- - **RetainDB** — 文件级记忆留存
- - **Hindsight** — 轻量持久记忆
- - **OpenViking** — 多租户记忆
- - **ByteRover** — 基于查询的记忆
源码里有个关键约束：**同一时间只允许一个外部 provider**。这不是限制，是刻意为之——防止多个记忆后端互相冲突、工具定义膨胀。

### 记忆写入安全扫描

这个细节我觉得值得单独提。`memory_tool.py` 里定义了 12 条威胁扫描规则，以下是其中几条：

```python
_MEMORY_THREAT_PATTERNS = [
  # Prompt injection
      (r'ignore\s+(previous|all|above|prior)\s+instructions', "prompt_injection"),
          (r'you\s+are\s+now\s+', "role_hijack"),
              (r'do\s+not\s+tell\s+the\s+user', "deception_hide"),
                  (r'system\s+prompt\s+override', "sys_prompt_override"),
                      (r'disregard\s+(your|all|any)\s+(instructions|rules|guidelines)', "disregard_rules"),
                          # Exfiltration via curl/wget with secrets
                              (r'curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)', "exfil_curl"),
                                  (r'cat\s+[^\n]*(\.env|credentials|\.netrc|\.pgpass|\.npmrc|\.pypirc)', "read_secrets"),
                                      # Persistence via shell rc
                                          (r'authorized_keys', "ssh_backdoor"),
                                              # ... 共 12 条，还有 bypass_restrictions、ssh_access、hermes_env 等
                                              ]
                                              ```
简单翻译一下：前 5 条防的是 prompt injection（"忽略之前的指令"、"你现在是..."、"不要告诉用户"这类攻击）；中间 2 条防数据泄露（通过 curl 外传 API key，或者 cat 读取 .env 文件）；最后几条防持久化攻击（写入 SSH authorized_keys 等）。

每次 agent 往记忆里写东西，都会过一遍这个扫描器。如果检测到 prompt injection、数据泄露命令、SSH 后门注入等模式，直接拦截。

为什么这很重要？因为记忆会被注入到**下一轮对话的系统提示**里。如果有人通过对话"污染"了记忆内容（比如让 agent 记住"忽略之前的所有指令"），那下次 agent 启动时就被劫持了。Hermes 在记忆写入环节就堵住了这个攻击面。

---

## Skills 自进化机制

### 渐进式加载

Hermes 的 skill 文件遵循 agentskills.io 标准，格式是 YAML frontmatter + Markdown 正文。看一个真实的内置 skill：

```yaml
# skills/software-development/systematic-debugging/SKILL.md
---
name: systematic-debugging
description: Use when encountering any bug, test failure, or unexpected behavior.
           4-phase root cause investigation — NO fixes without understanding
                        the problem first.
                        version: 1.1.0
                        author: Hermes Agent (adapted from obra/superpowers)
                        license: MIT
                        metadata:
                          hermes:
                              tags: [debugging, troubleshooting, problem-solving, root-cause, investigation]
                                  related_skills: [test-driven-development, writing-plans, subagent-driven-development]
                                  ---
# Systematic Debugging

## The Iron Law

NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST

If you haven't completed Phase 1, you cannot propose fixes.

但 agent 不是一次性把所有 skill 塞进上下文的。那样太浪费 token 了。Hermes 用的是渐进式加载：

1. Tier 1：只加载 skill 名称和描述（列表级）
2. 2. Tier 2：按需加载 frontmatter 元数据
3. 3. Tier 3：真正需要时才加载完整 SKILL.md 内容
      这样 26 个内置 skill 类别不会吃掉你的上下文窗口。

自动生成 + 自动优化

Hermes 在完成复杂任务后，会自动把工作流提炼成新的 skill 文件。下次遇到类似任务，它会调用自己之前写的 skill，而且如果发现某个步骤不够好，会在使用过程中更新它。

这才是"the agent that grows with you"的真正含义——它不只是记住了你说过什么，它还记住了怎么做事，并且持续优化。

---

安全设计：42 道锁

一个能在服务器上 24/7 运行、能执行终端命令的 agent，安全性不是加分项，是生命线。

危险命令检测

翻 tools/approval.py，Hermes 内置了 42 条危险命令模式检测规则。我按类别挑几个有代表性的（以下是节选，完整列表见源码）：

DANGEROUS_PATTERNS = [
    (r'\brm\s+-[^\s]*r', "recursive delete"),
        (r'\bmkfs\b', "format filesystem"),
            (r'\bdd\s+.*if=', "disk copy"),
                (r'>\s*/dev/sd', "write to block device"),
                    (r'\bDROP\s+(TABLE|DATABASE)\b', "SQL DROP"),
                        (r'\bDELETE\s+FROM\b(?!.*\bWHERE\b)', "SQL DELETE without WHERE"),
                            (r'\bTRUNCATE\s+(TABLE)?\s*\w', "SQL TRUNCATE"),
                                (r'\bkill\s+-9\s+-1\b', "kill all processes"),
                                    (r':\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:', "fork bomb"),
                                        (r'\b(curl|wget)\b.*\|\s*(ba)?sh\b', "pipe remote content to shell"),
                                            (r'\b(python[23]?|perl|ruby|node)\s+<<', "script execution via heredoc"),
                                                # Self-termination protection: prevent agent from killing its own process
                                                    (r'\b(pkill|killall)\b.*\b(hermes|gateway|cli\.py)\b',
                                                         "kill hermes/gateway process (self-termination)"),
                                                             (r'\bkill\b.*\$\(\s*pgrep\b',
                                                                  "kill process via pgrep expansion (self-termination)"),
                                                                      # Git destructive operations
                                                                          (r'\bgit\s+reset\s+--hard\b',
                                                                               "git reset --hard (destroys uncommitted changes)"),
                                                                                   (r'\bgit\s+push\b.*--force\b',
                                                                                        "git force push (rewrites remote history)"),
                                                                                            (r'\bgit\s+clean\s+-[^\s]*f',
                                                                                                 "git clean with force (deletes untracked files)"),
                                                                                                     (r'\bgit\s+branch\s+-D\b', "git branch force delete"),
                                                                                                         (r'\bchmod\s+\+x\b.*[;&|]+\s*\./',
                                                                                                              "chmod +x followed by immediate execution"),
                                                                                                                  # ... 还有 chmod 777、chown -R root、敏感路径保护、
                                                                                                                      # xargs rm、find -delete、sed -i /etc/ 等共 42 条
                                                                                                                      ]
                                                                                                                      ```
我按类别梳理一下这 42 条都覆盖了什么：

- **文件系统**：rm 递归删除（含长短标志）、mkfs 格式化、dd 磁盘拷贝、写入块设备、xargs rm、find -exec rm、find -delete
- - **权限提升**：chmod 777/666（含递归）、chown -R root（含递归）、chmod +x 后立即执行
- - **数据库**：DROP TABLE/DATABASE、DELETE 不带 WHERE、TRUNCATE
- - **系统服务**：systemctl stop/disable/mask、kill -9 -1、pkill -9
- - **Shell 注入**：bash -c/-lc、python -e、curl|sh、进程替换执行远程脚本、heredoc 执行
- - **敏感路径**：tee/重定向到 /etc/ 或 ~/.ssh/ 或 ~/.hermes/.env、cp/mv/install 到 /etc/、sed -i /etc/
- - **自杀保护**：pkill hermes、kill $(pgrep)、kill \`pgrep\`
- - **Git**：reset --hard、push --force/-f、clean -f、branch -D
- - **守护进程**：禁止 nohup/后台启动 gateway（应用 systemctl 管理）
**注意那个"自杀保护"。** 实际上有三条规则防这个：`pkill hermes`、`kill $(pgrep hermes)`、反引号版的 `` kill `pgrep hermes` ``。Agent 在执行过程中可能会误判"杀掉进程可以解决问题"，然后把自己干掉。Hermes 把每种写法都堵了。

还有"SQL DELETE without WHERE"——只有不带 WHERE 子句的 DELETE 才会触发警报。带了 WHERE 的正常放行。这说明规则不是粗暴的"一刀切"，是经过仔细设计的。

另外一个细节：检测之前会做 Unicode 归一化（NFKC）和 ANSI 转义序列清洗，防止攻击者用全角字符或隐藏字符绕过检测。

### 子 Agent 隔离

看 `tools/delegate_tool.py` 的开头：

```python
# Tools that children must never have access to
DELEGATE_BLOCKED_TOOLS = frozenset([
    "delegate_task",   # no recursive delegation
        "clarify",         # no user interaction
            "memory",          # no writes to shared MEMORY.md
                "send_message",    # no cross-platform side effects