Hermes Agent 深度解析：当 AI 学会自己写技能，Agent 的终局形态来了

两个月狂揽 7 万+ GitHub Stars，周均增速是同类项目的三倍，连续多日霸榜 GitHub Trending 全站第一——Hermes Agent 凭什么成为 2026 年最火的现象级 AI 项目？答案藏在一个看似简单却极具颠覆性的设计里：它是第一个真正实现「自我进化」的开源 Agent。

一、为什么 Hermes Agent 让整个 AI 圈疯狂

如果你关注 AI Agent 领域，一定注意到了一个有趣的现象：市面上绝大多数 Agent，本质上都是「无状态执行器」。

你让它写代码，它写完了。下次再让它写类似的代码，它又要从头开始——不记得你上次的需求，不知道你的编码风格，更不会从上次的错误中学习。就像一个永远只有 7 秒记忆的金鱼，每次对话都是全新的开始。

这带来了几个致命问题：

1. 效率低下：同样的错误会反复犯，同样的配置要反复说
2. 无法积累：做了 100 次任务，能力还是第 1 次的水平
3. 体验割裂：Agent 永远是「工具」，而不是「伙伴」

Hermes Agent 的出现，彻底打破了这种尴尬。它的核心差异化只有一句话，却足以改变整个 Agent 的游戏规则：

它是目前唯一一个内置自学习闭环的 Agent——能从经验中创建技能、在使用中自我改进、跨会话持续积累记忆。

这不是营销噱头。让我们深入技术细节，看看这个「自我进化」到底是怎么实现的。

二、核心机制：GAPA 与 Learning Loop

2.1 GAPA：不改模型的自我进化引擎

Hermes Agent 最核心的技术创新是 GAPA（Generalized Action and Prompt Adaptation，通用动作与提示自适应）。

这个名字听起来很学术，但原理其实很直观：

传统 Agent 工作流程：
用户输入 → LLM 推理 → 工具调用 → 输出结果 → 结束

Hermes Agent 工作流程：
用户输入 → LLM 推理 → 工具调用 → 输出结果 → 【GAPA 评估】→ 优化提示/动作 → 形成技能
                                                    ↓
                                              下次直接复用

具体来说，GAPA 的工作机制是这样的：

1. 记录所有工具调用：Hermes 在执行过程中，会记录每一次工具调用（调用模型生成文本、调用可视化工具绘图、写入知识库等）
2. 累计评估触发：当工具调用累计达到 15 次时，GAPA 会自动触发一次整体评估
3. 模式识别与优化：评估过程中，系统会识别成功的模式、失败的教训，并据此优化提示词和动作序列
4. 生成可复用技能：优化后的经验会被提取成结构化的 Skill 文件，存储在 ~/.hermes/skills/ 目录

关键点来了：这个过程完全不需要重新训练模型。Hermes 的「进化」发生在提示和动作层面，而非模型权重层面。这意味着：

• 不需要 GPU
• 不需要大规模数据
• 不需要漫长的训练时间
• 进化是即时的、渐进的、可逆的

2.2 Learning Loop 的三层闭环

GAPA 是底层引擎，而 Learning Loop（学习闭环）是 Hermes 的顶层设计哲学。这个闭环包含三个层次：

第一层：从任务到技能（自主创建）

当 Hermes 完成一个「复杂任务」（涉及 5 个以上工具调用）后，会自动从这次经验中提取模式，创建一个可复用的技能（Skill）。

触发条件包括：

• 完成了复杂任务（5+ 工具调用）
• 发现了「非平凡」的工作流
• 用户进行了纠正或错误恢复

生成的 Skill 文件遵循 Markdown 格式，包含：

• 任务描述
• 执行步骤
• 注意事项
• 踩过的坑
• 下次该怎么做

第二层：从技能到优化（自我修复）

创建出的技能不是一成不变的。Hermes 在后续调用技能时，会根据执行效果持续优化。

优化方式很聪明——不是全量重写，而是 patch 方式更新：

• 更安全：不会因为一次失败就推翻整个技能
• 更高效：Token 消耗更少
• 更可追溯：每次修改都有记录

第三层：从历史到知识（持久化记忆）

记忆系统采用 MEMORY.md + USER.md 双文件架构：

这些记忆会在每次会话开始时自动加载，真正实现「越用越懂你」。

三、四层记忆架构：模拟人类记忆的技术实现

如果说 Learning Loop 是 Hermes 的「大脑」，那么记忆系统就是它的「海马体」。

Hermes Agent 模拟人类记忆逻辑，设计了四层记忆体系：

3.1 架构总览

┌─────────────────────────────────────────────────────────┐
│                    第一层：常驻提示记忆                    │
│         MEMORY.md + USER.md (~3,575 字符上限)           │
│              每次会话自动加载，全局可用                    │
├─────────────────────────────────────────────────────────┤
│                    第二层：会话归档记忆                    │
│              SQLite + WAL + FTS5 全文索引               │
│              持久化所有历史交互数据                       │
├─────────────────────────────────────────────────────────┤
│                    第三层：语义搜索记忆                    │
│                 向量数据库 + 语义相似度匹配                │
│              支持跨会话召回相关历史                       │
├─────────────────────────────────────────────────────────┤
│                    第四层：技能库记忆                      │
│              ~/.hermes/skills/ 目录下的 SKILL.md        │
│              Agent 自己创建的能力模块                     │
└─────────────────────────────────────────────────────────┘

3.2 各层详解

第一层：常驻提示记忆

这是最轻量但最常用的记忆层。每次对话开始时，Hermes 会自动读取 MEMORY.md 和 USER.md，将其注入到系统提示中。

这个设计的巧妙之处在于：

• 容量可控：总字符数限制在 ~3,575，不会撑爆上下文窗口
• 优先级最高：常驻提示意味着「这些信息永远是最重要的」
• 用户可编辑：虽然是自动写入，但用户可以手动修改

典型内容示例：

# MEMORY.md
## 环境配置
- Python 版本: 3.11
- 默认编辑器: VS Code
- 项目路径: ~/projects/my-app

## 使用约定
- 代码风格: 黑色主题，4空格缩进
- 测试框架: pytest
- 部署方式: Docker Compose

## 技术发现
- 2026-04-15: 发现 requests 库在代理环境下有连接池问题，改用 httpx

第二层：会话归档记忆

这一层使用 SQLite + WAL（Write-Ahead Logging）+ FTS5（全文索引） 实现。

为什么选择这个技术栈？

存储的内容包括：

• 完整对话历史
• 工具调用记录
• 任务执行结果
• 用户反馈和纠正

第三层：语义搜索记忆

这是最「智能」的记忆层。Hermes 会将历史交互向量化存储，支持语义相似度匹配。

举个例子：

• 上次你说「帮我优化一下数据库查询」
• 这次你说「这个 SQL 跑得太慢了」

传统关键词匹配会认为这是两个无关的需求，但语义搜索能识别出它们的相似性，自动召回上次的相关经验。

第四层：技能库记忆

这是 Hermes 最独特的记忆形态。Skill 不是预置的，而是 Agent 在实际使用中自己「学」出来的。

技能文件的典型结构：

# SKILL: 数据库性能优化

## 触发条件
- 用户提到「慢查询」「优化」「SQL 性能」
- 涉及数据库相关任务

## 执行步骤
1. 获取 EXPLAIN ANALYZE 输出
2. 检查索引覆盖情况
3. 分析 JOIN 顺序
4. 查看 WHERE 条件选择性

## 注意事项
- 不要直接建议加索引，先检查数据分布
- 注意区分「查询慢」和「写入慢」
- 考虑是否是连接池问题

## 历史案例
- 2026-04-10: 某查询从 3s 优化到 50ms，原因是缺失复合索引
- 2026-04-12: 某写入操作慢，原因是事务隔离级别设置过高

3.3 记忆系统的技术实现

Hermes 的记忆系统核心代码位于 hermes_state.py：

# 简化版记忆管理示意
class HermesMemory:
    def __init__(self, base_path: str = "~/.hermes"):
        self.memory_file = Path(base_path) / "memories" / "MEMORY.md"
        self.user_file = Path(base_path) / "memories" / "USER.md"
        self.session_db = Path(base_path) / "sessions.db"
        self.skills_dir = Path(base_path) / "skills"
        
        # 初始化 SQLite + FTS5
        self._init_session_db()
        
    def _init_session_db(self):
        """初始化会话数据库，启用 WAL 模式和 FTS5"""
        conn = sqlite3.connect(self.session_db)
        conn.execute("PRAGMA journal_mode=WAL")
        conn.execute("""
            CREATE VIRTUAL TABLE IF NOT EXISTS sessions 
            USING fts5(
                timestamp, role, content, tool_calls,
                tokenize='porter unicode61'
            )
        """)
        conn.commit()
        
    def load_context(self) -> str:
        """加载常驻记忆到上下文"""
        memory_content = self.memory_file.read_text() if self.memory_file.exists() else ""
        user_content = self.user_file.read_text() if self.user_file.exists() else ""
        
        total_len = len(memory_content) + len(user_content)
        if total_len > 3575:
            # 超出上限时智能裁剪
            memory_content = self._smart_truncate(memory_content, user_content)
            
        return f"# Agent Memory\n{memory_content}\n\n# User Profile\n{user_content}"
        
    def search_history(self, query: str, limit: int = 10) -> List[dict]:
        """语义搜索历史记录"""
        # 1. FTS5 全文检索
        # 2. 向量相似度匹配
        # 3. 融合排序
        pass

四、Skill 系统：Agent 自己写代码的代码

Skill 系统是 Hermes 最具革命性的设计。让我们深入看看它是如何工作的。

4.1 Skill 创建流程

用户任务执行
     ↓
工具调用计数 ≥ 5 次？
     ↓ 是
GAPA 评估引擎启动
     ↓
提取任务模式
     ↓
识别成功路径和失败教训
     ↓
生成 SKILL.md 文件
     ↓
存储到 ~/.hermes/skills/
     ↓
下次类似任务自动加载

4.2 Skill 文件格式

Hermes 的 Skill 文件遵循一套开放标准，以 Markdown 格式存储：

---
skill_name: api_integration
version: 1.3
created: 2026-04-15
updated: 2026-04-18
trigger_keywords: [api, 接口, 集成, integration]
---

# API 集成技能

## 概述
帮助用户完成第三方 API 的集成工作，包括认证、请求、错误处理。

## 标准流程

### 1. 认证配置
- 检查是否已有 API Key 配置
- 确认认证方式（Bearer / API Key / OAuth）
- 处理敏感信息的存储

### 2. 请求封装
```python
import httpx

async def call_api(endpoint: str, params: dict) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.get(
            endpoint,
            params=params,
            headers={"Authorization": f"Bearer {API_KEY}"}
        )
        response.raise_for_status()
        return response.json()

3. 错误处理

注意事项

• 敏感信息不要硬编码，使用环境变量
• 注意 API 调用频率限制
• 处理好网络超时情况

演进历史

• v1.0: 初始创建
• v1.1: 增加重试机制
• v1.2: 修复 OAuth token 刷新问题
• v1.3: 增加异步支持

### 4.3 Skill 自动更新机制

Hermes 的 Skill 不是静态的，会在使用中持续进化。更新机制包括：

**Patch 模式更新**（推荐）：
```python
def update_skill_patch(skill_path: Path, update_content: str):
    """增量更新技能文件，而非全量重写"""
    existing = skill_path.read_text()
    
    # 智能合并：只更新变化的部分
    updated = merge_with_patch(existing, update_content)
    
    skill_path.write_text(updated)

全量更新（谨慎使用）：

def update_skill_full(skill_path: Path, new_content: str):
    """完全重写技能文件，慎用！"""
    # 备份旧版本
    backup_path = skill_path.with_suffix('.md.bak')
    shutil.copy(skill_path, backup_path)
    
    skill_path.write_text(new_content)

4.4 Skill 激活机制

Hermes 会在以下情况下自动激活相关 Skill：

1. 关键词匹配：用户输入包含 Skill 的触发关键词
2. 语义相似：当前任务与某个 Skill 的描述语义相似
3. 手动调用：用户明确要求使用某个 Skill

激活后的 Skill 会被注入到系统提示中：

def build_system_prompt(user_input: str, skills_dir: Path) -> str:
    """构建包含相关技能的系统提示"""
    
    # 1. 加载常驻记忆
    memory = load_memory()
    
    # 2. 检索相关技能
    relevant_skills = search_skills(user_input, skills_dir)
    
    # 3. 组装系统提示
    prompt = f"""
{memory}

# Available Skills
{format_skills(relevant_skills)}

# Instructions
When the user's task matches a skill, follow the skill's guidance.
You may adapt the skill based on specific circumstances.
"""
    return prompt

五、多平台网关：一次部署，处处可用

Hermes Agent 另一个亮点是其强大的多平台集成能力。

5.1 支持的平台

5.2 网关架构

Hermes 的网关设计采用了「统一入口 + 平台适配器」模式：

┌─────────────────────────────────────────────────────────┐
│                    消息接收层                            │
│   Telegram │ WhatsApp │ Discord │ Slack │ CLI │ Obsidian│
└───────────────────────┬─────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                    消息标准化层                          │
│         统一消息格式：user_id, content, metadata         │
└───────────────────────┬─────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                    Agent 核心处理层                       │
│              LLM 推理 → 工具调用 → 记忆更新               │
└───────────────────────┬─────────────────────────────────┘
                        ↓
┌─────────────────────────────────────────────────────────┐
│                    响应适配层                            │
│     Markdown 渲染 │ 图片生成 │ 文件传输 │ 格式转换       │
└─────────────────────────────────────────────────────────┘

5.3 Telegram 集成实战

以最常用的 Telegram 集成为例，展示完整的配置流程：

# 1. 创建 Telegram Bot
# 在 Telegram 中搜索 @BotFather，发送 /newbot 创建机器人
# 获取 API Token: 1234567890:ABCdefGHIjklMNOpqrsTUVwxyz

# 2. 配置 Hermes
cd ~/.hermes
cat > config.yaml << EOF
messaging:
  telegram:
    enabled: true
    token: "1234567890:ABCdefGHIjklMNOpqrsTUVwxyz"
    allowed_users:
      - your_telegram_id  # 可选：限制访问用户
EOF

# 3. 启动网关
hermes gateway start telegram

# 4. 测试
# 在 Telegram 中给你的 Bot 发送消息，应该会收到回复

5.4 安全设计：五层防线

Hermes 在多平台接入场景下，设计了五层安全防线：

┌─────────────────────────────────────────────────────────┐
│ 第一层：身份验证                                        │
│   - Telegram user_id 白名单                             │
│   - Slack workspace 验证                                │
│   - API Key 校验                                        │
├─────────────────────────────────────────────────────────┤
│ 第二层：命令过滤                                        │
│   - 危险命令黑名单（rm -rf, format 等）                  │
│   - 敏感路径保护（/etc, ~/.ssh 等）                      │
│   - 网络访问限制                                        │
├─────────────────────────────────────────────────────────┤
│ 第三层：操作审计                                        │
│   - 所有工具调用记录                                    │
│   - 文件操作日志                                        │
│   - 异常行为告警                                        │
├─────────────────────────────────────────────────────────┤
│ 第四层：沙箱隔离                                        │
│   - Docker 容器运行（可选）                              │
│   - 文件系统隔离                                        │
│   - 网络隔离                                            │
├─────────────────────────────────────────────────────────┤
│ 第五层：人工确认                                        │
│   - 高风险操作需用户确认                                 │
│   - 大额支付二次验证                                    │
│   - 敏感数据导出审批                                    │
└─────────────────────────────────────────────────────────┘

六、实战：从零部署 Hermes Agent

6.1 快速安装

Hermes 提供了一键安装脚本，整个过程不超过 3 分钟：

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

# 重载 Shell 配置
source ~/.zshrc  # 或 source ~/.bashrc

# 初始化配置
hermes setup

# 按提示输入 API Key（支持 OpenAI、Anthropic、OpenRouter 等）

安装脚本会自动：

1. 检测系统环境（Linux / macOS / Windows WSL2）
2. 安装 Python 3.11+ 和依赖
3. 创建 ~/.hermes 目录结构
4. 配置默认模型
5. 安装可选的浏览器自动化组件

6.2 目录结构

安装完成后，你会看到这样的目录结构：

~/.hermes/
├── config.yaml           # 主配置文件
├── memories/
│   ├── MEMORY.md        # Agent 记忆
│   └── USER.md          # 用户画像
├── skills/              # 自动生成的技能库
│   ├── api_integration.md
│   ├── code_review.md
│   └── ...
├── sessions.db          # 会话历史数据库
├── tools/               # 自定义工具
└── logs/                # 日志目录

6.3 模型选择建议

Hermes 支持多种 LLM 后端，选择建议如下：

配置示例：

# ~/.hermes/config.yaml
model:
  provider: openrouter  # openai, anthropic, openrouter, ollama
  model_name: "anthropic/claude-3.5-sonnet"
  api_key: "${OPENROUTER_API_KEY}"  # 支持环境变量
  
  # 高级配置
  temperature: 0.7
  max_tokens: 4096
  timeout: 60

6.4 Docker 部署（生产环境推荐）

对于生产环境或需要隔离的场景，推荐使用 Docker：

# docker-compose.yml
version: '3.8'

services:
  hermes:
    image: hermes/hermes:latest
    container_name: hermes-agent
    restart: unless-stopped
    
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - TZ=Asia/Shanghai
    
    volumes:
      - ./hermes-data:/root/.hermes  # 持久化记忆和技能
    
    ports:
      - "8080:8080"  # Web UI（实验性）
    
    # 资源限制
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 4G

启动：

docker-compose up -d

# 查看日志
docker-compose logs -f hermes

# 进入容器交互
docker exec -it hermes-agent hermes chat

七、性能优化与最佳实践

7.1 记忆管理优化

随着使用时间增长，记忆会不断膨胀。优化策略：

定期清理常驻记忆：

# ~/.hermes/tools/cleanup_memory.py
import re
from pathlib import Path
from datetime import datetime, timedelta

def cleanup_old_entries(memory_file: Path, days: int = 30):
    """清理超过指定天数的技术发现条目"""
    content = memory_file.read_text()
    
    cutoff = datetime.now() - timedelta(days=days)
    pattern = r'- (\d{4}-\d{2}-\d{2}): (.+)'
    
    def filter_entry(match):
        date_str, entry = match.groups()
        entry_date = datetime.strptime(date_str, '%Y-%m-%d')
        return match.group(0) if entry_date > cutoff else ''
    
    cleaned = re.sub(pattern, filter_entry, content)
    memory_file.write_text(cleaned)

会话数据库维护：

# 定期执行 VACUUM 优化数据库
sqlite3 ~/.hermes/sessions.db "VACUUM;"

# 重建 FTS 索引
sqlite3 ~/.hermes/sessions.db "INSERT INTO sessions(sessions) VALUES('optimize');"

7.2 技能库管理

避免技能膨胀：

# 技能去重与合并
def merge_similar_skills(skills_dir: Path, similarity_threshold: float = 0.8):
    """合并高度相似的技能"""
    skills = list(skills_dir.glob('*.md'))
    
    for i, skill_a in enumerate(skills):
        for skill_b in skills[i+1:]:
            similarity = compute_similarity(skill_a, skill_b)
            if similarity > similarity_threshold:
                merged = merge_skills(skill_a, skill_b)
                skill_a.write_text(merged)
                skill_b.unlink()  # 删除重复技能

技能版本控制：

# 将技能目录纳入 Git 管理
cd ~/.hermes/skills
git init
git add *.md
git commit -m "Initial skills snapshot"

# 技能回滚
git checkout HEAD~1 -- broken_skill.md

7.3 多模型策略

针对不同任务使用不同模型，优化成本：

# ~/.hermes/config.yaml
model:
  default: "anthropic/claude-3.5-sonnet"
  
  # 任务路由
  routing:
    simple_chat: "openai/gpt-4o-mini"  # 简单对话用便宜模型
    code_review: "anthropic/claude-3.5-sonnet"  # 代码审查用好模型
    skill_creation: "anthropic/claude-3.5-sonnet"  # 技能创建用好模型
    memory_search: "local/all-MiniLM-L6-v2"  # 记忆搜索用本地模型

7.4 成本控制

Hermes 的成本主要来自 LLM API 调用。控制策略：

1. 合理设置 max_tokens：大多数任务不需要 4096 tokens
2. 使用缓存：相似问题复用历史回答
3. 批量处理：多个小任务合并成一个大任务
4. 监控用量：定期检查 API 使用量

# 用量监控脚本
import json
from datetime import datetime, timedelta
from pathlib import Path

def analyze_usage(logs_dir: Path):
    """分析过去一周的 API 用量"""
    usage = {'total_tokens': 0, 'by_model': {}}
    
    for log_file in logs_dir.glob('*.jsonl'):
        for line in log_file:
            entry = json.loads(line)
            # 解析并统计...
    
    return usage

八、与主流 Agent 的对比

核心差异总结：

• Hermes Agent：适合追求「越用越强」体验的用户，需要一定的技术背景
• OpenClaw：适合需要多平台接入和复杂工作流编排的场景
• Codex CLI：适合快速编码任务，开箱即用
• Cursor：适合 IDE 内的日常开发，学习成本最低

九、适用场景与不适用场景

9.1 推荐场景

1. 长期项目开发：Hermes 会记住你的项目结构、编码风格、技术选型
2. 技术研究与探索：Skill 机制会自动沉淀研究方法论
3. 重复性任务自动化：多次执行后，Hermes 会形成高效的处理流程
4. 个人知识管理：与 Obsidian 集成，成为你的「第二大脑」
5. 团队协作：共享技能库，团队经验可传承

9.2 不推荐场景

1. 一次性简单任务：用 ChatGPT 或 Claude 网页版更直接
2. 需要极高准确性的场景：医疗、金融等关键决策，仍需人工审核
3. 无法自托管的场景：如果必须用云端，考虑官方托管方案
4. 非技术用户：当前版本对技术背景有一定要求

十、总结与展望

10.1 核心结论

Hermes Agent 的成功，验证了一个重要的产品理念：Agent 的价值不在于「能做什么」，而在于「能记住什么」「能学会什么」。

它用工程手段，在不修改模型权重的前提下，实现了 Agent 的「自我进化」。这个设计有以下意义：

1. 技术民主化：不需要昂贵的 GPU，任何开发者都能拥有「进化型 Agent」
2. 知识可传承：Skill 文件以开放格式存储，可以分享、版本控制、跨平台迁移
3. 范式创新：从「工具」到「伙伴」，Agent 第一次真正具备了「成长性」

10.2 未来展望

Hermes Agent 目前仍在快速迭代中，值得期待的方向包括：

1. 多 Agent 协作：多个 Hermes 实例之间的技能共享和协作
2. 更强大的浏览器自动化：基于 Camoufox 的隐身浏览器能力增强
3. 本地模型优化：更好地支持 Llama、Mistral 等开源模型
4. 企业级特性：权限管理、审计日志、合规支持

10.3 一句话总结

Hermes Agent 不是「更好的 Agent」，而是「另一种 Agent」——它让 AI 第一次真正拥有了「记忆」和「学习」的能力，这才是 Agent 未来的正确方向。

参考资料

• Hermes Agent GitHub 仓库
• Nous Research 官网
• GAPA 论文：Generalized Action and Prompt Adaptation
• Agent 记忆系统设计最佳实践

本文成文于 2026 年 4 月，基于 Hermes Agent v0.4.0 版本。项目仍在快速迭代中，部分特性可能已有更新。