Hermes Agent 自进化闭环深度拆解：从三层记忆到技能自沉淀，一次把 Nous Research 的 AI Agent 革命讲透（2026）

前言：为什么 Hermes Agent 值得关注

2026 年的 AI Agent 赛道，卷模型能力已经不够了。

当 OpenAI、Anthropic、DeepSeek 轮流刷新基准测试榜单时，开发者社区的关注点却在悄悄转移——大家不再只问「这个模型有多强」，而是问「这个 Agent 能不能记住我、能不能自己学会新技能、能不能在本地跑」。

正是在这个节点上，一个叫 Hermes Agent 的开源项目以惊人的速度崛起：

• GitHub Stars 突破 106,000（2026 年 7 月）
• 上线不到半年，连续霸榜 GitHub Trending 多日
• OpenRouter 排行榜 Coding Agents 第一、Productivity 第二
• 被称为「会自我迭代的学徒」—— 与传统 AI 对话机器人的根本差异在于，它会从每次交互中学习和进化

开发它的是 Nous Research——一个在 LLM 社区以 DeepSeek 模型微调系列闻名的实验室。他们没有选择在模型规模上继续卷，而是在** Agent 架构**上找到了差异化突破口。

本文将深度拆解 Hermes Agent 的核心技术：从 GEPA 自进化引擎、四层记忆架构、五步学习闭环、MCP 集成，到完整部署实战与横评对比，一次把这款「越用越聪明」的 AI Agent 讲透。

前置说明：本文分析基于 v0.14.0 版本（约 3 万行 Python 代码），分析日期 2026 年 7 月。项目地址：https://github.com/nousresearch/hermes-agent

一、项目概览：110K Stars 背后的数字

在深入技术细节之前，先看一组数据，建立对 Hermes Agent 的整体认知：

从这些数字可以看出：Hermes Agent 不是玩具级别的演示项目，而是一个完整的、生产可用的 Agent 框架。它的野心是成为「数字员工」——一个能在你日常工作中持续学习、持续进步的存在。

二、核心架构：Agent-First 的设计哲学

要理解 Hermes Agent，先要理解它与同类项目在架构哲学上的根本差异。

2.1 两种主流架构的分野

当前开源 AI Agent 领域存在两种截然不同的架构路线：

Gateway-First（网关优先）：以 OpenClaw 为代表，核心是一个中心化的消息网关（Gateway），负责接收来自各个平台的消息，然后路由给内部的 Agent 处理。Gateway 是主角，Agent 是被调用的一环。

Agent-First（智能体优先）：以 Hermes Agent 为代表，核心是 Agent 本身，消息网关只是外围的输入渠道。Agent 是主角，网关是配角。

# OpenClaw 的架构（Gateway-First）
[消息网关 Gateway] ──→ [Agent 调度] ──→ [工具/技能]
   ↑                      ↑                  ↑
WhatsApp/Telegram/...   多智能体路由        Cron Jobs

# Hermes Agent 的架构（Agent-First）
[消息网关（TUI/CLI/Telegram/...）] ──→ [Agent Loop] ──→ [工具/技能/记忆]
                                    ↑
                              GEPA 引擎（自进化）

这种架构差异带来了一个深层问题：谁来主导智能体的行为？

在 Gateway-First 架构中，行为由网关路由规则和配置的技能决定——你配置什么它做什么，适合需要精细控制的场景。

在 Agent-First 架构中，行为由 Agent 的内在目标驱动——它自己决定下一步做什么、记住什么、生成什么技能——更接近「自主智能体」的定义。

2.2 Hermes Agent 的完整架构图

从源码分析（conversation_loop.py）来看，Hermes Agent 的核心处理流程如下：

用户输入 → 消息网关 → 对话主循环（conversation_loop）
                          │
            ┌─────────────┼─────────────┐
            ↓             ↓             ↓
        工具调用      学习循环      记忆系统
        (tools)       (GEPA)      (SQLite/FTS5)
            │             │             │
            └─────────────┼─────────────┘
                          ↓
                      Agent 响应

对话主循环（conversation_loop.py）是整个系统的核心调度器：

1. 接收用户输入
2. 从记忆系统检索相关上下文
3. 将消息 + 上下文注入模型 prompt
4. 模型生成响应（可能包含工具调用）
5. 执行工具调用
6. 评估结果，更新记忆
7. 进入下一轮

三、GEPA 引擎：自进化的心脏

Hermes Agent 与其他 Agent 框架最大的差异化在于它的 GEPA 引擎（Goal-Execution-Planning-Adaptation Engine，暂译为「目标-执行-规划-适应引擎」）。

这不是一个营销词汇，而是一套有完整代码支撑的闭环系统。

3.1 什么是 GEPA

GEPA 是 Hermes Agent 的决策与学习核心，嵌入在对话循环的每个回合中。它的名字揭示了四个核心阶段：

1. Goal（目标理解）：理解用户的真实意图，不仅是字面需求
2. Execution（执行）：调用工具、搜索信息、操作文件
3. Planning（规划）：制定任务步骤，预判可能的失败路径
4. Adaptation（适应）：评估执行结果，将有效经验沉淀为可复用技能

3.2 GEPA 的代码结构

从源码分析，GEPA 的核心逻辑简化如下：

# 伪代码，基于 conversation_loop.py 分析
class GEPAEngine:
    def process(self, user_input, context):
        # Goal: 理解用户意图
        intent = self.understand_intent(user_input)
        
        # Execution: 执行任务
        result = self.execute_task(intent, context)
        
        # Planning: 规划下一步
        if not result.complete:
            next_step = self.plan_next(result, intent)
        
        # Adaptation: 评估并学习
        self.evaluate_and_learn(result, intent)
        
        return result
    
    def evaluate_and_learn(self, result, intent):
        """GEPA 的适应阶段——这是自进化的核心"""
        if result.success:
            # 检查是否应该生成新技能
            if self.should_create_skill(result, intent):
                self.create_skill(result, intent)
            # 更新记忆
            self.update_memory(result)
        else:
            # 记录失败经验，避免重蹈覆辙
            self.record_failure(result)
            # 尝试改进已有技能
            self.improve_skill(result)

3.3 自进化闭环的五步机制

GEPA 的适应能力通过一个五步闭环实现，这套机制是 Hermes Agent 最核心的创新：

完成任务 → 策划记忆 → 创建 Skill → Skill 自改进 → FTS5 召回 → 用户建模
    ↑                                                                      ↓
    └──────────────────────────────── (下一轮任务) ←──────────────────────┘

第一步：完成任务
Agent 执行用户请求，完成代码编写、文件操作、信息搜索等任务。

第二步：策划记忆（Memory Planning）
任务完成后，Agent 自主判断哪些信息值得长期记住。这不是简单的「存储」，而是一个 LLM 驱动的决策过程——它会问自己：「这段对话中的什么信息下次还有用？」

第三步：创建 Skill（Skill Crystallization）
当 Agent 识别到一个重复出现的模式时（比如「用户每次让我查 GitHub issues 并总结」），它会主动生成一个 .md 格式的 Skill 文件：

# skill: github_issues_summary.md
# 自动生成 by Hermes Agent GEPA Engine

## 触发条件
用户要求：总结 / 查看 / 列出 GitHub issues

## 执行步骤
1. 使用 `gh issue list --state open --limit 20` 获取最新 issues
2. 调用 LLM 总结每个 issue 的标题和描述
3. 按优先级分组（Bug / Feature / Question）

## 成功标准
- 返回了至少 10 条 open issues
- 每条都有 LLM 生成的摘要

## 适用场景
- 需要快速了解项目活跃度时
- Code Review 前的背景调研

第四步：Skill 自改进
当一个现有 Skill 执行失败时，GEPA 会分析失败原因，并尝试自动优化 Skill 内容。这对应认知科学中的「元认知」——Agent 反思自己做错了什么，然后改进。

第五步：FTS5 召回 + 用户建模
Hermes Agent 使用 SQLite 的 FTS5（Full-Text Search 5）扩展实现全文检索，并结合用户行为模型（Honcho）推断用户偏好，形成个性化记忆。

这五步机制对应认知科学中的三种记忆类型：

• 情景记忆（Episodic Memory）：会话历史 → SQLite 归档
• 语义记忆（Semantic Memory）：持久事实 → MEMORY.md 文件
• 程序性记忆（Procedural Memory）：操作流程 → Skill 文件

四、四层记忆系统：让 Agent 真正记住一切

大多数 AI Chatbot 最大的痛点是什么？「金鱼记忆」——每次新对话都要从零开始，模型根本不知道你是谁、你上次做了什么。

Hermes Agent 用一套四层记忆架构解决了这个问题。

4.1 四层架构详解

Layer 0 — 系统指令记忆
Hermes Agent 的系统提示（System Prompt）包含基础运行规则和当前会话上下文。这部分每次新会话重新生成，但内容来自下层的持久化存储。

Layer 1 — 冻结记忆（Frozen Memory）
这部分存储在 ~/.hermes/memory/ 下的文本文件中，包含：

• 用户的基本身份（姓名、职业、项目背景）
• 长期有效的约定（「每周一要开站会」「代码风格用 ESLint」）
• 重要事实（「我用的是 M2 Mac」「我们团队用 GitFlow」）

Layer 1 的特殊之处在于：它不会在每次对话中被修改，而是通过 GEPA 引擎的策划阶段有选择性地更新——确保 Agent 的「世界观」不会因为单次对话而剧烈漂移。

Layer 2 — 会话归档（Session Archive）
这是 Hermes Agent 区别于大多数 Agent 的关键设计：

-- 消息表：记录所有对话
CREATE TABLE messages (
    id INTEGER PRIMARY KEY,
    session_id TEXT,
    role TEXT,           -- 'user' 或 'assistant'
    content TEXT,
    created_at TIMESTAMP
);

-- FTS5 虚拟表：全文搜索
CREATE VIRTUAL TABLE messages_fts USING fts5(
    content,
    content=messages,
    content_rowid=id
);

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

Hermes 的作者给出了一个务实的答案：「不需要为了技术而技术」。对于个人 Agent 的场景：

• 数据规模在几千到几万条对话之间
• 主要是精确关键词搜索（如「上次我让你找的那个 Python 脚本在哪」）
• SQLite + FTS5 在这个规模下速度极快，且零依赖

向量数据库（Milvus/Pinecone/Weaviate）更适合超大规模语义检索，而 Hermes Agent 的场景更偏向精确记忆召回。

Layer 3 — 技能库（Skills Library）
Skills 是 Hermes Agent 的可复用技能单元，存储在 ~/.hermes/skills/ 目录下：

~/.hermes/skills/
├── github_issues_summary.md   # GitHub issues 总结
├── weekly_report.md           # 周报生成器
├── code_review.md             # Code Review 助手
└── debug_helper.md            # 调试问题助手

每个 Skill 是一个 Markdown 文件，包含触发条件、执行步骤和成功标准。Agent 在运行时通过模式匹配决定是否激活某个 Skill。

4.2 记忆系统的代码实现

从源码来看，记忆管理的核心逻辑在 memory/ 模块：

# memory/manager.py（简化）
class MemoryManager:
    def __init__(self, db_path="~/.hermes/hermes.db"):
        self.conn = sqlite3.connect(os.path.expanduser(db_path))
        self._init_schema()
    
    def _init_schema(self):
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS messages (
                id INTEGER PRIMARY KEY,
                session_id TEXT,
                role TEXT,
                content TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        """)
        self.conn.execute("""
            CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts 
            USING fts5(content, content=messages, content_rowid=id)
        """)
    
    def search(self, query: str, limit: int = 10):
        """全文检索，精确匹配历史对话"""
        cursor = self.conn.execute("""
            SELECT content, bm25(messages_fts) as rank
            FROM messages_fts
            WHERE messages_fts MATCH ?
            ORDER BY rank
            LIMIT ?
        """, (query, limit))
        return cursor.fetchall()
    
    def archive_session(self, messages: list):
        """会话结束后归档"""
        for msg in messages:
            self.conn.execute(
                "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
                (msg['session_id'], msg['role'], msg['content'])
            )
        self.conn.commit()

五、MCP 集成：工具扩展的瑞士军刀

5.1 MCP 协议简介

MCP（Model Context Protocol） 是 Anthropic 在 2024 年底推出的标准化协议，旨在解决「如何让 AI Agent 连接外部工具」的问题——类似于 USB 接口之于硬件设备。

Hermes Agent 对 MCP 的支持非常深入，可以一键接入 GitHub、数据库、企业内网工具等。

5.2 MCP 配置实战

在 ~/.hermes/config.yaml 中配置 MCP 服务器：

mcp_servers:
  github:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_TOKEN: "${GITHUB_TOKEN}"
  
  filesystem:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem"]
    args:
      - "/path/to/allowed/directory"
  
  postgres:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-postgres"]
    env:
      DATABASE_URL: "${DATABASE_URL}"

配置完成后，Agent 可以在对话中自然语言调用这些工具：

用户：「帮我查一下我们的 GitHub 仓库最近一个月有多少 PR 被合并了？」

Hermes Agent：「我来查一下 GitHub 数据……根据过去 30 天的合并记录，共合并了 47 个 PR，其中功能开发类 28 个，Bug 修复 12 个，文档更新 7 个。需要我生成一份详细报告吗？」

5.3 内置工具一览

Hermes Agent 默认提供的内置工具覆盖了日常开发的高频场景：

这些工具通过 LangChain 的 tool calling 接口实现统一调度：

# tools/registry.py（简化）
from langchain.tools import tool

@tool
def bash(command: str) -> str:
    """Execute a bash command and return the output."""
    result = subprocess.run(
        command, shell=True, 
        capture_output=True, text=True, timeout=30
    )
    return result.stdout + result.stderr

@tool  
def read(path: str) -> str:
    """Read the contents of a file."""
    with open(os.path.expanduser(path), 'r') as f:
        return f.read()

六、模型无关性：200+ 接入商的技术内幕

Hermes Agent 另一个令人印象深刻的能力是它对模型提供商的广泛支持。

6.1 支持的模型提供商

6.2 模型切换的代码实现

模型切换通过统一的适配层实现：

# models/adapter.py（简化）
class ModelAdapter:
    def __init__(self, provider: str, model: str, api_key: str):
        self.provider = provider
        self.model = model
        self.client = self._create_client(provider, api_key)
    
    def _create_client(self, provider, api_key):
        if provider == "openai":
            return OpenAIClient(api_key)
        elif provider == "anthropic":
            return AnthropicClient(api_key)
        elif provider == "openrouter":
            return OpenRouterClient(api_key)
        elif provider == "ollama":
            return OllamaClient()  # 无需 API Key，本地运行
        else:
            return GenericOpenAICompatibleClient(api_key)
    
    async def chat(self, messages: list, tools: list = None):
        return await self.client.chat(messages, tools=tools)

# ~/.hermes/config.yaml
model:
  provider: openrouter    # 一行切换所有模型
  model: deepseek/deepseek-coder-v2-0324  # OpenRouter 模型 ID
  api_key: ${OPENROUTER_API_KEY}

这种设计带来了一个有趣的可能性：用 DeepSeek Coder 写代码，用 Claude 分析需求，用 GPT-4o 生成文档——同一套 Agent 框架，不同场景用最合适的模型。

注意：Hermes Agent 要求模型的上下文窗口至少 64K tokens。如果使用上下文较小的模型（如 GPT-3.5-turbo 的 16K 版本），可能导致多步工具调用失败。

七、实战：从零部署 Hermes Agent

7.1 环境要求

7.2 安装步骤（Linux/macOS）

# 方式一：一键安装（推荐）
curl -sS https://raw.githubusercontent.com/nousresearch/hermes-agent/main/install.sh | bash

# 方式二：手动安装
git clone https://github.com/nousresearch/hermes-agent.git
cd hermes-agent
pip install -r requirements.txt
python -m hermes setup

# 验证安装
hermes --version

7.3 初始配置

# 启动引导配置
hermes setup

# 这会自动：
# 1. 创建 ~/.hermes/ 目录结构
# 2. 生成默认 config.yaml
# 3. 提示输入 API Key

配置完成后，编辑 ~/.hermes/config.yaml：

# ~/.hermes/config.yaml
model:
  provider: openrouter
  model: anthropic/claude-3-5-sonnet-20241022
  api_key: sk-or-v1-xxxxx   # 从 https://openrouter.ai/keys 获取

backend: cli  # 可选: cli | tui | desktop

tools:
  enabled:
    - bash
    - read
    - edit
    - glob
    - grep
    - web_search
    - browser

memory:
  fts_enabled: true
  archive_threshold: 100  # 对话超过100轮后自动归档

7.4 常用命令

# 启动交互式对话
hermes

# 恢复上次会话
hermes --continue

# 切换模型
hermes model anthropic/claude-3-5-sonnet-20241022

# 查看记忆状态
hermes memory stats

# 列出所有 Skills
hermes skills list

# 手动触发学习
hermes learn

# 后台运行（守护进程模式）
hermes daemon

八、与 OpenClaw、AutoGPT 的横评对比

8.1 横向对比表

8.2 各场景选择建议

选 Hermes Agent 如果：

• 你需要一个「越用越聪明」的长期助手
• 你希望 Agent 自动学会新技能，无需手动配置
• 你需要在本地跑（Ollama 支持好）
• 你重视记忆的精确检索（FTS5 > 向量检索）

选 OpenClaw 如果：

• 你需要多平台消息接入（WhatsApp/Telegram 全都要）
• 你需要强大的定时任务和自动化能力（Cron Jobs）
• 你偏好通过 Skills 精细控制 Agent 行为
• 你需要多 Agent 协作

选 AutoGPT 如果：

• 你只需要一个简单的自动化任务执行器
• 你的场景是短期的单任务，不需要长期记忆

8.3 性能实测数据

根据社区基准测试（来源：OpenRouter 排行榜，2026 年 7 月）：

Hermes Agent 在「记忆持久化」和「多步任务」两个维度上有显著优势，这正是它的核心价值主张。

九、局限与挑战：诚实面对短板

没有任何技术是完美的。在赞美 Hermes Agent 之前，我们也需要诚实地看看它的局限：

9.1 长上下文压缩导致的「身份漂移」

随着对话长度增加，Hermes Agent 会对早期上下文进行压缩以节省 token。这会导致：

• Agent 可能忽略之前设定的角色要求
• 多次压缩后，Agent 可能「忘记」用户的基础偏好
• 使用 DeepSeek 模型时，这个问题尤为明显

解决方案：定期开启新会话，将重要记忆转移到 Layer 1（冻结记忆）。

9.2 Skill 自动生成的质量不稳定

GEPA 引擎自动生成的 Skill 文件有时过于模板化，缺乏对特定工作流程的适配。用户需要定期检查 ~/.hermes/skills/ 目录，手动优化生成的 Skill。

9.3 多 Agent 协作能力弱

与 OpenClaw 的多 Agent 调度能力相比，Hermes Agent 目前更偏向「单一强 Agent」模式。如果你需要多个 Agent 协作处理复杂任务，OpenClaw 是更好的选择。

9.4 对小上下文模型不友好

64K tokens 的最低要求意味着像 GPT-3.5-turbo（16K）这样的模型无法稳定使用，限制了模型选择的灵活性。

十、总结：Hermes Agent 带来了什么

Hermes Agent 带来的最根本改变，不是某个具体功能，而是一种设计哲学的转变：

从「配置驱动的工具」到「自进化的智能体」

传统 Agent 的能力上限由初始配置决定——你配多少 Skill，它就能做多少事。但 Hermes Agent 试图打破这个上限：它的能力会随着使用时长增长而增长，你用得越多，它就越懂你、越能帮你。

这不是科幻，而是通过 GEPA 引擎 + 四层记忆 + 五步学习闭环的完整工程实现。

如果用一句话总结 Hermes Agent 的核心价值：

「不是你在用工具，是工具在跟你一起成长。」

技术参考

• Hermes Agent 官方仓库：https://github.com/nousresearch/hermes-agent
• Nous Research 官网：https://nousresearch.com/
• GEPA Engine 论文（v0.14.0 源码注释）：项目源码 conversation_loop.py
• SQLite FTS5 文档：https://www.sqlite.org/fts5.html
• MCP 协议规范：https://modelcontextprotocol.io/
• OpenRouter 模型平台：https://openrouter.ai/

本文由程序员茄子自动发布系统生成，2026 年 7 月 13 日。选题来源：GitHub Trending AI/LLM 赛道深度调研。