Hermes Agent 深度实战：从自学习 Skill 到三层记忆——15 万 Star 的自进化 AI Agent 架构完全指南（2026）

两个月 15 万 Star，207 位贡献者，MIT 开源——Hermes Agent 不是又一个 LLM 套壳，而是一个精密编排的 Agent 运行时。本文从源码级架构拆解到生产级部署，带你彻底搞懂"会自我进化的 AI Agent"到底是怎么实现的。

一、为什么 Hermes Agent 值得你认真看一眼

如果你关注 AI Agent 领域，最近三个月一定被 Hermes Agent 刷过屏。Nous Research 在 2026 年 2 月开源了这个项目，三个月后 Star 数突破 15 万，直接登顶 GitHub Trending 月度榜。

但 Star 数说明不了什么。真正值得你花时间的是它的设计理念：

传统 Agent：固定技能 → 执行任务 → 结束。每次对话从零开始，上一轮学到的经验全部丢失。

Hermes Agent：执行任务 → 自动创建技能 → 持续优化 → 知识积累 → 越用越聪明。

这不是噱头。Nous Research 的基准测试数据：拥有 20 个以上自创 Skill 的 Agent，完成研究任务的速度比零 Skill 的全新实例快了 40%。

更直白地说：Hermes Agent 不是 Copilot（依赖 IDE），不是 ChatGPT wrapper（API 套壳），也不是单轮对话助手。它是一个驻留在你服务器上的自主智能体——拥有持久记忆、自动生成技能、跨平台通信能力，并且运行时间越长越智能。

本文会从架构设计、核心机制、代码实战到生产优化，完整拆解 Hermes Agent 的技术实现。

二、整体架构：六层骨架

打开 Hermes Agent 的仓库，你会发现它的代码组织非常清晰。核心架构由六层组成：

┌─────────────────────────────────────────────┐
│  Layer 6: Curator 后台自学习器               │
│  (Skill 创建/优化/RL 训练飞轮)              │
├─────────────────────────────────────────────┤
│  Layer 5: 记忆与压缩管线                     │
│  (MEMORY.md / USER.md / SQLite FTS5)        │
├─────────────────────────────────────────────┤
│  Layer 4: 插件扩展系统                       │
│  (MCP 服务器 / 自定义工具 / Skills)          │
├─────────────────────────────────────────────┤
│  Layer 3: 工具注册中心                       │
│  (tools/registry.py → toolsets.py)          │
├─────────────────────────────────────────────┤
│  Layer 2: AI Agent 同步推理循环              │
│  (run_conversation → 工具调用 → 结果回喂)    │
├─────────────────────────────────────────────┤
│  Layer 1: CLI/TUI 入口层                     │
│  (hermes chat / hermes-agent API / ACP)     │
└─────────────────────────────────────────────┘

核心代码集中在两个文件：

• run_agent.py：AIAgent 类，核心对话循环，约 12k LOC
• model_tools.py：工具发现与分发层

这种架构选择说明一件事：Hermes 首先是一个会复盘的执行体，其次才是一个可接入多平台的接口。

2.1 核心执行循环：经典的 ReAct 模式

Hermes 的核心循环用最经典的"模型生成 → 工具执行 → 结果回喂"做迭代，外面套上自学习的 Curator、跨会话 FTS5 记忆搜索和 7 种部署后端。

# run_agent.py 核心循环简化版
class AIAgent:
    def run_conversation(self, user_message: str) -> str:
        # 1. 注入记忆上下文（MEMORY.md + USER.md + 相关 Skill）
        system_prompt = self.prompt_builder.build(
            memory=self.memory.get_core_memory(),      # L1 核心记忆
            user_profile=self.memory.get_user_profile(), # L2 用户画像
            skills=self.skills.get_relevant_skills(user_message), # 匹配相关 Skill
        )
        
        # 2. ReAct 循环
        messages = [{"role": "system", "content": system_prompt}]
        messages.append({"role": "user", "content": user_message})
        
        while True:
            response = self.model.chat(messages)
            messages.append({"role": "assistant", "content": response.content})
            
            if not response.tool_calls:
                break  # 无工具调用，对话结束
            
            # 3. 执行工具调用
            for tool_call in response.tool_calls:
                result = self.registry.dispatch(tool_call)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
        
        # 4. 后台触发 Curator 审视
        self.curator.review_conversation(messages)
        
        return response.content

注意最后那行 self.curator.review_conversation(messages)——这就是 Hermes "自进化"的关键入口。每次对话结束后，Curator 会在后台审视这次对话，判断是否有值得沉淀的经验。

三、核心机制一：自学习 Skill 系统

这是 Hermes 最受关注也最被误解的能力。很多人以为"自动创建 Skill"是某种黑盒魔法，实际上它是一套前台执行与后台复盘的分离架构。

3.1 前台：系统提示中的经验引导

在 agent/prompt_builder.py 中，Hermes 向 LLM 注入了一段 SKILLS_GUIDANCE：

After completing a complex task (5+ tool calls), fixing a tricky bug, 
or discovering a non-obvious solution, consider creating a skill 
so you can reuse this approach in the future.

这不是强制规则，而是一个"建议"。LLM 在完成复杂任务后，会根据上下文自行判断是否值得创建 Skill。

3.2 后台：Curator 的 Review 机制

Curator 是 Hermes 的"复盘引擎"。它的工作流程：

对话结束 → Curator 审视全量消息 → 判断是否有可沉淀经验
  → 有：调用 skill_manage() 创建/更新 Skill
  → 无：跳过

一个 Skill 的本质是什么？一个 Markdown 文件。存储在 ~/.hermes/skills/ 目录下：

# Skill: Debug Python ImportError

## 触发条件
当用户报告 Python ImportError 且涉及包安装问题时激活

## 解决步骤
1. 检查虚拟环境是否激活：`which python`
2. 对比 pip list 与 requirements.txt：`pip list | grep <package>`
3. 如环境正确但仍报错，检查 sys.path：`python -c "import sys; print(sys.path)"`
4. 常见根因：conda 与 venv 冲突 → `conda deactivate && source venv/bin/activate`

## 注意事项
- macOS 上 Homebrew Python 可能干扰
- __init__.py 缺失也会导致 ImportError

关键洞察：Hermes 的"进化"，准确来说是文件层面的经验写回。它学到了什么，你能打开文件直接看；它写到了哪里，你能精确定位。这比"模型自我学习"听起来不够高级，但好处很实在——它可控。

3.3 Skill 的生命周期

# tools/skill_manage.py 简化逻辑
class SkillManager:
    def create_skill(self, name: str, content: str, trigger: str):
        """创建新 Skill"""
        skill_path = SKILLS_DIR / f"{name}.md"
        if skill_path.exists():
            return self.update_skill(name, content)  # 已存在则更新
        
        skill = SkillTemplate(
            name=name,
            trigger=trigger,
            content=content,
            created_at=datetime.now(),
            usage_count=0,
            success_rate=0.0,
        )
        skill_path.write_text(skill.to_markdown())
    
    def update_skill(self, name: str, new_content: str):
        """更新已有 Skill — 增量合并而非覆盖"""
        existing = self.load_skill(name)
        merged = self.merge_skill_content(existing.content, new_content)
        existing.content = merged
        existing.updated_at = datetime.now()
        existing.version += 1
        skill_path.write_text(existing.to_markdown())
    
    def get_relevant_skills(self, query: str) -> list[Skill]:
        """FTS5 全文检索匹配相关 Skill"""
        results = self.fts5_search(query)
        return [r for r in results if r.success_rate > 0.5][:5]

注意 update_skill 是增量合并而非覆盖——这意味着 Skill 会随着使用越来越精确，而不是被新经验粗暴替换。

3.4 效果数据

Nous Research 的内部基准测试：

数据很直白：Skill 越多，Agent 越快，越准，越省 token。

四、核心机制二：三层记忆架构

大多数 AI Agent 像金鱼——聊完就忘。Hermes 借鉴 CPU 缓存的设计思想，打造了分层记忆系统：

┌──────────────────────────────────────────────┐
│  L1: 核心记忆 (MEMORY.md)                     │
│  容量：≤800 tokens，启动时冻结为快照注入提示词   │
│  内容：关键上下文、项目状态、重要决策           │
├──────────────────────────────────────────────┤
│  L2: 用户画像 (USER.md)                       │
│  容量：~500 tokens                            │
│  内容：技术栈偏好、沟通风格、工作习惯           │
├──────────────────────────────────────────────┤
│  L3: 会话记忆 (SQLite + FTS5)                 │
│  容量：无上限，全量存储                         │
│  检索：FTS5 全文索引，毫秒级搜索               │
│  工具：session_search 按需查询                 │
└──────────────────────────────────────────────┘

4.1 L1 核心记忆：精确控制上下文窗口

# memory/core_memory.py
class CoreMemory:
    MAX_TOKENS = 800
    
    def __init__(self, path: Path = Path("~/.hermes/MEMORY.md")):
        self.path = path.expanduser()
        self._snapshot = None
    
    def get_snapshot(self) -> str:
        """启动时冻结快照，确保会话内一致性"""
        if self._snapshot is None:
            content = self.path.read_text() if self.path.exists() else ""
            token_count = self._count_tokens(content)
            if token_count > self.MAX_TOKENS:
                content = self._compress(content)
            self._snapshot = content
        return self._snapshot
    
    def update(self, new_facts: list[str]):
        """Curator 在对话结束后更新核心记忆"""
        current = self.path.read_text() if self.path.exists() else ""
        merged = self._merge_facts(current, new_facts)
        
        # 超出容量时，用 LLM 做摘要压缩
        if self._count_tokens(merged) > self.MAX_TOKENS:
            merged = self._summarize(merged)
        
        self.path.write_text(merged)
        self._snapshot = None  # 下次获取时重新冻结

为什么是 800 tokens？因为 Hermes 的系统提示词本身已经很长了（包含工具描述、Skill 列表、安全规则等），核心记忆不能占用太多窗口。800 tokens 大约是 400 个汉字或 600 个英文单词，刚好够放最关键的上下文。

4.2 L2 用户画像：越聊越懂你

# memory/user_profile.py
class UserProfile:
    MAX_TOKENS = 500
    
    def update_from_conversation(self, messages: list[dict]):
        """从对话中提取用户特征"""
        extraction_prompt = """
        Analyze the conversation and extract user characteristics:
        - Preferred programming languages
        - Communication style (concise vs detailed)
        - Common project types
        - Time zone indicators
        - Tool preferences
        
        Return as structured JSON.
        """
        characteristics = self.model.extract(messages, extraction_prompt)
        self._merge_characteristics(characteristics)

这个画像不是静态的。每次对话结束后，Curator 会重新审视并更新用户画像。你告诉过 Hermes 一次"我是后端工程师，主要用 Python"，它就再也不会给你推荐前端框架。

4.3 L3 会话记忆：全量存储 + FTS5 按需检索

# memory/session_store.py
class SessionStore:
    def __init__(self, db_path: Path = Path("~/.hermes/sessions.db")):
        self.conn = sqlite3.connect(str(db_path.expanduser()))
        self.conn.execute("PRAGMA journal_mode=WAL")  # WAL 模式，并发安全
        self._init_fts5()
    
    def _init_fts5(self):
        self.conn.executescript("""
            CREATE TABLE IF NOT EXISTS messages (
                id INTEGER PRIMARY KEY,
                session_id TEXT,
                role TEXT,
                content TEXT,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
            );
            CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
                content, 
                content='messages', 
                content_rowid='id',
                tokenize='unicode61'  -- 支持中文分词
            );
            CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
                INSERT INTO messages_fts(rowid, content) VALUES (new.id, new.content);
            END;
        """)
    
    def search(self, query: str, limit: int = 10) -> list[dict]:
        """FTS5 全文搜索，毫秒级"""
        cursor = self.conn.execute("""
            SELECT m.*, rank 
            FROM messages_fts f 
            JOIN messages m ON m.id = f.rowid 
            WHERE messages_fts MATCH ?
            ORDER BY rank 
            LIMIT ?
        """, (query, limit))
        return [dict(row) for row in cursor.fetchall()]

关键设计决策：L3 记忆不会主动加载到上下文窗口。只有在需要时，Agent 才会调用 session_search 工具进行针对性查询。这避免了长对话导致的上下文膨胀问题。

五、核心机制三：全平台消息网关 + 安全设计

5.1 Gateway 守护进程

Hermes 的消息网关是一个独立守护进程，负责：

• 统一接入 Telegram、Discord、Slack、WhatsApp、Signal、微信、飞书
• 管理 Cron 定时任务（每 60s 检查一次）
• 处理消息路由和并发控制

# 启动网关
hermes gateway start

# 状态检查
hermes gateway status

# 配置平台接入
hermes setup --platform telegram
hermes setup --platform discord

网关的配置存储在 ~/.hermes/gateway.yaml：

gateway:
  port: 8765
  platforms:
    telegram:
      enabled: true
      bot_token: ${TELEGRAM_BOT_TOKEN}
    discord:
      enabled: true
      bot_token: ${DISCORD_BOT_TOKEN}
    slack:
      enabled: false
  cron:
    check_interval: 60  # 秒
    jobs_dir: ~/.hermes/cron

5.2 安全五层防线

Hermes 的安全设计不是事后加的，而是架构层面的一等公民：

Layer 1: 命令白名单 — 只允许预定义的终端命令
Layer 2: 路径沙箱 — 文件操作限制在白名单目录内
Layer 3: 人工审批 — 危险操作（rm、sudo 等）需用户确认
Layer 4: 审计日志 — 所有操作记录到 ~/.hermes/audit.log
Layer 5: 权限分离 — 网关进程与 Agent 进程使用不同权限

# security/sandbox.py 简化
class CommandSandbox:
    ALLOWED_COMMANDS = {
        "git", "python", "pip", "node", "npm", "cat", "ls", "grep",
        "find", "curl", "docker", "kubectl", "rg",  # ripgrep
    }
    BLOCKED_PATTERNS = [
        r"rm\s+-rf\s+/", r"sudo\s+", r"chmod\s+777",
        r">\s*/dev/sd", r"dd\s+if=",
    ]
    
    def validate(self, command: str) -> tuple[bool, str]:
        # 检查白名单
        base_cmd = command.split()[0]
        if base_cmd not in self.ALLOWED_COMMANDS:
            return False, f"Command '{base_cmd}' not in allowlist"
        
        # 检查危险模式
        import re
        for pattern in self.BLOCKED_PATTERNS:
            if re.search(pattern, command):
                return "NEEDS_APPROVAL", f"Command matches dangerous pattern: {pattern}"
        
        return True, "Approved"

六、Cron 定时任务：让 Agent 自主管理时间

Hermes 的 Cron 系统是其"自主性"的关键体现。支持三种创建方式：

6.1 自然语言创建

最直观的方式，直接跟 Hermes 说话：

你：每天早上 8 点检查一下邮箱中最新的邮件，筛选出有价值的邮件，汇总结果发送到我的飞书

Hermes：✅ 已创建定时任务
  任务名称：每日邮件摘要
  执行频率：每天 08:00
  下次执行：2026-05-25 08:00:00
  任务 ID：cron_mail_digest_001
  推送平台：飞书

6.2 CLI 命令行创建

# 创建 cron 任务
hermes cron create "0 9 * * 1" "生成每周 AI 新闻摘要" --deliver telegram

# 查看所有任务
hermes cron list

# 暂停/恢复
hermes cron pause cron_mail_digest_001
hermes cron resume cron_mail_digest_001

# 删除
hermes cron delete cron_mail_digest_001

6.3 JSON 配置文件

// ~/.hermes/cron/jobs.json
[
  {
    "id": "cron_mail_digest_001",
    "name": "每日邮件摘要",
    "schedule": "0 8 * * *",
    "prompt": "检查邮箱中最新的邮件，筛选出有价值的邮件，汇总结果",
    "deliver": ["feishu"],
    "enabled": true,
    "last_run": "2026-05-24T08:00:00",
    "next_run": "2026-05-25T08:00:00"
  },
  {
    "id": "cron_code_review_001",
    "name": "每日代码审查",
    "schedule": "0 18 * * 1-5",
    "prompt": "检查今天提交的代码，找出潜在的 bug 和改进点",
    "deliver": ["telegram", "slack"],
    "enabled": true
  }
]

Cron 的执行由 Gateway 守护进程处理，每 60s 触发一次检查。即使你关闭了 CLI 终端，只要 Gateway 在跑，定时任务就不会中断。

七、MCP 集成：连接外部工具生态

Hermes 原生支持 MCP（Model Context Protocol），可以连接任何 MCP 服务器来扩展工具集。

7.1 配置 MCP 服务器

// ~/.hermes/mcp_config.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"],
      "env": {}
    }
  }
}

7.2 将 Hermes 自身暴露为 MCP 服务器

# 启动 MCP 服务器模式
hermes mcp serve --port 9000

# 从其他 Agent/IDE 连接
# 在 Claude Code / Cursor 等工具的 MCP 配置中添加：
# {
#   "hermes": {
#     "url": "http://localhost:9000/mcp"
#   }
# }

这意味着你可以把 Hermes 的能力（记忆、技能、工具）暴露给其他 AI Agent 使用，实现 Agent 间的能力共享。

八、代码实战：从零部署到生产优化

8.1 一键安装（3 分钟搞定）

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

# 刷新 shell 配置
source ~/.zshrc  # 或 source ~/.bashrc

# 初始化配置
hermes setup

安装脚本会自动完成：检测并安装缺失的依赖、克隆仓库及子模块、创建 Python 虚拟环境、安装所有 Python 包、配置全局 hermes 命令、引导配置 LLM Provider。

8.2 模型选择建议

Hermes 支持多种模型后端，通过 OpenRouter 一个 API Key 就能接入 600+ 模型：

# ~/.hermes/config.yaml
model:
  provider: openrouter  # 推荐：一个 Key 接入所有模型
  api_key: ${OPENROUTER_API_KEY}
  default: deepseek/deepseek-chat-v3  # 日常任务：性价比之王
  complex: anthropic/claude-sonnet-4  # 复杂推理：准确率优先
  fast: deepseek/deepseek-chat  # 简单问答：速度优先

成本参考（2026 年 5 月价格）：

8.3 Docker 生产部署

# Dockerfile
FROM python:3.12-slim

RUN apt-get update && apt-get install -y \
    git curl ripgrep ffmpeg sqlite3 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s \
  CMD curl -f http://localhost:8765/health || exit 1

# 启动 Gateway + Agent
CMD ["python", "-m", "hermes.gateway", "--host", "0.0.0.0", "--port", "8765"]

# docker-compose.yml
version: '3.8'
services:
  hermes:
    build: .
    ports:
      - "8765:8765"
    volumes:
      - hermes_data:/root/.hermes
      - ./projects:/root/projects
    environment:
      - OPENROUTER_API_KEY=${OPENROUTER_API_KEY}
      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 4G
        reservations:
          memory: 2G

volumes:
  hermes_data:

8.4 自定义 Skill 开发

除了让 Hermes 自动创建 Skill，你也可以手动编写：

<!-- ~/.hermes/skills/deploy-checklist.md -->
# Skill: 生产部署检查清单

## 触发条件
当用户提到"部署"、"上线"、"发版"时激活

## 检查步骤

### 1. 代码质量
- [ ] 运行 `pytest --cov` 覆盖率 ≥ 80%
- [ ] 运行 `ruff check .` 无 lint 错误
- [ ] 运行 `mypy .` 类型检查通过

### 2. 安全检查
- [ ] `pip audit` 无已知漏洞
- [ ] 无硬编码密钥（git diff 检查）
- [ ] CORS 配置正确

### 3. 性能基线
- [ ] API P99 延迟 < 200ms
- [ ] 内存使用 < 512MB
- [ ] 数据库慢查询 < 100ms

### 4. 基础设施
- [ ] Docker 镜像构建成功
- [ ] K8s manifest 配置正确
- [ ] 环境变量已更新
- [ ] 回滚方案已准备

## 输出格式
生成 Markdown 检查报告，标记通过/失败项

手动 Skill 和自动创建的 Skill 在机制上完全一样，都存在 ~/.hermes/skills/ 目录下，都会被 FTS5 索引。

8.5 多代理隔离

Hermes 支持多配置文件，可以运行多个隔离的实例：

# 工作代理
hermes --profile work chat
# 配置文件：~/.hermes/profiles/work/config.yaml

# 个人代理
hermes --profile personal chat
# 配置文件：~/.hermes/profiles/personal/config.yaml

# 项目专属代理
hermes --profile project-alpha chat
# 配置文件：~/.hermes/profiles/project-alpha/config.yaml

每个 Profile 有独立的记忆、Skill 和工具配置，互不干扰。

九、性能优化：生产环境的生存指南

9.1 SQLite WAL 模式

# 在 hermes_state.py 中确保 WAL 模式
conn = sqlite3.connect(db_path)
conn.execute("PRAGMA journal_mode=WAL")     # Write-Ahead Logging
conn.execute("PRAGMA synchronous=NORMAL")    # 平衡安全与性能
conn.execute("PRAGMA cache_size=-64000")     # 64MB 缓存
conn.execute("PRAGMA temp_store=MEMORY")     # 临时表在内存中

WAL 模式允许读写并发，避免长时间运行的 Agent 因 SQLite 锁而阻塞。

9.2 Prompt Prefix Cache 保护

# prompt_builder.py — 保护系统提示前缀不被截断
class PromptBuilder:
    def build(self, memory, user_profile, skills, max_tokens=8000):
        # 计算固定前缀长度
        prefix = self._build_prefix(memory, user_profile, skills)
        prefix_tokens = self._count_tokens(prefix)
        
        # 为对话历史预留空间
        history_budget = max_tokens - prefix_tokens - 1000  # 1000 for response
        
        if history_budget < 2000:
            # 前缀过长，需要压缩 Skill 列表
            skills = self._compress_skill_list(skills)
            prefix = self._build_prefix(memory, user_profile, skills)
        
        return prefix

9.3 并行任务控制

Hermes 的 Batch Runner 支持并行任务，但需要注意资源控制：

# batch_runner.py 配置
BATCH_CONFIG = {
    "max_concurrent_tasks": 3,      # 最大并发任务数
    "task_timeout_seconds": 300,     # 单任务超时
    "memory_limit_mb": 512,          # 单任务内存限制
    "rate_limit_per_minute": 20,     # API 调用频率限制
}

9.4 记忆压缩策略

长时间运行后，会话记忆会膨胀。Hermes 的压缩管线：

# memory/compressor.py
class MemoryCompressor:
    def compress_session(self, session_id: str):
        """将旧会话压缩为摘要"""
        messages = self.store.get_session(session_id)
        
        # 只保留最近 50 条消息的原文
        recent = messages[-50:]
        older = messages[:-50]
        
        # 旧消息压缩为摘要
        summary = self.model.summarize(older)
        
        # 存储摘要，释放原文空间
        self.store.save_summary(session_id, summary)
        self.store.delete_messages(session_id, [m.id for m in older])

十、与同类 Agent 的对比

核心差异：Hermes 的定位是"可运行的 Agent Operating Layer"，不是 LLM 应用。它更接近一个轻量级的 Agent 操作系统，而不是一个聊天工具。

十一、踩坑记录与最佳实践

11.1 常见坑

坑 1：Python 3.13 不兼容
某些依赖包还没适配 3.13，务必使用 3.10 ~ 3.12。

坑 2：macOS Homebrew Python 干扰
如果你用 Homebrew 安装了 Python，可能和 pyenv 冲突。建议使用 pyenv 管理版本：

pyenv install 3.12.3
pyenv global 3.12.3

坑 3：Skill 自动创建过于频繁
初期 Hermes 可能对"复杂任务"的判断过于宽松，导致创建大量低质量 Skill。可以在配置中调整阈值：

skills:
  min_tool_calls_for_creation: 8  # 默认 5，调高减少噪音
  review_before_create: true       # 创建前需用户确认

坑 4：FTS5 中文分词不精确
unicode61 分词器对中文支持有限，建议添加 jieba 分词：

-- 使用 jieba 分词器替代 unicode61
CREATE VIRTUAL TABLE messages_fts USING fts5(
    content, 
    content='messages',
    content_rowid='id',
    tokenize='jieba'
);

11.2 最佳实践

1. 前两周不要关闭 review_before_create：让 Hermes 自动创建 Skill，但你手动审核，筛选出真正有价值的
2. 定期清理 Skill：每月检查 ~/.hermes/skills/，删除不再适用或质量低的 Skill
3. 用 Profile 隔离工作和个人：避免工作项目的 Skill 污染个人对话
4. Gateway 常驻运行：即使不用 CLI，也保持 Gateway 运行，确保 Cron 任务正常执行
5. 定期备份 ~/.hermes/：这是 Hermes 所有记忆和 Skill 的存储位置

十二、总结与展望

Hermes Agent 的核心价值不在于"它能做什么"，而在于"它能学会做什么"。

传统的 Agent 是静态的——你给它什么能力，它就只有什么能力。Hermes 是动态的——它的能力随使用增长。这种"经验沉淀 → 技能固化 → 能力进化"的闭环，是 Agent 从工具走向伙伴的关键一步。

但它也有局限：

• Skill 质量依赖 LLM：自动创建的 Skill 质量参差不齐，需要人工审核
• 记忆压缩有损：旧对话压缩为摘要后可能丢失细节
• 多代理协调还在早期：虽然支持 Profile 隔离，但跨 Agent 协作还不成熟
• 本地部署门槛：虽然比大多数方案简单，但对非技术用户仍不友好

展望未来，Hermes 的 RL 训练飞轮（rl_cli.py）是最值得关注的模块。当前 Skill 创建依赖 LLM 的判断，未来可能通过强化学习自动优化 Skill 的创建策略——不是"LLM 觉得值得沉淀就沉淀"，而是"RL 证明沉淀了确实更快更准"。

如果你正在寻找一个能真正记住你、能陪你长期工作的 AI Agent，Hermes 值得一试。一行命令就能开始：

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

参考资料：

• NousResearch/hermes-agent GitHub 仓库
• Hermes Agent 原理与架构深度解析 - 博客园
• Hermes Agent 技术架构全解 - CSDN
• 从 Hermes Agent 到自学习 Skill 机制 - CSDN
• Hermes 三层记忆机制彻底拆解 - CSDN