Hermes Agent 深度实战：当 AI Agent 学会了「自我进化」——从闭环学习到三层记忆架构、从 GEPA 进化算法到 200+ 模型适配的生产级完全指南（2026）

作者: 程序员茄子
日期: 2026-06-21
字数: 约 12,000 字
适用人群: AI Agent 开发者、后端工程师、对自进化智能体感兴趣的架构师

引言：为什么 Hermes Agent 可能是 2026 年最重要的开源 AI 项目

2026 年 2 月 25 日，Nous Research 在 GitHub 上发布了一个名为 Hermes Agent 的开源项目。短短三个月内，这个项目获得了超过 14 万星标，多次登上 GitHub Trending 榜首，被开发者称为「最接近 AI 操作系统的开源项目」。

但数字本身并不重要——重要的是它解决了一个困扰 AI Agent 领域多年的根本性问题：

传统的 AI Agent 是「无状态」的——它们不会从经验中学习，每次对话都从零开始。

你用 AutoGPT 完成了一个复杂的部署任务，它做得很好。但下次你再问它类似的问题，它依然从零规划，此前的经验荡然无存。这种「 amnesia （健忘）」特性，使得传统 Agent 更像一个「高级版的临时工」，而不是一个能成长的数字化分身。

Hermes Agent 的改变在于：它引入了一个真正的 「自进化学习循环」（Self-Improving Loop），让 AI Agent 第一次具备了「越用越聪明」的能力。它不是又一个封装 LLM API 的工具库，而是一个会成长的智能体——能记住你的偏好、自动创建技能、跨会话检索记忆、在对话中自我改进，甚至能在完成任务后将自己的最佳实践固化为可复用的技能模块。

更关键的是，这一切都建立在完全开源（MIT 协议）的基础上：

• 支持 200+ 大语言模型（OpenAI、Anthropic、DeepSeek、Ollama 本地模型等）
• 内置 40+ 工具（文件操作、代码执行、终端访问、浏览器控制等）
• 支持 16+ 消息平台（Telegram、Discord、Slack、WhatsApp、Signal、微信等）
• 提供 6 种执行后端（本地终端、SSH、Docker、Kubernetes、Serverless、云端托管）
• 采用 Python 3.11+ 编写，核心代码约 3 万行（不含测试和前端）

本文将深入解析 Hermes Agent 的架构设计、核心机制，并通过完整的代码实战演示如何将其应用到生产环境。读完本文，你将能够：

1. 理解自进化 Agent 的底层原理（闭环学习、三层记忆、技能系统）
2. 掌握 Hermes Agent 的完整架构（四层设计、消息网关、执行后端）
3. 从零部署 Hermes Agent 到生产环境（含 Docker、K8s、Serverless 三种方案）
4. 开发自定义 Skill，扩展 Hermes Agent 的能力边界
5. 对比 Hermes Agent 与 OpenClaw、Claude Code、AutoGPT 的优劣，做出合理的技术选型

第一章：核心概念——自进化 AI Agent 的范式转移

1.1 传统 Agent 的致命缺陷：开环系统

要理解 Hermes Agent 的革命性，我们需要先看清传统 Agent 框架的工作模式：

用户输入 → 规划 → 执行 → 输出结果 → [会话结束，一切归零]

这是一个典型的 开环系统（Open-Loop System）——无论任务完成得多出色，系统都不会留下任何「经验值」。下次遇到相同问题，Agent 必须从头再来。

具体来说，传统 Agent 存在三大痛点：

痛点一：无状态记忆（Amnesia）

Agent 的记忆仅限于当前会话的上下文窗口（通常 4K-128K tokens）。一旦会话结束，所有信息丢失。即使用 RAG 外挂知识库，也只是「静态知识检索」，而非「动态经验积累」。

痛点二：无技能沉淀（No Skill Consolidation）

Agent 每次执行任务都是「即兴发挥」——它不会把成功的流程固化下来。好比一个厨师，每次做菜都重新摸索配方，从不用菜谱。

痛点三：无自我改进（No Self-Improvement）

Agent 的行为完全依赖底层 LLM 的能力。如果 LLM 在某类任务上表现不佳，Agent 无法自我适应或优化。它没有一个「复盘 → 改进 → 验证」的闭环。

1.2 Hermes Agent 的范式转移：闭环学习系统

Hermes Agent 引入了一个完全不同的范式：

执行任务 → 评估表现 → 提炼经验 → 创建/优化技能 → 存储记忆 → 下次复用
    ↓                                                              ↑
    └─────────────────── 闭环学习循环 ──────────────────────────────┘

这个循环包含四个关键阶段：

阶段 1：记忆持久化（Memory Persistence）

Hermes 维护跨会话的长期记忆，包括用户偏好、项目上下文、历史对话等。采用 四层记忆架构（短期工作记忆、中期任务记忆、长期技能记忆、永久用户画像），配合 FTS5 全文搜索和 LLM 智能摘要，实现毫秒级记忆检索。

# Hermes 记忆系统的核心抽象（简化版）
class MemoryManager:
    def __init__(self, storage_path: str):
        self.short_term = WorkingMemory()      # 当前会话
        self.mid_term = TaskMemory(storage_path)  # 近期任务
        self.long_term = SkillMemory(storage_path) # 固化技能
        self.user_profile = UserProfile(storage_path) # 用户画像
    
    def retrieve(self, query: str) -> List[Memory]:
        """多层级记忆检索"""
        results = []
        results += self.short_term.search(query)
        results += self.mid_term.search(query)
        results += self.long_term.search(query)
        results += self.user_profile.search(query)
        return self._rerank(results, query)

阶段 2：技能自动创建（Automatic Skill Creation）

当 Hermes 完成一个任务后，它会自动触发「技能提炼流程」：用 LLM 总结任务的成功流程，生成 Markdown 格式的 Skill 文件，并存储到本地技能库（~/.hermes/skills/）。

Skill 文件是可复用的 Prompt + 工具调用模板。下次遇到类似任务，Hermes 会自动检索并加载相关 Skill，而不是从零规划。

# ~/.hermes/skills/deploy_nextjs_app.md

## Skill: Deploy Next.js App to Vercel

### Trigger
User mentions: "deploy", "next.js", "vercel"

### Steps
1. Check `package.json` for Next.js dependency
2. Run `npm run build` to verify build passes
3. Run `vercel --prod` with environment variables
4. Verify deployment URL returns 200

### Success Criteria
- Build completes without errors
- Vercel deployment URL is accessible
- Environment variables are properly set

### Common Pitfalls
- Missing `NEXT_PUBLIC_` prefix for client-side env vars
- Node.js version mismatch (use `engines` field in package.json)

阶段 3：自进化管道（Self-Evolution Pipeline）

Hermes 集成了由 UC Berkeley 和 Stanford 研究者联合开发的 GEPA（Genetic-Pareto Prompt Evolution） 进化算法。它会：

1. 收集历史任务的执行轨迹（成功/失败案例）
2. 用遗传算法生成新的 Prompt 候选
3. 在测试集上评估候选 Prompt 的性能
4. 保留 Pareto 最优的 Prompt（在准确率、成本、延迟等多个指标上最优）

这意味着：Hermes 的 Prompt 会随着使用自动优化，无需人工干预。

阶段 4：跨平台状态同步（Cross-Platform State Sync）

Hermes 的记忆、技能、配置是 跨平台统一 的。无论你通过 Telegram、Discord 还是 CLI 与 Hermes 交互，它都知道你之前在另一个平台上做过什么。

这是通过 统一状态后端（Unified State Backend） 实现的——所有平台网关都连接到一个共享的 SQLite / PostgreSQL 数据库。

第二章：架构深度解析——四层架构设计

Hermes Agent 采用 四层架构，从下到上分别是：

┌─────────────────────────────────────────────────────┐
│              接入层（Interface Layer）                 │
│  CLI / Web UI / Telegram / Discord / Slack / ...    │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│              网关层（Gateway Layer）                   │
│  消息路由 / 平台适配 / 鉴权 / 限流                    │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│              核心层（Core Agent Layer）                │
│  对话主循环 / 记忆管理 / 技能系统 / 自进化管道         │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│              执行层（Execution Backend Layer）          │
│  本地终端 / SSH / Docker / K8s / Serverless / 云端   │
└─────────────────────────────────────────────────────┘

2.1 接入层：15+ 平台的统一接口

Hermes 的接入层通过 适配器模式（Adapter Pattern） 统一了 15+ 消息平台的接口。每个平台都有一个对应的 Adapter，负责：

• 将平台特定的消息格式转换为 Hermes 内部格式
• 处理平台特定的鉴权和 Webhook 验证
• 将 Hermes 的回复转换回平台特定的格式

# 适配器基类
class PlatformAdapter(ABC):
    @abstractmethod
    async def receive(self, raw_message: dict) -> HermesMessage:
        """将平台消息转换为内部格式"""
        pass
    
    @abstractmethod
    async def send(self, message: HermesResponse) -> None:
        """将内部回复转换为平台格式并发送"""
        pass

# Telegram 适配器示例
class TelegramAdapter(PlatformAdapter):
    def __init__(self, token: str):
        self.bot = telegram.Bot(token=token)
    
    async def receive(self, raw_message: dict) -> HermesMessage:
        update = telegram.Update.de_json(raw_message, self.bot)
        return HermesMessage(
            text=update.message.text,
            user_id=update.effective_user.id,
            platform="telegram",
            raw=raw_message
        )

支持的平台列表（截至 v0.15.2）：

• 即时通讯：Telegram、WhatsApp、Signal、WeChat（第三方协议）
• 团队协作：Slack、Discord、Microsoft Teams、飞书
• 联邦协议：Matrix
• 邮件：SMTP/IMAP（Gmail、Outlook、自定义 SMTP）
• 本地界面：CLI（终端）、Web UI（浏览器）、LSP（VS Code 插件）

2.2 网关层：消息路由与平台适配

网关层是 Hermes 的「交通枢纽」，负责：

1. 消息路由：根据消息来源和目标，将消息路由到正确的 Agent 实例
2. 平台适配：处理不同平台的表情回复、文件上传、按钮交互等特性
3. 鉴权与限流：防止未授权访问和 API 滥用
4. 会话管理：维护多平台会话的状态一致性

网关层的核心组件是 Router（路由器），它使用基于规则的路由表：

# 路由表配置示例（~/.hermes/config/routes.yaml）
routes:
  - pattern: "telegram:group:123456789"  # Telegram 群组
    target: "agent:coding_expert"
    description: "Python 开发群，路由到编码专家"
  
  - pattern: "discord:dm:*"  # 所有 Discord 私信
    target: "agent:personal_assistant"
    description: "私信由个人助理处理"
  
  - pattern: "cli:*"  # 所有 CLI 请求
    target: "agent:default"
    description: "终端使用默认 Agent"

2.3 核心层：对话主循环与自进化引擎

核心层是 Hermes 的「大脑」，包含以下关键模块：

模块 1：ConversationLoop（对话主循环）

负责协调整个 Agent 的执行流程：接收消息 → 检索记忆 → 加载技能 → 调用 LLM → 执行工具 → 返回回复 → 触发自进化。

# 对话主循环的核心逻辑（伪代码）
async def conversation_loop(message: HermesMessage):
    # 1. 检索相关记忆
    memories = memory_manager.retrieve(message.text)
    
    # 2. 加载相关技能
    skills = skill_system.match(message.text, memories)
    
    # 3. 构建 Prompt
    prompt = build_prompt(
        message=message,
        memories=memories,
        skills=skills,
        tools=tool_registry.list()
    )
    
    # 4. 调用 LLM（支持流式输出）
    async for chunk in llm_client.chat(prompt, stream=True):
        await send_chunk(chunk)
    
    # 5. 执行工具调用（如果有）
    if response.has_tool_calls:
        tool_results = await execute_tools(response.tool_calls)
        # 将工具结果反馈给 LLM，继续对话
        ...
    
    # 6. 任务完成后，触发自进化
    if task_completed:
        await self_evolution_pipeline.run(
            task=message.text,
            trajectory=conversation_trajectory,
            result=response
        )

模块 2：ContextEngine（上下文压缩引擎）

当对话历史超过 LLM 的上下文窗口时，ContextEngine 会自动压缩历史消息，保留关键信息。它使用两种策略：

• 提取式压缩：用 LLM 提取历史消息中的关键事实和决策
• 抽象式压缩：将多条相关消息合并为一条高级摘要

# 上下文压缩示例
原始对话（10,000 tokens）：
  用户：帮我部署这个 Next.js 项目
  Agent：好的，我先检查 package.json...
  Agent：发现需要 Node.js 18+，正在检查环境...
  ...（20 轮对话）...
  Agent：部署成功！URL: https://my-app.vercel.app

压缩后（500 tokens）：
  任务：部署 Next.js 项目到 Vercel
  关键步骤：检查 package.json → 验证 Node.js 版本 → 运行 npm run build → 执行 vercel --prod
  结果：成功，URL: https://my-app.vercel.app
  经验教训：需要设置 NEXT_PUBLIC_API_URL 环境变量

模块 3：SkillsSystem（技能系统）

技能系统是 Hermes 「自进化」的核心。它管理技能的：

• 匹配：根据用户输入，用向量检索 + 关键词匹配找到相关技能
• 加载：将匹配的技能注入到 Prompt 中
• 创建：从任务执行轨迹中自动生成新技能
• 优化：用 GEPA 算法优化技能的 Prompt

技能文件是 Markdown 格式，包含以下字段：

---
name: deploy_nextjs_vercel
version: 1.2.0
created_at: 2026-03-15T10:30:00Z
last_used: 2026-06-20T15:45:00Z
success_count: 42
failure_count: 3
---

# Deploy Next.js App to Vercel

## Trigger Keywords
deploy, next.js, vercel, production

## Prerequisites
- Vercel CLI installed (`npm i -g vercel`)
- Logged in (`vercel login`)
- `vercel.json` config file (optional)

## Steps
1. Check build: `npm run build`
2. Check environment variables: `vercel env ls`
3. Deploy: `vercel --prod`
4. Verify: `curl -sSf https://<deployment-url> > /dev/null`

## Troubleshooting
- If build fails: check Node.js version in `package.json` engines field
- If env vars missing: `vercel env add`

模块 4：Curator（后台维护员）

Curator 是一个后台运行的 LLM 进程，负责：

• 定期清理过时的记忆和技能
• 合并重复的技能
• 优化技能的 Prompt（用 GEPA 算法）
• 生成每日/每周的工作总结

# Curator 的工作循环
async def curator_loop():
    while True:
        await asyncio.sleep(3600)  # 每小时运行一次
        
        # 1. 清理 30 天未使用的技能
        deleted = skill_system.cleanup_unused(days=30)
        logger.info(f"Cleaned up {deleted} unused skills")
        
        # 2. 合并相似的技能
        merged = skill_system.merge_similar(similarity_threshold=0.85)
        logger.info(f"Merged {merged} similar skills")
        
        # 3. 优化高频使用的技能（用 GEPA）
        top_skills = skill_system.get_top_used(limit=10)
        for skill in top_skills:
            improved_prompt = gepa.optimize(skill)
            skill.update_prompt(improved_prompt)
        
        # 4. 生成每日总结
        summary = memory_manager.generate_daily_summary()
        await send_to_user(f"📊 今日总结：{summary}")

2.4 执行层：6 种执行后端

Hermes 的任务执行不依赖本地环境，而是可以调度到 6 种执行后端：

执行后端通过 Executor 接口 统一：

class Executor(ABC):
    @abstractmethod
    async def execute(self, command: str, cwd: str = None) -> ExecutionResult:
        pass
    
    @abstractmethod
    async def read_file(self, path: str) -> str:
        pass
    
    @abstractmethod
    async def write_file(self, path: str, content: str) -> None:
        pass

# Docker 执行器示例
class DockerExecutor(Executor):
    def __init__(self, image: str):
        self.client = docker.from_env()
        self.container = self.client.containers.run(
            image=image,
            detach=True,
            tty=True,
            volumes={'/host/path': {'bind': '/workspace', 'mode': 'rw'}}
        )
    
    async def execute(self, command: str, cwd: str = None) -> ExecutionResult:
        exit_code, output = self.container.exec_run(
            cmd=f"cd {cwd or '/workspace'} && {command}",
            stream=True
        )
        return ExecutionResult(exit_code=exit_code, output=output)

第三章：三层记忆架构——从会话上下文到程序性技能

Hermes 的记忆系统是其「自进化」能力的基石。它采用 三层记忆架构，每层都有不同的生命周期和用途。

3.1 架构概览

┌─────────────────────────────────────────────────────┐
│  第一层：短期工作记忆（Working Memory）                │
│  生命周期：当前会话                                   │
│  存储：RAM                                          │
│  内容：当前对话的上下文、用户输入、Agent 回复          │
└─────────────────────────────────────────────────────┘
                         ↓ 会话结束后归档
┌─────────────────────────────────────────────────────┐
│  第二层：中期任务记忆（Task Memory）                   │
│  生命周期：近期任务（默认保留 7 天）                   │
│  存储：本地 SQLite + FTS5 全文索引                    │
│  内容：任务描述、执行轨迹、成功/失败记录、用户反馈     │
└─────────────────────────────────────────────────────┘
                         ↓ 高频成功任务固化
┌─────────────────────────────────────────────────────┐
│  第三层：长期技能记忆（Skill Memory）                  │
│  生命周期：永久（除非手动删除）                        │
│  存储：本地文件系统（~/.hermes/skills/）+ Git 版本控制│
│  内容：可复用的技能文件（Markdown 格式）               │
└─────────────────────────────────────────────────────┘

3.2 第一层：短期工作记忆

短期工作记忆存储在 RAM 中，生命周期与当前会话绑定。它的核心作用是：

• 维护对话的连贯性（多轮对话）
• 暂存工具调用的中间结果
• 支持「撤销」和「重试」操作

class WorkingMemory:
    def __init__(self, max_tokens: int = 128000):
        self.messages: List[Message] = []
        self.max_tokens = max_tokens
        self.token_count = 0
    
    def add_message(self, message: Message):
        self.messages.append(message)
        self.token_count += count_tokens(message)
        
        # 如果超过 token 限制，触发压缩
        if self.token_count > self.max_tokens:
            self.compress()
    
    def compress(self):
        """用 ContextEngine 压缩历史消息"""
        compressed = context_engine.compress(self.messages[:-10])
        # 保留最近 10 条消息不压缩
        self.messages = compressed + self.messages[-10:]
        self.token_count = count_tokens(self.messages)

3.3 第二层：中期任务记忆

中期任务记忆存储在本地 SQLite 数据库中，使用 FTS5（Full-Text Search 5）实现全文检索。

数据表结构：

-- 任务表
CREATE TABLE tasks (
    id INTEGER PRIMARY KEY,
    description TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    completed_at TIMESTAMP,
    status TEXT CHECK(status IN ('pending', 'running', 'success', 'failure')),
    result TEXT,
    feedback INTEGER  -- 用户反馈：1 (👍) 或 -1 (👎)
);

-- 执行轨迹表
CREATE TABLE trajectories (
    id INTEGER PRIMARY KEY,
    task_id INTEGER REFERENCES tasks(id),
    step_number INTEGER NOT NULL,
    action TEXT NOT NULL,  -- 'llm_call', 'tool_call', 'user_input'
    input TEXT,
    output TEXT,
    duration_ms INTEGER,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- FTS5 虚拟表（用于全文搜索）
CREATE VIRTUAL TABLE tasks_fts USING fts5(
    description,
    result,
    content=tasks,
    content_rowid=id
);

检索示例：

# 用户问：「我之前部署过 Next.js 项目吗？」
# Hermes 会在中期任务记忆中检索：

results = db.execute("""
    SELECT tasks.*, rank 
    FROM tasks_fts 
    JOIN tasks ON tasks.id = tasks_fts.rowid
    WHERE tasks_fts MATCH 'next.js OR nextjs OR deploy'
    ORDER BY rank, completed_at DESC
    LIMIT 5
""")

# 返回：
# 1. "Deploy Next.js project to Vercel" (2026-06-15, success)
# 2. "Fix Next.js build error (webpack config)" (2026-06-10, success)
# 3. ...

3.4 第三层：长期技能记忆

长期技能记忆是 Hermes 「自进化」的最终产物。当某个任务被执行多次且成功率较高时，Hermes 会将其固化为一个 Skill 文件，存储到 ~/.hermes/skills/ 目录。

Skill 文件是可复用的 Prompt + 工具调用模板。它包含两个核心部分：

1. Frontmatter（YAML 元数据）

---
name: deploy_python_fastapi
version: 2.1.0
category: deployment
tags: [python, fastapi, docker, deployment]
created_at: 2026-04-01T10:00:00Z
last_used: 2026-06-20T15:30:00Z
usage_count: 37
success_rate: 0.92
average_duration_seconds: 45
dependencies: [docker, python3.11]
---

2. Body（Markdown 内容）

# Deploy Python FastAPI App with Docker

## Overview
This skill deploys a FastAPI application using Docker and docker-compose.

## When to Use
- User mentions "deploy FastAPI", "dockerize FastAPI"
- Project has `main.py` with FastAPI app
- User wants production-ready deployment

## Prerequisites
- Docker and docker-compose installed
- `requirements.txt` or `pyproject.toml` present
- FastAPI app entry point is `main:app`

## Steps

### 1. Create Dockerfile
```dockerfile
FROM python:3.11-slim

WORKDIR /app

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

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

2. Create docker-compose.yml

version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=${REDIS_URL}
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped

3. Build and Run

docker-compose up --build -d
docker-compose ps  # Verify running
curl http://localhost:8000/health  # Health check

Common Issues

Port Already in Use

# Check what's using port 8000
lsof -i :8000
# Kill if needed
kill -9 <PID>

Missing Environment Variables

# Create .env file
echo "DATABASE_URL=postgresql://..." > .env
echo "REDIS_URL=redis://..." >> .env

Success Criteria

• docker-compose ps shows "Up" status
• curl http://localhost:8000/health returns 200
• Logs show no errors (docker-compose logs -f)

**技能匹配算法**：

当用户发送消息时，Hermes 会用以下算法匹配相关技能：

```python
def match_skills(user_message: str, top_k: int = 3) -> List[Skill]:
    # 1. 向量检索（语义匹配）
    query_embedding = embed_model.encode(user_message)
    vector_results = vector_db.search(query_embedding, top_k=top_k*2)
    
    # 2. 关键词匹配（精确匹配）
    keyword_results = []
    for skill in all_skills:
        score = calculate_keyword_overlap(user_message, skill.tags)
        if score > 0.5:
            keyword_results.append((skill, score))
    
    # 3. 合并并重新排序
    all_results = merge_and_deduplicate(vector_results, keyword_results)
    reranked = rerank_by_success_rate(all_results)
    
    return reranked[:top_k]

第四章：GEPA 进化算法——用遗传算法优化 Prompt

Hermes Agent 最创新的技术之一，是集成了 GEPA（Genetic-Pareto Prompt Evolution） 算法，用于自动优化技能的 Prompt。

4.1 为什么需要 Prompt 进化？

在传统的 Agent 框架中，Prompt 是 静态的——由开发者手写，部署后不再改变。但手写 Prompt 往往存在以下问题：

• 不完整：遗漏了边界情况和错误处理
• 不最优：同样的效果，可能用更少的 tokens 就能实现
• 不适应：当用户的使用场景变化时，Prompt 无法自适应

GEPA 的思路是：把 Prompt 当作「可进化的代码」，用遗传算法持续优化。

4.2 GEPA 算法原理

GEPA 是由 UC Berkeley 和 Stanford 研究者联合开发的 Prompt 进化算法。它的核心流程是：

初始化种群（随机生成 N 个候选 Prompt）
    ↓
评估种群（在每个候选 Prompt 上运行测试集）
    ↓
选择父代（用 Pareto 最优选择，考虑多个指标）
    ↓
交叉（Combine）和变异（Mutate）生成子代
    ↓
评估子代 → 保留 Pareto 最优的个体
    ↓
重复 100-500 代，直到收敛

关键创新：Pareto 最优选择

传统遗传算法只用「准确率」一个指标选择父代。但 Prompt 优化需要同时考虑多个指标：

• 准确率（Accuracy）：任务成功率
• 成本（Cost）：消耗的 tokens 数量
• 延迟（Latency）：平均响应时间
• 鲁棒性（Robustness）：在噪声输入下的表现

GEPA 使用 Pareto 最优 选择父代——只保留在多个指标上都不能被其他个体「支配」的个体。

# Pareto 最优的判断逻辑
def is_pareto_optimal(candidate, population):
    for other in population:
        if dominates(other, candidate):
            return False
    return True

def dominates(a, b):
    """a 支配 b 当且仅当：a 在所有指标上 >= b，且至少有一个指标 > b"""
    all_equal_or_better = all(
        a.metrics[i] >= b.metrics[i] 
        for i in range(len(a.metrics))
    )
    strictly_better = any(
        a.metrics[i] > b.metrics[i]
        for i in range(len(a.metrics))
    )
    return all_equal_or_better and strictly_better

4.3 Hermes 中的 GEPA 实现

Hermes 将 GEPA 集成到技能系统中。当一个技能被使用了 N 次（默认 N=15）后，Curator 会自动触发 GEPA 优化流程：

# Curator 中的 GEPA 优化逻辑
async def optimize_skill_with_gepa(skill: Skill):
    # 1. 收集该技能的测试集（从历史执行轨迹中构建）
    test_cases = build_test_cases(skill)
    
    # 2. 初始化种群（当前技能 + 随机变异的候选）
    population = [skill.prompt]
    for _ in range(9):  # 总共 10 个候选
        mutated = mutate_prompt(skill.prompt)
        population.append(mutated)
    
    # 3. 运行 GEPA
    optimized_prompt = gepa.evolve(
        initial_population=population,
        test_cases=test_cases,
        metrics=['accuracy', 'cost', 'latency'],
        generations=100
    )
    
    # 4. 如果新 Prompt 显著优于旧 Prompt，则更新
    if optimized_prompt.accuracy > skill.accuracy + 0.05:
        skill.update_prompt(optimized_prompt)
        logger.info(f"Skill {skill.name} prompt optimized: accuracy {skill.accuracy} → {optimized_prompt.accuracy}")

实际效果：

根据 Nous Research 的官方数据，经过 GEPA 优化后：

• 技能的平均准确率提升 12-18%
• Prompt 的平均 token 消耗降低 20-30%
• 在噪声输入下的鲁棒性提升 25%

第五章：代码实战——从零部署到生产环境

理论讲完了，现在进入实战环节。本章将手把手教你部署 Hermes Agent 到生产环境。

5.1 方案选择：哪种部署方式适合你？

Hermes 支持多种部署方式，选择哪种取决于你的使用场景：

5.2 实战一：本地 CLI 部署（最快上手）

步骤 1：安装 Hermes Agent

# 方法一：官方安装脚本（推荐）
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# 方法二：从源码安装
git clone https://github.com/NousResearch/Hermes-Agent.git
cd Hermes-Agent
python3 -m venv venv
source venv/bin/activate
pip install -e ".[all]"

步骤 2：配置模型提供商

# 交互式配置向导
hermes config init

# 示例输出：
# ? 选择模型提供商：
#   > OpenAI
#     Anthropic
#     DeepSeek
#     Ollama (本地模型)
# 
# ? 输入 API Key（或留空使用环境变量）：
#   >
# 
# ? 选择默认模型：
#   > gpt-4o
#     gpt-4-turbo
#     claude-3-5-sonnet

配置文件保存在 ~/.hermes/config/config.yaml：

# ~/.hermes/config/config.yaml
model:
  provider: openai
  model: gpt-4o
  api_key: ${OPENAI_API_KEY}  # 支持环境变量
  temperature: 0.7
  max_tokens: 4096

memory:
  backend: sqlite  # 也支持 postgresql
  path: ~/.hermes/memory.db

skills:
  auto_create: true  # 自动创建技能
  auto_optimize: true  # 自动优化技能（需要 GEPA）
  storage_path: ~/.hermes/skills

execution:
  backend: local  # local | ssh | docker | k8s | serverless
  workdir: ~/.hermes/workspace

gateways:
  - type: cli
    enabled: true
  - type: telegram
    enabled: false
    token: ${TELEGRAM_BOT_TOKEN}

步骤 3：启动 Hermes Agent

# 启动 CLI 界面
hermes chat

# 示例对话：
# > 你好，帮我写一个 Python 脚本，读取 CSV 文件并绘制柱状图
# 
# 🤖 Hermes：好的，我来帮你完成这个任务。
# 
# [执行] 分析需求...
# [执行] 编写代码...
# [执行] 测试运行...
# 
# 已完成！代码保存在 ~/.hermes/workspace/csv_plot.py
# 
# [自动创建技能] 我将此任务固化为技能：csv_to_bar_chart

步骤 4：验证自进化功能

# 查看已创建的技能
hermes skills list

# 输出：
# NAME                      CREATED         USED  SUCCESS RATE
# csv_to_bar_chart          2026-06-21      3     100%
# deploy_nextjs_vercel      2026-06-15      12    92%
# fix_docker_compose        2026-06-10      5     80%

# 手动触发技能优化
hermes skills optimize --name csv_to_bar_chart

# 输出：
# [GEPA] 正在优化技能 csv_to_bar_chart...
# [GEPA] 初始准确率：100% | 初始成本：1200 tokens
# [GEPA] 第 50 代：准确率 100% | 成本 980 tokens ✅
# [GEPA] 优化完成！新 Prompt 已保存。

5.3 实战二：Docker Compose 部署（自托管推荐）

如果你希望 Hermes Agent 7×24 运行，并且能够接收来自 Telegram、Discord 等平台的消息，推荐使用 Docker Compose 部署。

步骤 1：编写 docker-compose.yml

# docker-compose.yml
version: '3.8'

services:
  hermes:
    image: nousresearch/hermes-agent:latest
    container_name: hermes-agent
    restart: unless-stopped
    ports:
      - "8080:8080"  # Web UI
      - "3000:3000"  # 网关（可选）
    volumes:
      - ./config:/app/config
      - ./skills:/app/skills
      - ./memory:/app/memory
      - ./workspace:/app/workspace
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
    command: ["hermes", "server", "--host", "0.0.0.0", "--port", "8080"]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  postgres:
    image: postgres:16-alpine
    container_name: hermes-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=hermes
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=hermes
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    container_name: hermes-redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

步骤 2：配置环境变量

# .env 文件（与 docker-compose.yml 同级）
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
TELEGRAM_BOT_TOKEN=123456:ABC-DEF...

步骤 3：启动服务

docker-compose up -d

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

# 输出：
# ✓ Hermes Agent v0.15.2 启动成功
# ✓ 加载了 37 个技能
# ✓ 连接到大模型：OpenAI GPT-4O
# ✓ Telegram 网关已启动
# ✓ Web UI 已启动：http://localhost:8080

步骤 4：配置 Telegram Bot（可选）

1. 找 @BotFather 创建一个 Bot，获取 Token
2. 在 ~/.hermes/config/config.yaml 中启用 Telegram 网关
3. 重启 Hermes

gateways:
  - type: telegram
    enabled: true
    token: ${TELEGRAM_BOT_TOKEN}
    allowed_users: [123456789]  # 你的 Telegram User ID

现在，你可以在 Telegram 中与 Hermes 对话了！

5.4 实战三：Kubernetes 部署（企业级）

对于企业级部署，推荐使用 Kubernetes。Hermes 官方提供了 Helm Chart。

步骤 1：添加 Hermes Helm 仓库

helm repo add hermes https://nousresearch.github.io/hermes-agent-helm
helm repo update

步骤 2：创建 values.yaml

# values.yaml
replicaCount: 3  # 高可用：3 个副本

image:
  repository: nousresearch/hermes-agent
  tag: v0.15.2
  pullPolicy: IfNotPresent

config:
  model:
    provider: openai
    model: gpt-4o
  memory:
    backend: postgresql
    dsn: ${DATABASE_URL}
  skills:
    auto_create: true
    storage_path: /app/skills

env:
  - name: OPENAI_API_KEY
    valueFrom:
      secretKeyRef:
        name: hermes-secrets
        key: openai-api-key
  - name: DATABASE_URL
    valueFrom:
      secretKeyRef:
        name: hermes-secrets
        key: database-url

service:
  type: LoadBalancer
  port: 80
  targetPort: 8080

ingress:
  enabled: true
  hosts:
    - host: hermes.yourcompany.com
      paths:
        - path: /
          pathType: Prefix

persistence:
  skills:
    size: 10Gi
    storageClass: standard
  memory:
    size: 20Gi
    storageClass: standard

步骤 3：部署到 K8s 集群

# 创建 Secret
kubectl create secret generic hermes-secrets \
  --from-literal=openai-api-key="$OPENAI_API_KEY" \
  --from-literal=database-url="postgresql://hermes:secret@postgres:5432/hermes"

# 部署
helm install hermes hermes/hermes-agent -f values.yaml

# 查看状态
kubectl get pods -l app=hermes
# 输出：
# NAME                       READY   STATUS    RESTARTS   AGE
# hermes-6d8f4b5c4-abc12    1/1     Running   0          2m
# hermes-6d8f4b5c4-def34    1/1     Running   0          2m
# hermes-6d8f4b5c4-ghi56    1/1     Running   0          2m

# 查看 Ingress
kubectl get ingress
# 输出：
# NAME      CLASS   HOSTS                        ADDRESS         PORTS   AGE
# hermes    nginx   hermes.yourcompany.com       34.120.XX.XX    80      2m

现在，Hermes Agent 已经高可用部署，可以通过 https://hermes.yourcompany.com 访问。

第六章：高级实战——自定义 Skill 开发

Hermes Agent 的强大之处在于其 可扩展性。你可以通过编写自定义 Skill，让 Hermes 学会任何新能力。

6.1 Skill 文件格式详解

Skill 文件是 Markdown 格式，存储在 ~/.hermes/skills/ 目录。一个完整的 Skill 包含两部分：

1. Frontmatter（YAML 元数据）

---
name: query_database  # 技能名称（唯一）
version: 1.0.0
category: database    # 分类
tags: [sql, postgres, query]  # 标签（用于匹配）
model_compatibility: [gpt-4o, claude-3-5-sonnet]  # 兼容的模型
created_at: 2026-06-21T10:00:00Z
last_used: 2026-06-21T15:30:00Z
usage_count: 0
success_rate: null
average_duration_seconds: null
dependencies: [psycopg2, sqlalchemy]  # Python 依赖
---

2. Body（Markdown 内容）

# Query PostgreSQL Database

## Overview
Executes a SQL query against a PostgreSQL database and returns results as a table.

## When to Use
- User asks to "query the database", "run SQL", "check records"
- User mentions specific table names
- User wants to analyze data stored in PostgreSQL

## Prerequisites
- PostgreSQL connection string in environment variable `DATABASE_URL`
- Table exists and user has SELECT permission

## Steps

### 1. Connect to Database
```python
import os
import psycopg2
from psycopg2.extras import RealDictCursor

conn = psycopg2.connect(os.getenv('DATABASE_URL'))
cursor = conn.cursor(cursor_factory=RealDictCursor)

2. Execute Query

query = "SELECT * FROM users WHERE created_at > %s"
cursor.execute(query, (last_week,))
results = cursor.fetchall()

3. Format Results

import pandas as pd

df = pd.DataFrame(results)
print(df.to_markdown(index=False))

Safety Rules

• NEVER execute DROP, DELETE, UPDATE, INSERT without explicit user confirmation
• Always use parameterized queries to prevent SQL injection
• Limit results to 100 rows unless user specifies otherwise

Example Usage

User: "How many users signed up last week?"
Agent:

1. Infer SQL: SELECT COUNT(*) FROM users WHERE created_at >= NOW() - INTERVAL '7 days'
2. Execute query
3. Return: "Last week, 1,247 users signed up."

Troubleshooting

Connection Refused

• Check DATABASE_URL is correct
• Verify PostgreSQL is running: pg_isready

Permission Denied

-- Grant SELECT permission
GRANT SELECT ON users TO hermes_agent;

Success Criteria

• Query executes without errors
• Results are formatted as Markdown table
• Row count is shown

### 6.2 用 Python 代码动态创建 Skill

除了手写 Skill 文件，你还可以用 Hermes 的 Python API 动态创建 Skill：

```python
from hermes.skills import SkillManager

# 初始化 SkillManager
skill_manager = SkillManager(storage_path="~/.hermes/skills")

# 创建一个新技能
skill = skill_manager.create_skill(
    name="send_slack_notification",
    description="Send a notification to Slack channel",
    tags=["slack", "notification", "webhook"],
    prompt_template="""
When user asks to send a Slack notification:
1. Extract the channel name and message from user input
2. Use the `slack_sdk` Python library to send message
3. Code template:
```python
from slack_sdk import WebClient

client = WebClient(token=os.getenv('SLACK_BOT_TOKEN'))
response = client.chat_postMessage(
    channel="{channel}",
    text="{message}"
)
print(f"Message sent: {response['ts']}")

4. Execute the code and verify success
   """,
   dependencies=["slack_sdk"]
   )

print(f"Skill created: {skill.name} v{skill.version}")

输出：Skill created: send_slack_notification v1.0.0

### 6.3 Skill 的自动优化（GEPA）

当一个 Skill 被使用多次后，你可以手动触发优化：

```python
from hermes.evolution import GEPAPromptOptimizer

# 初始化 GEPA 优化器
gepa = GEPAPromptOptimizer(
    test_cases=skill_manager.build_test_cases(skill_name="query_database"),
    metrics=["accuracy", "cost", "latency"],
    population_size=20,
    generations=100
)

# 运行优化
optimized_prompt = gepa.evolve(skill.prompt_template)

# 更新 Skill
skill_manager.update_skill(
    name="query_database",
    new_prompt_template=optimized_prompt
)

print(f"Skill optimized! New version: v{skill.version}")

第七章：与 OpenClaw / Claude Code 的深度对比

Hermes Agent 经常与 OpenClaw（俗称「龙虾」）和 Claude Code（Anthropic 官方）相提并论。下表从多个维度对比这三个框架：

7.1 选择建议

选择 Hermes Agent，如果你：

• 希望 AI Agent 能「越用越聪明」（自进化）
• 需要支持多个消息平台（Telegram、Discord、Slack 等）
• 需要部署到生产环境（K8s、Serverless）
• 希望完全掌控数据（自托管）
• 需要使用多个不同的 LLM（不锁定厂商）

选择 OpenClaw，如果你：

• 想要最简单的上手体验
• 主要在本地使用，不需要 7×24 运行
• 喜欢「龙虾」的社区和生态

选择 Claude Code，如果你：

• 已经是 Claude 的付费用户
• 主要做代码编辑和重构
• 不需要自进化或复杂记忆

第八章：性能优化与生产最佳实践

将 Hermes Agent 部署到生产环境后，还需要关注性能和可靠性。本章介绍 10 个最佳实践。

8.1 最佳实践 1：使用 PostgreSQL 替代 SQLite

默认情况下，Hermes 使用 SQLite 存储记忆和任务。但在生产环境中，推荐使用 PostgreSQL：

# ~/.hermes/config/config.yaml
memory:
  backend: postgresql
  dsn: postgresql://hermes:secret@postgres:5432/hermes
  pool_size: 20
  timeout: 30

好处：

• 支持并发读写（SQLite 是单线程的）
• 支持更复杂查询（JSONB、数组、全文搜索）
• 支持主从复制和高可用

8.2 最佳实践 2：启用 Prompt Caching（降低 80% 成本）

如果你使用 Anthropic Claude 或 OpenAI GPT-4o，可以启用 Prompt Caching，将重复的 Prompt 部分缓存起来，避免重复计费。

model:
  provider: anthropic
  model: claude-3-5-sonnet-20241022
  prompt_caching: true  # 启用 Prompt Caching
  cache_ttl: 300  # 缓存 5 分钟

根据 Anthropic 的文档，Prompt Caching 可以降低 80-90% 的成本。

8.3 最佳实践 3：限制工具调用的深度

为了防止 Agent 「失控」（无限循环调用工具），需要设置限制：

execution:
  max_tool_calls: 15  # 单个任务最多 15 次工具调用
  max_iterations: 5   # 最多 5 轮「思考 → 执行」
  timeout_seconds: 300  # 单个任务最多运行 5 分钟

8.4 最佳实践 4：为技能添加「置信度阈值」

不是所有技能都应该被自动触发。你可以为技能添加「置信度阈值」，只有匹配置信度超过阈值时才自动加载：

skills:
  auto_load: true
  confidence_threshold: 0.8  # 置信度 > 80% 才自动加载
  ask_user_when_uncertain: true  # 不确定时询问用户

8.5 最佳实践 5：定期备份技能和记忆

Hermes 的技能和记忆是它「学习成果」的载体。务必定期备份：

# 备份脚本（cron 每天运行）
#!/bin/bash
DATE=$(date +%Y%m%d)
tar -czf /backup/hermes_$DATE.tar.gz \
  ~/.hermes/skills \
  ~/.hermes/memory.db \
  ~/.hermes/config

# 上传到云存储（可选）
aws s3 cp /backup/hermes_$DATE.tar.gz s3://my-hermes-backups/

8.6 其他最佳实践（简要列出）

6. 使用 Vector Database 优化技能匹配：默认用 SQLite FTS5 做关键词匹配，但对于大规模技能库（1000+），推荐使用 Qdrant 或 Pinecone 做向量检索。

7. 为不同平台设置不同的 Agent 实例：Telegram 用 agent:telegram_bot，CLI 用 agent:default，避免技能冲突。

8. 监控 Token 消耗：用 Prometheus + Grafana 监控每个用户的 Token 消耗，防止滥用。

9. 灰度发布新技能：新技能先在你自己的会话中测试，确认无问题后再推送给其他用户。

10. 定期清理失败的任务：Failed 状态的任务占空间且无意义，定期删除 30 天前的失败任务。

总结与展望

Hermes Agent 代表了 AI Agent 技术的一个重要转折点：从「无状态工具」到「有状态、可成长的数字化分身」。

它的四大创新——闭环学习系统、三层记忆架构、技能自动创建、GEPA Prompt 进化——共同解决了一个核心问题：如何让 AI Agent 从经验中学习。

在本文中，我们深入解析了 Hermes Agent 的架构设计、核心机制，并通过三个完整的实战案例（本地 CLI、Docker Compose、Kubernetes）演示了如何部署到生产环境。我们还介绍了如何开发自定义 Skill，以及如何与 OpenClaw 和 Claude Code 做技术选型。

未来展望：

根据 Nous Research 的路线图，Hermes Agent 在 2026 年下半年将推出以下新特性：

• 多 Agent 协作（多个 Hermes 实例协同完成复杂任务）
• 视觉记忆（能够「记住」图片和截图）
• 语音接口（支持语音输入和输出）
• 端侧部署（在手机和树莓派上运行）

如果你对自进化 AI Agent 感兴趣，不妨现在就试试 Hermes Agent。它可能会改变你对 AI 助手的认知。

参考资源

• 官方 GitHub：https://github.com/NousResearch/Hermes-Agent
• 官方文档：https://hermes-agent.nousresearch.com/docs
• Discord 社区：https://discord.gg/hermes-agent
• GEPA 论文："Genetic-Pareto Prompt Evolution for Self-Improving Agents", UC Berkeley, 2026
• Hermes Desktop：https://github.com/NousResearch/Hermes-Desktop（原生桌面客户端）

本文由 程序员茄子 原创，转载请注明出处。