Hermes Agent 深度拆解：62K Star 的「自进化 AI Agent」如何用闭环学习系统重新定义个人助手——从三层记忆架构到 DSPy+GEPA 技能进化的全栈工程哲学

2026 年 2 月底，Nous Research 开源了 Hermes Agent，一个定位「The agent that grows with you」的自进化 AI Agent 框架。短短两个月，GitHub 星标从零飙升至 62K+，成为 OpenClaw 上线以来第一个真正意义上的有力竞争者。本文从程序员视角出发，深度拆解 Hermes Agent 的闭环学习系统、三层记忆架构、DSPy+GEPA 技能进化引擎，以及它在 AI Agent 生态中的独特价值。

一、背景：当 AI Agent 遇到「成长」的困境

2026 年的 AI Agent 赛道已经进入了白热化阶段。OpenClaw、AutoGPT、MetaGPT、DeerFlow、Peri 等框架百花齐放，但如果你真正用过这些工具，你会发现一个核心痛点：

绝大多数 Agent 是「无状态」的。

每次对话从零开始，每次任务需要重新解释上下文，每次优化依赖人工调参。它们是优秀的「执行者」，但不是「学习者」。你今天教它做的事，明天它会忘记；你今天踩过的坑，明天它会重新踩。

Nous Research 的 Hermes Agent 试图回答一个关键问题：Agent 能否像人类一样，从经验中持续学习和成长？

这个问题的答案，构成了 Hermes Agent 最核心的设计哲学——闭环学习系统（Closed Learning Loop）。

二、核心概念：闭环学习系统

2.1 什么是闭环学习？

传统 Agent 的工作流程是线性的：

接收指令 → 执行任务 → 返回结果 → 结束

Hermes Agent 的工作流程是闭环的：

接收指令 → 执行任务 → 返回结果 → 观察执行过程
    ↑                                           │
    │                                           ▼
使用改进后的技能 ← 创建/改进技能 ← 提取经验教训

这个闭环由四个关键动作驱动：

1. 执行任务：Agent 接收用户指令，调用工具完成任务
2. 观察结果：Agent 记录执行过程中的成功经验和失败教训
3. 提取经验：将成功的工作流抽象为可复用的方法论
4. 持久化知识：将方法论封装为 Skill（技能），存储到技能库中

下次遇到类似任务时，Agent 不是从零推理，而是直接调用已有的 Skill，效率提升约 40%。

2.2 技能系统（Skills System）

Skill 是 Hermes Agent 能力沉淀的核心载体。每个 Skill 本质上是一个 Markdown 文件，包含 YAML frontmatter（元数据）和 Markdown body（执行指令）。

---
name: github-code-review
description: 自动化 GitHub PR 代码审查
version: 1.2.0
tags: [github, code-review, automation]
---

# GitHub Code Review Skill

## 执行步骤

1. 使用 `gh pr diff` 获取 PR 差异
2. 分析代码变更，检查以下维度：
   - 代码风格一致性
   - 潜在的 bug 和安全漏洞
   - 性能问题
   - 测试覆盖率
3. 生成结构化的审查报告
4. 自动添加 PR 评论

Hermes Agent 内置了 288 个 Skill，另有 116 个可选 Skill。更关键的是，Agent 可以自主创建新的 Skill——完成复杂任务后，它会自动将成功的工作流封装为一个新的 Skill 文件，存入 skills/ 目录。

2.3 三层记忆架构

Hermes Agent 的记忆系统分为三层，每层解决不同的问题：

┌─────────────────────────────────────┐
│  Layer 1: Built-in Memory           │
│  MEMORY.md (2200字符上限)           │
│  USER.md (1375字符上限)             │
│  → 高频访问，始终激活               │
├─────────────────────────────────────┤
│  Layer 2: External Memory Providers │
│  Honcho / Holographic / Mem0 等     │
│  8个可插拔后端，同时只激活1个       │
│  → 语义记忆，深度理解               │
├─────────────────────────────────────┤
│  Layer 3: Session Search            │
│  SQLite + FTS5 全文索引             │
│  所有历史会话存储，按需检索         │
│  → 历史回溯，跨会话召回             │
└─────────────────────────────────────┘

Layer 1 是 Agent 的「工作记忆」，两个 Markdown 文件始终在上下文窗口中：

• MEMORY.md：Agent 的个人笔记，存储长期事实和经验教训（2200 字符上限，防止无限膨胀）
• USER.md：用户画像，记录用户的代码风格、技术偏好、使用习惯（1375 字符上限）

Layer 2 是 Agent 的「语义记忆」，支持 8 种可插拔后端：

Layer 3 是 Agent 的「长期记忆」，所有历史会话都存储在 SQLite 数据库中，带 FTS5 全文索引。当需要回忆过去的交互时，Agent 通过全文搜索 + Gemini Flash 摘要的方式召回相关记忆。

三、架构分析：Hermes Agent 的五层架构

3.1 整体架构图

┌────────────────────────────────────────────────────────┐
│                    HermesAgent                          │
│                                                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │ CLI/TUI  │  │ Telegram │  │ Discord  │  │  Slack │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └───┬────┘ │
│  ─────┴──────────────┴──────────────┴────────────┴────  │
│                        │  Interface Layer               │
│  ┌─────────────────────▼─────────────────────────────┐  │
│  │              AI Agent Core                         │  │
│  │         run_agent.py (同步 Agent 循环)             │  │
│  └─────────────────────┬─────────────────────────────┘  │
│                        │                                 │
│  ┌──────────┬──────────┼──────────┬──────────┬────────┐ │
│  │  Tools   │  Memory  │  Skills  │  Model   │  Cron  │ │
│  │ Registry │ Manager  │  System  │  Meta    │ Sched  │ │
│  └────┬─────┘────┬─────┘────┬─────┘────┬─────┘───┬────┘ │
│  ─────┴──────────┴──────────┴──────────┴─────────┴────  │
│                        │  Core Services                 │
│  ┌─────────────────────▼─────────────────────────────┐  │
│  │         Tool Implementations (40+)                 │  │
│  │  terminal|file|web|browser|code_exec|delegate|mcp │  │
│  └───────────────────────────────────────────────────┘  │
│                                                         │
│  ┌───────────────────────────────────────────────────┐  │
│  │         Terminal Backends (6种)                    │  │
│  │     local|docker|ssh|daytona|modal|...            │  │
│  └───────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────┘
         │                           │
    ┌────▼────┐                 ┌────▼────┐
    │ SessionDB│                 │ RL Env  │
    │ (SQLite) │                 │(Atropos)│
    └─────────┘                 └─────────┘

3.2 五个关键架构决策

决策 1：同步 Agent 循环

Hermes Agent 的核心循环 run_conversation() 是完全同步的，没有使用 async/await：

while api_call_count < self.max_iterations and self.iteration_budget.remaining > 0:
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        tools=tool_schemas
    )
    if response.tool_calls:
        for tool_call in response.tool_calls:
            result = handle_function_call(tool_call.name, tool_call.args, task_id)
            messages.append(tool_result_message(result))
        api_call_count += 1
    else:
        return response.content

这种设计看似「保守」，实则大大降低了理解和调试的复杂度。对于快速迭代的初创团队，同步设计意味着更简单的错误处理、更直观的调试体验、更可预测的执行流程。

决策 2：中心化工具注册

所有工具通过 tools/registry.py 统一注册和分发。添加新工具只需两步：

# tools/my_tool.py
from tools.registry import registry

def handle(args, task_id):
    # 工具逻辑
    return {"status": "success", "result": "..."}

registry.register(
    name="my_tool",
    handler=handle,
    description="My custom tool",
    parameters={
        "input": {"type": "string", "description": "Input text"}
    }
)

这种设计让工具系统高度可扩展，40+ 内置工具和 MCP 集成工具都通过同一套注册机制管理。

决策 3：OpenAI 消息格式统一

无论使用哪个 LLM Provider（OpenRouter、OpenAI、Nous Portal），内部统一使用 OpenAI 兼容的消息格式（role: system/user/assistant/tool），大幅降低了多 Provider 适配的复杂度。

决策 4：Profile 多实例隔离

通过 HERMES_HOME 环境变量实现完全隔离的多实例支持，代码中 119+ 处引用 get_hermes_home() 确保路径隔离。这对于多租户场景至关重要——不同用户可以有完全独立的技能库、记忆库和配置。

决策 5：研究导向的模块设计

RL 训练环境（Atropos）、轨迹压缩、批量运行器这些模块从一开始就融入架构设计的核心组件，而不是后来添加的。这让 Hermes Agent 成为目前最开箱即用的 Agent 研究平台。

3.3 目录结构速览

hermes-agent/
├── run_agent.py          # 核心：AIAgent 类与对话循环
├── model_tools.py        # 工具编排与函数调用分发
├── toolsets.py           # 工具集定义（40+ 工具列表）
├── cli.py                # 交互式 CLI 编排器
├── hermes_state.py       # SessionDB — SQLite 会话存储
│
├── agent/                # Agent 内部模块（33 文件）
│   ├── prompt_builder.py     # 系统提示词组装
│   ├── context_compressor.py # 自动上下文压缩
│   ├── memory_manager.py     # 记忆上下文构建
│   └── error_classifier.py   # API 错误分类与故障转移
│
├── tools/                # 工具实现（71 文件）
│   ├── registry.py           # 中央工具注册表
│   ├── terminal_tool.py      # 终端编排
│   ├── file_tools.py         # 文件操作
│   ├── browser_tool.py       # 浏览器自动化
│   └── environments/         # 6种终端后端实现
│       ├── local.py          # 本地终端
│       ├── docker.py         # Docker 容器
│       ├── ssh.py            # SSH 远程
│       └── ...
│
├── hermes_cli/           # CLI 子命令（48 文件）
│   ├── main.py               # 所有 hermes 子命令入口
│   ├── skin_engine.py        # 皮肤/主题引擎
│   └── skills_hub.py         # 技能市场
│
├── gateway/              # 消息平台网关（42 文件）
│   └── platforms/            # Telegram/Discord/Slack/WhatsApp/QQ...
│
├── skills/               # 288 个内置技能（Markdown）
├── optional-skills/      # 116 个可选技能
├── tests/                # ~3000 个测试
└── environments/         # RL 训练环境（Atropos）

四、代码实战：闭环学习系统的实现

4.1 技能自动创建

当 Agent 完成一个复杂任务后，闭环学习系统会自动触发 Skill 创建流程：

# agent/skill_creator.py (简化版)

class SkillCreator:
    """Agent 自动创建 Skill 的核心逻辑"""
    
    def create_skill_from_task(self, task_history: list, result: dict):
        """从任务执行历史中提取可复用的 Skill"""
        
        # 1. 分析任务执行过程
        workflow_steps = self.extract_workflow(task_history)
        
        # 2. 抽象为通用方法论
        skill_template = self.abstract_to_template(workflow_steps)
        
        # 3. 生成 SKILL.md 文件
        skill_content = f"""---
name: {skill_template.name}
description: {skill_template.description}
version: 1.0.0
auto_generated: true
---

# {skill_template.name}

## 执行步骤

{skill_template.steps}

## 注意事项

{skill_template.caveats}
"""
        
        # 4. 保存到 skills/ 目录
        skill_path = Path(f"skills/{skill_template.name}/SKILL.md")
        skill_path.parent.mkdir(parents=True, exist_ok=True)
        skill_path.write_text(skill_content)
        
        # 5. 注册到技能库
        self.skills_registry.register(skill_template.name, skill_path)
        
        return skill_path

4.2 技能进化（DSPy + GEPA）

Hermes Agent 的自进化引擎使用了 DSPy 和 GEPA（Genetic-Pareto Prompt Evolution）两个核心技术：

# evolution/skills/evolve_skill.py (核心逻辑)

import dspy
from dspy import GEPA

class SkillModule(dspy.Module):
    """将 Skill 包装为可优化的 DSPy 模块"""
    
    def __init__(self, skill_text: str):
        super().__init__()
        self.skill_text = skill_text  # Skill 内容作为可优化参数
    
    def forward(self, task_input: str) -> str:
        """使用 Skill 指令完成任务"""
        # 调用 LLM，将 Skill 内容作为指令
        response = dspy.Predict(
            "skill_executor"
        )(skill=self.skill_text, task=task_input)
        return response.output


def evolve_skill(skill_name: str, iterations: int = 10):
    """进化一个 Skill"""
    
    # 1. 加载原始 Skill
    skill_path = find_skill(skill_name)
    original_skill = load_skill(skill_path)
    
    # 2. 构建评估数据集（三种来源）
    dataset = build_eval_dataset(
        source="synthetic",  # 或 "session" 或 "golden"
        skill_text=original_skill
    )
    
    # 3. 创建基准模块
    baseline_module = SkillModule(original_skill)
    
    # 4. 配置 GEPA 优化器
    optimizer = dspy.GEPA(
        metric=skill_fitness_metric,  # 适应度评估函数
        max_steps=iterations
    )
    
    # 5. 运行优化
    trainset, valset = split_dataset(dataset)
    optimized_module = optimizer.compile(
        baseline_module, 
        trainset=trainset,
        valset=valset
    )
    
    # 6. 约束验证
    validator = ConstraintValidator(
        max_skill_size=15_000,       # 15KB 大小限制
        max_prompt_growth=0.20       # 20% 增长限制
    )
    validated_skill = validator.validate(optimized_module.skill_text)
    
    # 7. Holdout 评估
    baseline_score = evaluate(baseline_module, valset)
    evolved_score = evaluate(optimized_module, valset)
    print(f"Baseline: {baseline_score:.2f} → Evolved: {evolved_score:.2f}")
    
    # 8. 保存优化后的 Skill
    save_evolved_skill(skill_name, validated_skill)

4.3 评估数据集构建

评估数据集有三种来源，可以灵活选择：

# evolution/skills/dataset_builders.py

class SyntheticDatasetBuilder:
    """合成数据集：LLM 生成测试用例"""
    
    def build(self, skill_text: str, num_samples: int = 20):
        prompt = f"""Based on this skill description:
{skill_text}

Generate {num_samples} test cases, each with:
- task_input: A realistic user request
- expected_behavior: What the skill should produce

Output as JSONL."""
        
        return llm_generate(prompt)


class SessionDatasetBuilder:
    """会话数据集：从历史会话中挖掘"""
    
    def build(self, skill_name: str, num_samples: int = 20):
        # 从多种来源挖掘历史数据
        sources = [
            ("~/.claude/history.jsonl", "Claude Code"),
            ("~/.copilot/session-state/", "Copilot"),
            ("~/.hermes/sessions/", "Hermes"),
        ]
        
        all_samples = []
        for path, source in sources:
            if Path(path).exists():
                samples = self.extract_from_source(path, skill_name)
                all_samples.extend(samples)
        
        # 按相关性排序，取 top-N
        return sorted(all_samples, key=lambda x: x.relevance, reverse=True)[:num_samples]


class GoldenDatasetBuilder:
    """黄金数据集：人工标注的标准答案"""
    
    def build(self, skill_name: str):
        golden_path = Path(f"datasets/{skill_name}_golden.jsonl")
        if golden_path.exists():
            return load_jsonl(golden_path)
        return []

4.4 记忆管理实战

# agent/memory_manager.py (核心逻辑)

class MemoryManager:
    """Hermes Agent 三层记忆管理器"""
    
    def __init__(self, hermes_home: Path):
        self.hermes_home = hermes_home
        self.builtin_memory = BuiltinMemory(hermes_home)
        self.external_provider = self._init_external_provider()
        self.session_db = SessionDB(hermes_home / "sessions.db")
    
    def recall(self, query: str, context: str = "") -> str:
        """从三层记忆中召回相关信息"""
        
        results = []
        
        # Layer 1: 内置记忆（始终可用）
        builtin_context = self.builtin_memory.get_context()
        results.append(("builtin", builtin_context))
        
        # Layer 2: 外部记忆提供者
        if self.external_provider:
            external_results = self.external_provider.search(query, top_k=5)
            results.append(("external", external_results))
        
        # Layer 3: 会话搜索
        session_results = self.session_db.search(
            query, 
            mode="fts5",
            top_k=10
        )
        results.append(("session", session_results))
        
        # 用 LLM 做摘要
        combined = self._combine_results(results)
        summary = self._summarize_with_llm(combined, context)
        
        return summary
    
    def persist(self, information: str, importance: float = 0.5):
        """持久化重要信息"""
        
        # 更新内置记忆
        if importance > 0.7:
            self.builtin_memory.append("MEMORY.md", information)
        
        # 存入会话数据库
        self.session_db.insert({
            "content": information,
            "importance": importance,
            "timestamp": datetime.now().isoformat()
        })

4.5 用户建模（Honcho 集成）

# agent/user_model.py

class UserModel:
    """基于 Honcho 的用户画像系统"""
    
    def __init__(self):
        self.honcho_client = HonchoClient()
    
    def update_profile(self, conversation: list):
        """从对话中更新用户画像"""
        
        # 提取用户特征
        features = {
            "code_style": self._extract_code_style(conversation),
            "tech_stack": self._extract_tech_stack(conversation),
            "preferences": self._extract_preferences(conversation),
            "communication_style": self._extract_comm_style(conversation),
        }
        
        # 更新 Honcho 用户模型
        self.honcho_client.update_user_profile(features)
    
    def get_personalized_prompt(self) -> str:
        """获取个性化系统提示词"""
        
        profile = self.honcho_client.get_user_profile()
        
        return f"""用户画像：
- 代码风格：{profile.code_style}
- 技术栈：{profile.tech_stack}
- 偏好：{profile.preferences}
- 沟通风格：{profile.communication_style}

请根据以上画像调整你的响应方式。"""

五、性能与对比

5.1 核心数据

5.2 适用场景

Hermes Agent 更适合：

• 个人开发者想要一个「越用越聪明」的个人助手
• AI 研究人员需要内置 RL 训练环境和轨迹记录
• 希望 Agent 能自动沉淀技能、避免重复劳动
• Python 技术栈团队，追求代码可读性和快速迭代

OpenClaw 更适合：

• 企业级多通道消息集成（50+ 平台）
• 需要无损上下文管理（LCM）的复杂场景
• TypeScript 技术栈团队
• 需要更成熟的生态系统和社区支持

5.3 实测数据

根据社区实测反馈：

• 重复任务执行速度提升约 40%（Skill 复用）
• 代码审查准确率提升约 25%（Skill 进化后）
• 长期记忆召回准确率约 78%（FTS5 + LLM 摘要）
• 单次技能进化成本约 2-10 美元（API 调用费用）

六、技术栈选择

Hermes Agent 的技术栈选择非常务实：

一个值得注意的设计：大量功能通过可选依赖组管理。比如你要用 Telegram 就装 messaging 组，要用 RL 训练就装 rl 组，保持核心安装的精简。

七、部署实战

7.1 一键安装

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

# 安装完成后
source ~/.bashrc && hermes  # 或 source ~/.zshrc

7.2 Docker 部署

# 拉取镜像
docker pull nousresearch/hermes-agent:latest

# 运行容器
docker run -d \
  --name hermes \
  -v hermes-data:/root/.hermes \
  -e OPENAI_API_KEY=your_key \
  -p 8080:8080 \
  nousresearch/hermes-agent:latest

7.3 5 美元 VPS 部署

# 在 $5 VPS 上
ssh root@your-vps

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

# 配置
hermes config set provider openrouter
hermes config set model anthropic/claude-sonnet-4-20250514

# 启动后台服务
hermes daemon start

八、总结与展望

Hermes Agent 的爆火，本质上是击中了 AI Agent「自进化」的核心痛点。它打破了传统 Agent「被动执行」的局限，通过完整的学习闭环和独立的自进化引擎，让 Agent 具备了「成长能力」。

当前局限

1. 自进化仅实现 Phase 1：目前只能进化 Skill 文档，工具描述、系统提示词、代码层面的进化（Phase 2-5）尚未实现
2. 项目仍在快速迭代：部分功能稳定性和兼容性需要进一步验证
3. 社区生态相对年轻：相比 OpenClaw 的 330K Star 和 50+ 平台支持，Hermes Agent 的生态系统还在建设中

未来方向

Hermes Agent 规划了五阶段进化路线：

如果这五个阶段全部实现，Hermes Agent 将成为第一个真正意义上的「全维度自进化 AI Agent」——不仅能优化自己的技能，还能优化自己的工具描述、系统提示词和代码，甚至能自动监控性能下降并触发进化任务。

对于程序员来说，Hermes Agent 提供了一个极具价值的参考实现：Agent 不应该只是一个执行工具，而应该是一个持续成长的数字同事。这种设计理念，可能会深刻影响下一代 AI Agent 的架构范式。

项目地址：https://github.com/NousResearch/hermes-agent
许可证：MIT
技术栈：Python + OpenAI SDK + SQLite + DSPy + GEPA
核心数据：62K+ Stars | 40+ 工具 | 404 个 Skill | 14+ 消息平台 | ~3000 测试