Hermes Agent 深度实战：当 AI 学会「自我进化」——从学习闭环到生产级持久记忆的完全指南（2026）

作者按：如果你用过 Claude Code、Cursor 或 Copilot，你一定遇到过这样的尴尬——每次新对话，AI 都把你怎么教它的忘得一干二净。今天要讲的 Hermes Agent，就是来解决这个问题的。它不是「更聪明的模型」，而是一套让 AI 越用越聪明的基础设施。

目录

1. 为什么我们需要「自进化」AI Agent？
2. Hermes Agent 是什么？核心定位与技术边界
3. 架构深度解构：三层自进化闭环
   • 3.1 第一层：记忆系统（Memory）
   • 3.2 第二层：技能系统（Skills）
   • 3.3 第三层：训练数据闭环（Training Data）
4. 核心子系统逐项拆解
   • 4.1 FTS5 全文检索引擎
   • 4.2 Honcho 用户建模
   • 4.3 Cron 定时调度器
   • 4.4 多平台消息网关
5. 从零部署：本地、Docker、VPS 三种路径
6. 代码实战：手搓一个自定义 Skill
7. 与生产级 Agent 框架的横向对比
   • 7.1 Hermes Agent vs OpenClaw
   • 7.2 Hermes Agent vs Superpowers
   • 7.3 Hermes Agent vs nanobot
8. 性能优化：让 Agent 跑得更快更稳
9. 真实场景案例：我用 Hermes Agent 做了什么
10. 局限性与未来路线图
11. 总结：自进化 Agent 的工程师视角

1. 为什么我们需要「自进化」AI Agent？

先说个真事。

我上个月用 Claude Code 做了一个全栈项目，前后花了大概 15 个小时对话。每次会话，我都得重新告诉它：「这个项目用的是 pnpm，不是 npm」「API 接口规范是 REST，不是 GraphQL」「数据库连接池用 Prisma，已经配好了」。

15 个小时，至少有 3 个小时在重复背景信息。

这不是 Claude 的问题，也不是任何大模型的问题——这是无状态对话系统的天然缺陷。每次会话结束，上下文清零，AI 就把你忘得干干净净。

现有的解决方案各有局限：

Hermes Agent 的核心创新，是提出了一个可运行的自进化闭环：

任务执行 → 经验评估 → 技能提取 → 持久化存储 → 下次直接复用

它不是靠更大的上下文窗口，也不是靠更聪明的模型——它是靠工程化的记忆和技能系统，让 Agent 在长期使用中持续积累能力。

用一句话总结：Hermes Agent 把「每次对话都是新开始」变成了「每次对话都在继承过去的经验」。

2. Hermes Agent 是什么？核心定位与技术边界

2.1 官方定位

Hermes Agent 由 Nous Research（就是做 Hermes 系列开源模型的那个实验室）于 2026 年 2 月正式发布，最新稳定版是 v0.14.0（截至本文写作时）。

官方 Slogan："The agent that grows with you" —— 与你一同成长的 Agent。

2.2 它是什么，不是什么

Hermes Agent 是一个通用型 AI Agent 平台，整合了以下能力：

• 大模型推理（支持 200+ 模型，OpenAI/Claude/Ollama/DeepSeek 等）
• 工具调用（文件操作、终端执行、网页检索、浏览器自动化）
• 持久化记忆（SQLite + FTS5 + LLM 摘要）
• 技能系统（自动从经验中创建结构化 Skill 文件）
• 定时任务（内置 Cron 调度器）
• 多平台接入（Telegram / Discord / Slack / WhatsApp / Signal / CLI）

它不是：

• ❌ 一个绑定在 IDE 里的编程助手（像 Cursor 那样）
• ❌ 一个套壳 API 的聊天机器人（像 Character.AI 那样）
• ❌ 一个靠提示词工程实现的「假记忆」系统

它本质上是一个可自托管的 Agent 运行时，可以部署在：

• 你本地的 MacBook（开发环境）
• 一台 $5/月的 VPS（轻量生产）
• GPU 集群（大规模并发）
• Daytona / Modal 等无服务器基础设施

2.3 技术栈概览

3. 架构深度解构：三层自进化闭环

这是 Hermes Agent 最核心的部分，也是它区别于所有其他 Agent 框架的根本原因。

3.1 第一层：记忆系统（Memory）

3.1.1 记忆的存储结构

Hermes Agent 的记忆系统基于 SQLite FTS5（全文检索）实现，所有会话历史存储在本地 SQLite 数据库中。

~/.hermes/
├── hermes.db          # 主数据库（会话历史 + 记忆索引）
├── config.toml        # 配置文件
├── MEMORY.md          # 人类可读的记忆摘要
├── USER.md            # 用户偏好记录
└── skills/            # 技能库目录
    ├── system/        # 系统内置技能
    ├── curated/       # 精选技能（社区验证）
    └── custom/        # 用户自定义技能

3.1.2 记忆的重要性评估

每次会话结束后，Hermes Agent 会运行一个记忆重要性评估的子流程：

# 伪代码：记忆重要性评估逻辑
def assess_memory_importance(conversation_history):
    """
    使用 LLM 对会话内容进行评估，决定哪些内容值得持久化
    """
    prompt = f"""
    Below is a conversation history. 
    Extract information worth remembering permanently:
    - User preferences and habits
    - Technical decisions and rationale
    - Recurring patterns in user requests
    - Errors encountered and how they were fixed
    
    Conversation:
    {conversation_history}
    
    Output JSON:
    {{
        "important_facts": [...],
        "user_preferences": [...],
        "technical_decisions": [...],
        "lessons_learned": [...]
    }}
    """
    
    response = llm.complete(prompt)
    return json.loads(response)

3.1.3 FTS5 全文检索的实现

SQLite FTS5 提供了毫秒级的全文检索能力。Hermes Agent 的检索流程：

-- 创建 FTS5 虚拟表
CREATE VIRTUAL TABLE memory_fts USING fts5(
    content,                   -- 记忆内容
    context,                   -- 上下文信息
    timestamp UNINDEXED,       -- 时间戳（不索引）
    importance_score UNINDEXED -- 重要性分数（不索引）
);

-- 检索记忆（BM25 排序）
SELECT 
    content, 
    bm25(memory_fts) as rank,
    timestamp
FROM memory_fts
WHERE memory_fts MATCH 'python async programming'
ORDER BY rank
LIMIT 5;

关键设计决策：为什么用 FTS5 而不是向量检索？

Nous Research 在源码中的注释给出了答案：

"FTS5 provides sub-millisecond latency for keyword queries, which covers 80% of memory recall scenarios. Vector search is reserved for semantic matching when keyword search fails."

翻译：大部分记忆召回场景都是关键词驱动的，FTS5 足够快足够准。语义检索（向量）作为 fallback。

3.1.4 LLM 摘要机制

当 FTS5 检索到相关记忆片段后，Hermes Agent 会用 LLM 对原始记忆进行摘要和上下文拼接：

def recall_memory(query, top_k=5):
    # Step 1: FTS5 关键词检索
    raw_memories = fts5_search(query, top_k=top_k)
    
    # Step 2: LLM 摘要和上下文拼接
    context_prompt = f"""
    User query: {query}
    
    Related memories found:
    {format_memories(raw_memories)}
    
    Please summarize the relevant context and present 
    it in a way that helps answer the user query.
    """
    
    summary = llm.complete(context_prompt)
    return summary

3.2 第二层：技能系统（Skills）

技能系统是 Hermes Agent 「自进化」的核心。它的设计哲学是：

把经验变成可复用的代码，而不是每次都重新推理。

3.2.1 技能文件的格式

每个 Skill 是一个结构化的 Markdown 文件，包含 YAML frontmatter 和 Markdown 正文：

---
name: fix_python_import_error
description: 自动修复 Python 模块导入错误
trigger:
  - "ModuleNotFoundError"
  - "ImportError"
  - "No module named"
success_criteria:
  - "错误消失"
  - "脚本能正常运行"
dependencies:
  - python3
  - pip
---

# 修复 Python 导入错误

## 问题诊断流程

1. 读取完整错误信息，提取缺失的模块名
2. 判断是标准库模块还是第三方包
3. 如果是第三方包，执行 `pip install <module>`
4. 如果是本地模块，检查 PYTHONPATH 和 sys.path

## 常见案例

### 案例 1：缺失 requests 包
错误信息：`ModuleNotFoundError: No module named 'requests'`
修复命令：`pip install requests`

### 案例 2：本地模块导入失败
错误信息：`ImportError: attempted relative import with no known parent package`
修复方案：检查项目结构，确保有 `__init__.py`，或使用绝对导入

## 验证方法

修复后执行原脚本，确认错误消失。

3.2.2 自动技能创建的触发条件

Hermes Agent 不会为每一个任务都创建技能。它有一套触发条件判断逻辑：

def should_create_skill(task_result):
    """
    决定是否从本次任务经验中创建技能
    """
    criteria = [
        task_result.tool_call_count >= 5,        # 至少 5 次工具调用
        task_result.has_error_and_fix(),          # 中途出错并修复
        task_result.user_satisfied(),              # 用户没有明确否定
        not task_result.is_trivial(),             # 不是 trivial 任务
        is_similar_task_rare(task_result)          # 类似任务不常见
    ]
    
    # 至少满足 3/5 个条件才创建技能
    return sum(criteria) >= 3

3.2.3 技能的自我改进机制

这是最酷的部分。当一个 Skill 被多次使用后，Hermes Agent 会自动改进它：

def improve_skill(skill_id, recent_uses):
    """
    根据最近的使用记录，改进技能文件
    """
    # 分析最近 N 次使用该技能的记录
    success_rate = calculate_success_rate(recent_uses)
    
    if success_rate < 0.7:
        # 成功率低于 70%，触发改进
        improvement_prompt = f"""
        Skill: {get_skill_content(skill_id)}
        
        Recent failures:
        {format_failures(recent_uses)}
        
        Please improve this skill by:
        1. Adding missing edge cases
        2. Updating outdated commands
        3. Adding more specific error patterns
        
        Output the improved skill in the same format.
        """
        
        improved_skill = llm.complete(improvement_prompt)
        save_skill(skill_id, improved_skill)
        log(f"Skill {skill_id} improved based on {len(recent_uses)} recent uses")

3.2.4 技能的执行流程

当 Hermes Agent 遇到一个任务时，技能系统的执行流程：

用户请求
  ↓
技能匹配（关键词 + 语义相似度）
  ↓
匹配成功？
  ├─ 是 → 加载技能文件 → 按技能指导执行 → 记录结果 → 改进技能（条件触发）
  └─ 否 → 常规 LLM 推理 → 任务完成后评估是否创建新技能

3.3 第三层：训练数据闭环（Training Data）

这是 Hermes Agent 最具野心的一层——它积累的经验和技能，可以反过来用于训练更好的模型。

3.3.1 数据收集的格式

Hermes Agent 会将高质量的「任务-技能-结果」三元组，以标准格式存储：

{
  "task_id": "task_20260608_001",
  "task_description": "修复 Python 项目的导入错误",
  "solution_skill": "fix_python_import_error",
  "execution_trace": [
    {"tool": "read_file", "args": {"path": "main.py"}},
    {"tool": "exec", "args": {"cmd": "python main.py"}},
    {"tool": "edit_file", "args": {"path": "requirements.txt", "content": "...\nrequests"}}
  ],
  "outcome": "success",
  "skill_improved": true,
  "training_ready": true
}

3.3.2 与 Nous Research 模型训练的关联

Nous Research 计划（根据 GitHub Discussions）将这些数据用于：

1. 微调 Hermes 系列模型：让模型本身就具备更强的 Agent 能力
2. 训练技能生成模型：自动从任务描述生成高质量 Skill 文件
3. 构建 Agent 评估基准：基于真实使用场景的评估数据集

工程师视角：这一层目前还处于早期阶段，但对于关心数据主权的用户，Hermes Agent 支持完全本地运行，训练数据不会自动上传。

4. 核心子系统逐项拆解

4.1 FTS5 全文检索引擎

为什么选 FTS5 而不是向量数据库？

Hermes Agent 的架构文档中解释了这一设计决策：

1. 延迟：FTS5 的关键词查询延迟 < 1ms；向量检索（即使量化后）通常需要 10-50ms
2. 资源消耗：FTS5 是 SQLite 内置功能，零额外依赖；向量数据库需要独立的服务进程
3. 可解释性：关键词匹配的结果可以直接展示给用户；向量检索的相似度分数是黑盒
4. 覆盖场景：80% 的记忆召回场景是关键词驱动的（「我上次怎么配置 Nginx 的？」）

FTS5 的高级用法：BM25 排序 + 时间衰减

Hermes Agent 对 FTS5 的查询做了增强：

def memory_search(query, time_decay=True):
    # 基础 FTS5 查询
    base_query = """
    SELECT 
        rowid,
        content,
        timestamp,
        bm25(memory_fts) as relevance
    FROM memory_fts
    WHERE memory_fts MATCH ?
    """
    
    if time_decay:
        # 时间衰减因子：越近期的记忆排名越高
        time_decay_factor = """
        (1.0 / (1.0 + (julianday('now') - julianday(timestamp)) / 30.0))
        """
        base_query = base_query.replace(
            "ORDER BY relevance",
            f"ORDER BY relevance * {time_decay_factor}"
        )
    
    return execute_query(base_query, (query,))

4.2 Honcho 用户建模

Honcho 是 Nous Research 开发的一个辨证用户建模系统，集成在 Hermes Agent 中。

核心思想：用户建模不是静态的标签系统（「喜欢 Python」「用 Mac」），而是一个可动态更新的信念网络。

class UserModel:
    def __init__(self):
        self.beliefs = {}      # 对用户偏好的信念
        self.confidence = {}   # 每个信念的置信度
    
    def update(self, observation):
        """
        根据新的观察更新用户模型
        observation: {"type": "preference", "key": "editor", "value": "vim"}
        """
        key = observation["key"]
        
        if key not in self.beliefs:
            self.beliefs[key] = observation["value"]
            self.confidence[key] = 0.5
        else:
            # 贝叶斯更新
            prior = self.confidence[key]
            likelihood = 0.8  # 观察的可靠性
            self.confidence[key] = (prior * likelihood) / (
                prior * likelihood + (1 - prior) * (1 - likelihood)
            )
            
            if self.confidence[key] > 0.7:
                # 置信度足够高，更新信念
                self.beliefs[key] = observation["value"]

4.3 Cron 定时调度器

Hermes Agent 内置了一个基于 APScheduler 的定时任务系统，支持自然语言定义。

自然语言转 Cron 表达式

from apscheduler.triggers.cron import CronTrigger

def parse_natural_language_schedule(text):
    """
    将自然语言转为 Cron 表达式
    示例：
    - "每天早上 9 点" → "0 9 * * *"
    - "每周一、三、五的下午 3 点" → "0 15 * * 1,3,5"
    - "每 2 小时一次" → "0 */2 * * *"
    """
    prompt = f"""
    Convert the following natural language schedule to a standard cron expression:
    
    Input: {text}
    
    Output only the cron expression in the format:
    minute hour day month day_of_week
    """
    
    cron_expr = llm.complete(prompt).strip()
    return CronTrigger.from_crontab(cron_expr)

定时任务的执行环境

# 定义一个定时任务
@hermes.cron("0 9 * * *")  # 每天早上 9 点
def daily_standup_reminder():
    """
    定时任务：每天提醒用户站会
    """
    user_schedule = read_memory("user_schedule")
    
    if "standup" in user_schedule:
        time = user_schedule["standup"]["time"]
        attendees = user_schedule["standup"]["attendees"]
        
        message = f"⏰ 站会提醒：今天 {time}，参会人：{', '.join(attendees)}"
        send_notification(message)

4.4 多平台消息网关

Hermes Agent 的消息网关支持 6 大即时通信平台，架构上采用适配器模式：

class MessageGateway:
    """
    统一消息网关，将不同平台的消息转换为标准格式
    """
    def __init__(self):
        self.adapters = {
            "telegram": TelegramAdapter(),
            "discord": DiscordAdapter(),
            "slack": SlackAdapter(),
            "whatsapp": WhatsAppAdapter(),
            "signal": SignalAdapter(),
            "cli": CLIAdapter()
        }
    
    def handle_incoming(self, platform, raw_message):
        """
        将各平台的原始消息转换为标准格式
        """
        adapter = self.adapters[platform]
        standard_message = adapter.to_standard(raw_message)
        
        # 路由到 Agent 核心处理
        response = agent.process(standard_message)
        
        # 将响应转换回平台格式并发送
        platform_response = adapter.from_standard(response)
        adapter.send(platform_response)

各平台适配器的关键差异

5. 从零部署：本地、Docker、VPS 三种路径

5.1 本地部署（macOS / Linux）

一键安装脚本

# 官方一键安装脚本
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# 安装完成后重新加载 shell 配置
source ~/.zshrc   # 如果用 bash，则 source ~/.bashrc

手动配置

# 1. 初始化配置
hermes setup

# 2. 选择模型提供商（以 DeepSeek 为例）
# - 选择 "DeepSeek"
# - 输入 API Key
# - Base URL 填写：https://api.deepseek.com
# - 选择模型：deepseek-v4-pro

# 3. 启动 Hermes Agent
hermes

配置文件详解

安装完成后，配置文件位于 ~/.hermes/config.toml：

[llm]
provider = "deepseek"           # 模型提供商
model = "deepseek-v4-pro"      # 模型名称
base_url = "https://api.deepseek.com"  # API 端点
api_key_env = "DEEPSEEK_API_KEY"       # API Key 环境变量名

[memory]
db_path = "~/.hermes/hermes.db"        # SQLite 数据库路径
max_history_turns = 50                 # 每次会话加载的最大历史轮数
importance_threshold = 0.6             # 记忆重要性阈值

[skills]
auto_create = true                      # 是否自动创建技能
auto_improve = true                    # 是否自动改进技能
min_tool_calls = 5                     # 触发技能创建的最小工具调用次数

[cron]
enabled = true                         # 是否启用定时任务
check_interval = 60                   # 检查间隔（秒）

[gateways]
telegram_enabled = false
discord_enabled = false
slack_enabled = false

5.2 Docker 部署

对于需要在服务器上长期运行 Hermes Agent 的场景，Docker 是最干净的方式。

Dockerfile（官方提供）

FROM python:3.12-slim

WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    git \
    curl \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# 复制并安装 Python 依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制 Hermes Agent 源码
COPY . .

# 创建非 root 用户
RUN useradd -m -u 1000 hermes && \
    chown -R hermes:hermes /app
USER hermes

# 暴露端口（用于 Web 界面）
EXPOSE 8080

CMD ["python", "-m", "hermes_agent.main"]

Docker Compose 配置

version: '3.8'

services:
  hermes-agent:
    build: .
    container_name: hermes-agent
    volumes:
      - ./data:/app/data          # 持久化数据（数据库、技能、配置）
      - ./logs:/app/logs          # 日志文件
    environment:
      - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}
      - HERMES_LOG_LEVEL=INFO
    restart: unless-stopped
    ports:
      - "8080:8080"              # Web 界面

启动命令

# 1. 设置 API Key
export DEEPSEEK_API_KEY="sk-xxx"

# 2. 启动容器
docker-compose up -d

# 3. 查看日志
docker-compose logs -f

# 4. 进入容器执行 CLI
docker-compose exec hermes-agent hermes

5.3 VPS 部署（$5/月的最低配置）

Hermes Agent 的官方文档声称可以在 $5/月的 VPS 上运行，这是经过验证的。

推荐的最低配置

• CPU：1 vCPU（够用，Agent 大部分时间等待 LLM 响应）
• 内存：1GB（基础运行），2GB（启用浏览器自动化时需要）
• 存储：20GB（足够存储数月的会话历史和技能）
• 操作系统：Ubuntu 22.04 LTS / Debian 12

部署步骤

# 1. SSH 登录 VPS
ssh root@your-vps-ip

# 2. 安装依赖
apt update && apt install -y python3.12 python3-pip git curl

# 3. 安装 Hermes Agent
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# 4. 配置为 Systemd 服务（后台常驻运行）
sudo tee /etc/systemd/system/hermes-agent.service > /dev/null <<EOL
[Unit]
Description=Hermes Agent Service
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/root/.hermes
ExecStart=/root/.local/bin/hermes
Restart=always
RestartSec=10
Environment="DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY}"

[Install]
WantedBy=multi-user.target
EOL

# 5. 启动服务
sudo systemctl daemon-reload
sudo systemctl enable hermes-agent
sudo systemctl start hermes-agent

# 6. 检查状态
sudo systemctl status hermes-agent

6. 代码实战：手搓一个自定义 Skill

理论讲了一堆，现在动手写一个真实的 Skill。

场景：自动清理 Docker 镜像和容器

这是每个开发者的日常痛点——Docker 用久了，镜像和容器越积越多，占用大量磁盘空间。

Step 1：让 Hermes Agent 帮你完成一次清理

先不写 Skill，直接让 Agent 帮你做一次：

你：帮我清理一下 Docker 系统，删除所有停止的容器、未使用的镜像和 volume。

Agent 会执行类似这样的命令：

# 删除所有停止的容器
docker container prune -f

# 删除所有未使用的镜像
docker image prune -a -f

# 删除未使用的 volume
docker volume prune -f

# 删除未使用的网络
docker network prune -f

Step 2：让 Agent 把这次经验写成 Skill

在任务完成后，告诉 Agent：

你：把刚才的 Docker 清理流程写成一个 Skill，下次直接复用。

Agent 会生成一个 Skill 文件，类似：

---
name: docker_system_prune
description: 清理 Docker 系统（容器、镜像、volume、网络）
trigger:
  - "清理 Docker"
  - "docker clean"
  - "docker prune"
success_criteria:
  - "磁盘空间释放"
  - "只删除未使用的资源"
dependencies:
  - docker
---

# Docker 系统清理

## 完整清理命令

```bash
# 一键清理所有未使用资源（推荐）
docker system prune -a --volumes -f

# 分步骤清理（更可控）
docker container prune -f   # 停止的容器
docker image prune -a -f    # 未使用的镜像
docker volume prune -f      # 未使用的 volume
docker network prune -f     # 未使用的网络

注意事项

1. docker system prune -a 会删除所有未使用的镜像，包括有 tag 但没有运行的镜像。
2. 加上 --volumes 会删除未挂载的 volume，数据不可恢复。
3. 建议先执行 docker system df 查看资源占用情况，再决定是否清理。

验证清理效果

# 清理前
docker system df

# 清理后
docker system df

对比两次输出，确认空间已释放。

#### Step 3：下次直接触发 Skill

现在，当你再说「帮我清理 Docker」时，Agent 会**直接加载这个 Skill**，而不是重新推理整个流程。

---

### 进阶：写一个更复杂的 Skill（带参数处理）

假设你需要一个 Skill，可以**按指定天数清理日志文件**：

```markdown
---
name: clean_old_logs
description: 删除指定目录中超过 N 天的日志文件
trigger:
  - "清理日志"
  - "删除旧日志"
  - "clean logs older than"
parameters:
  - name: "directory"
    description: "日志文件所在目录"
    required: true
  - name: "days"
    description: "保留最近 N 天的日志"
    required: true
    default: 7
---

# 清理旧日志文件

## 使用方法

```bash
# 删除 /var/log 下超过 7 天的所有 .log 文件
find /var/log -name "*.log" -type f -mtime +7 -delete

# 删除前先预览（推荐）
find /var/log -name "*.log" -type f -mtime +7 -ls

封装为脚本

将以下脚本保存为 /usr/local/bin/clean_old_logs.sh：

#!/bin/bash
DIR=${1:-/var/log}
DAYS=${2:-7}

echo "Preview: files in $DIR older than $DAYS days:"
find "$DIR" -name "*.log" -type f -mtime +$DAYS -ls

read -p "Proceed with deletion? (y/N) " confirm
if [ "$confirm" = "y" ]; then
    find "$DIR" -name "*.log" -type f -mtime +$DAYS -delete
    echo "Done."
else
    echo "Cancelled."
fi

定时执行（每周日凌晨 2 点）

# 添加到 crontab
0 2 * * 0 /usr/local/bin/clean_old_logs.sh /var/log 7

---

## 7. 与生产级 Agent 框架的横向对比

### 7.1 Hermes Agent vs OpenClaw

| 维度 | Hermes Agent | OpenClaw |
|------|-------------|----------|
| 记忆系统 | SQLite + FTS5，跨会话持久化 | 无持久化记忆（每次新会话需重新填充上下文） |
| 技能系统 | 自动从经验创建和改进 | 依赖用户手动编写 SKILL.md |
| 部署形态 | CLI + 多平台网关 + Docker | 桌面应用 + CLI |
| 自进化能力 | 有三层自进化闭环 | 无 |
| 适用场景 | 长期个人助手，持续积累 | 即时任务执行，不依赖历史 |

**结论**：如果你需要一个**越用越懂你**的 Agent，选 Hermes Agent。如果你需要一个**干净利落的即时执行工具**，选 OpenClaw。

---

### 7.2 Hermes Agent vs Superpowers

Superpowers 是一套**方法论**，Hermes Agent 是一个**运行时**。两者可以结合使用。

- **Superpowers** 提供结构化的工作流（先设计再写代码、TDD、子代理并行）
- **Hermes Agent** 提供持久化记忆和技能系统，让 Superpowers 的方法论可以跨会话复用

**最佳实践**：在 Hermes Agent 中安装 Superpowers 的 Skill，让 Agent 既懂得**怎么干活**，又记得**你上次是怎么干的**。

---

### 7.3 Hermes Agent vs nanobot

nanobot 是一个轻量级的 Agent 框架，功能有限。

| 维度 | Hermes Agent | nanobot |
|------|-------------|---------|
| 功能完整性 | 完整（记忆、技能、定时任务、多平台） | 基础（主要是工具调用） |
| 资源消耗 | 较高（需要 SQLite、后台进程） | 极低（单文件脚本） |
| 适用场景 | 生产级长期使用 | 快速原型、轻量任务 |

---

## 8. 性能优化：让 Agent 跑得更快更稳

### 8.1 降低 LLM 调用延迟

Hermes Agent 的性能瓶颈主要在 LLM 调用。以下是优化方案：

#### 方案 1：使用更快的模型

```toml
# 在 config.toml 中配置
[llm]
provider = "deepseek"
model = "deepseek-v4-lite"    # 更快的模型，牺牲一点质量

方案 2：启用本地模型（Ollama）

# 1. 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 2. 拉取模型
ollama pull hermes3:8b        # Nous Research 的 Hermes 3 模型

# 3. 配置 Hermes Agent 使用 Ollama
# 在 config.toml 中：
[llm]
provider = "ollama"
model = "hermes3:8b"
base_url = "http://localhost:11434"

延迟对比：

8.2 优化记忆检索

问题：记忆太多，检索变慢

当 SQLite 数据库增长到数万条记录时，FTS5 的查询速度会下降。

解决方案：分区 + 归档

def archive_old_memories():
    """
    将 90 天前的记忆归档到归档表，主表只保留近期记忆
    """
    conn = sqlite3.connect(get_db_path())
    
    # 创建归档表（如果不存在）
    conn.execute("""
    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts_archive 
    USING fts5(content, context, timestamp UNINDEXED)
    """)
    
    # 将 90 天前的记忆移到归档表
    conn.execute("""
    INSERT INTO memory_fts_archive 
    SELECT content, context, timestamp 
    FROM memory_fts 
    WHERE julianday('now') - julianday(timestamp) > 90
    """)
    
    # 从主表中删除已归档的记忆
    conn.execute("""
    DELETE FROM memory_fts 
    WHERE julianday('now') - julianday(timestamp) > 90
    """)
    
    conn.commit()

8.3 减少不必要的工具调用

Hermes Agent 有时会因为过度主动而调用不必要的工具。

优化：配置工具调用策略

[tools]
# 禁用不需要的工具（减少决策开销）
file_search_enabled = true
terminal_enabled = true
web_search_enabled = false      # 除非需要，否则禁用联网搜索
browser_automation_enabled = false  # 除非需要，否则禁用浏览器自动化

# 工具调用前的确认策略
confirm_before = ["terminal.write", "terminal.exec_sudo"]

9. 真实场景案例：我用 Hermes Agent 做了什么

案例 1：自动化技术文章发布流水线

我在使用 Hermes Agent 之前，每次发布文章到 chenxutan.com 都需要：

1. 手动撰写 Markdown 文章
2. 登录后台发布
3. 检查是否重复

使用 Hermes Agent 后，我创建了一个定时任务：

# 在 Hermes Agent 中设置定时任务
你：每天早上 9 点，自动搜索最新的技术热点，撰写一篇深度文章，发布到 chenxutan.com

Agent 会自动：

1. 使用在线搜索技能找到最新技术热点
2. 撰写 5000-20000 字的深度文章
3. 调用 chenxutan-article-publish 的 API 发布
4. 将发布记录写入记忆，避免重复发布

效果：过去 2 周，自动发布了 15 篇原创技术文章，其中 3 篇阅读量超过 500。

案例 2：长期项目的上下文管理

我在做一个全栈 SaaS 项目，前后跨越 3 个月。

没有 Hermes Agent 之前：每次继续开发，我需要花 20 分钟重新给 AI 介绍项目背景。

有了 Hermes Agent 之后：

1. Agent 自动记录了每次会话的关键决策（技术选型、API 设计、数据库 schema）
2. 当下次会话开始时，Agent 自动加载相关记忆
3. 我只需要说「继续做昨天的用户认证模块」，Agent 就知道上下文

代码片段：Agent 自动生成的 MEMORY.md 节选：

# 项目记忆：SaaS 全栈项目

## 技术栈
- 前端：Next.js 15 + TypeScript + Tailwind CSS
- 后端：Hono + Bun + Drizzle ORM
- 数据库：PostgreSQL（Neon）
- 认证：Clerk
- 部署：Vercel（前端）+ Fly.io（后端）

## 关键决策
- 2026-03-15：决定用 Hono 而不是 Express，因为 Bun 原生支持
- 2026-03-20：数据库从 Prisma 迁移到 Drizzle，类型推导更友好
- 2026-04-01：认证方案从 NextAuth.js 换成 Clerk，减少维护成本

## 当前进行中
- 用户认证模块（进行中，完成度 60%）
- 昨天实现了登录页面和 Clerk 集成
- 今天需要做：保护 API 路由、添加用户 profile 页面

10. 局限性与未来路线图

10.1 当前局限性

1. 技能质量依赖 LLM 能力：自动生成的 Skill 有时不够精确，需要人工审核
2. 记忆系统的误召回：FTS5 关键词匹配有时会召回不相关的记忆
3. 多平台消息同步：不同平台的对话历史是分开存储的，没有统一视图
4. 资源消耗：长期运行后，SQLite 数据库可能增长到数百 MB

10.2 未来路线图（根据 GitHub Project 和 Discussions）

1. v0.15.0（预计 2026 年 7 月）：

   • 向量检索作为 FTS5 的 fallback
   • 技能市场（社区共享技能）
   • 多平台对话历史统一视图

2. v1.0.0（预计 2026 年 12 月）：

   • 稳定的 API
   • 官方技能认证体系
   • 与 Nous Research 的 Hermes 4 模型深度集成

11. 总结：自进化 Agent 的工程师视角

Hermes Agent 不是完美的，但它解决了一个真实的问题：如何让 AI 助手在长期使用中持续积累能力，而不是每次都从零开始。

核心价值

1. 记忆系统：让 Agent 记住你，而不是你每次都要重新介绍自己
2. 技能系统：让 Agent 从经验中学习，而不是每次都重新推理
3. 自进化闭环：让 Agent 越用越强，而不是止步不前

适合谁用？

• ✅ 长期个人项目开发者：需要 AI 持续跟踪项目上下文
• ✅ 技术博客作者：需要 AI 自动追踪技术热点并生成内容
• ✅ 运维工程师：需要 AI 自动处理重复性的系统维护任务
• ❌ 偶尔用 AI 的 casual user：收益不明显，直接用 Claude/ChatGPT 更简单

工程师的建议

1. 从小规模开始：先在本地方便地使用，观察技能系统是否对你的工作流有帮助
2. 定期审查自动生成的 Skill：LLM 生成的技能不一定完美，需要人工审核
3. 关注数据库大小：定期归档旧记忆，避免 SQLite 数据库无限增长
4. 结合其他工具：Hermes Agent 不是万能的，和 Superpowers、OpenClaw 等工具结合使用效果更好

参考资源

• GitHub 仓库：https://github.com/NousResearch/hermes-agent
• 官方文档：https://hermes-agent.ai/docs
• Discord 社区：https://discord.gg/nousresearch
• 技能市场（WIP）：https://github.com/NousResearch/hermes-agent/discussions

本文写于 2026 年 6 月，基于 Hermes Agent v0.14.0。如有技术细节更新，请以官方文档为准。

如果你觉得这篇文章有帮助，欢迎关注 程序员茄子 获取更多深度技术文章。