Hermes Agent 深度拆解：从「越用越聪明」的自进化机制，到 Honcho 协议的四层记忆架构——一个能沉淀技能的数字员工是如何炼成的
引言：当 AI 不再「健忘」
你有没有遇到过这样的场景：和 Claude 聊了一个小时的项目方案，第二天再问同样的问题，它完全不记得昨天说过什么。或者让 AI 帮你写代码，每次都要重新解释项目结构、技术栈、命名规范——就像每次都在教一个新同事。
这不是 AI 的能力问题，而是架构问题。主流对话型 AI 是无状态的：每次对话都是独立的，没有持久化记忆，更谈不上「成长」。
2026 年 2 月，Nous Research 开源的 Hermes Agent 打破了这一范式。它不是聊天机器人，而是一个自主进化的数字员工——完成任务后自动沉淀可复用技能，通过四层记忆系统跨会话召回经验，运行时间越长，能力越强。
发布 7 周，GitHub Stars 突破 9.5 万，成为同期增长最快的开源 Agent 项目。它凭什么？核心答案是：闭环学习系统。
本文将深度拆解 Hermes Agent 的技术架构，从自进化机制到四层记忆系统，从 Honcho 协议到 Skills Hub，完整剖析一个「会学习」的 AI 是如何炼成的。
一、Hermes Agent 是什么：重新定义 AI 的「工作方式」
1.1 定位：不是聊天机器人，是数字员工
Hermes Agent 的官方定义是：开源、自托管、会自我进化的 AI 智能体框架。
核心差异：
| 特性 | 传统聊天机器人 | Hermes Agent |
|---|---|---|
| 状态管理 | 无状态，每次对话独立 | 有状态，跨会话持久化 |
| 记忆能力 | 短期上下文窗口 | 四层记忆系统 |
| 技能积累 | 无 | 自动沉淀可复用技能 |
| 进化机制 | 无 | 闭环学习系统 |
| 部署方式 | 云端 API | 本地/自托管/云原生 |
用一个比喻：传统 AI 是「临时工」，每次干活都要重新交代背景；Hermes Agent 是「老员工」，越干越熟，知道你的习惯、项目的坑、最佳实践的套路。
1.2 核心价值：三大能力栈
Hermes Agent 的能力覆盖三大场景：
- 个人助手：记住你的偏好、日程、联系人，自动执行重复任务
- 开发协作：理解项目代码库，沉淀代码规范、架构决策、踩坑记录
- 自动化运维：学习故障排查流程，积累运维 SOP，自动响应告警
核心能力栈：
- 学习闭环（Learning Loop）：完成任务 → 抽象技能 → 持久化 → 优化迭代
- 四层记忆系统：长期记忆、用户画像、技能库、全量历史
- 多平台统一网关：CLI / Web / Telegram / Discord / Slack / WhatsApp
- 模型无关架构：支持 OpenAI / Anthropic / Google Gemini / 千问 / Kimi 等 40+ 模型
二、技术架构：从「无状态」到「有状态」的范式转换
2.1 整体架构图
┌─────────────────────────────────────────────────────────────┐
│ Hermes Agent 架构 │
├─────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ CLI/Web │ │ Telegram │ │ Discord │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └────────────────┼────────────────┘ │
│ ▼ │
│ ┌─────────────────────────────────┐ │
│ │ Unified Message Gateway │ │
│ │ (统一消息网关 - 12+ 平台) │ │
│ └─────────────────┬───────────────┘ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Core Agent Runtime │ │
│ │ ┌─────────┐ ┌──────────┐ ┌─────────────┐ │ │
│ │ │ Planner │ │ Executor │ │ Reflector │ │ │
│ │ └─────────┘ └──────────┘ └─────────────┘ │ │
│ │ │ │ │ │ │
│ │ └────────────┼──────────────┘ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────┐ │ │
│ │ │ Learning Loop Engine │ │ │
│ │ │ (GEPA 自进化引擎) │ │ │
│ │ └───────────┬───────────────┘ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ Four-Layer Memory System │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌────────┐ ┌─────┐│ │ │
│ │ │ │MEMORY.md│ │USER.md │ │Skills/ │ │SQLite││ │ │
│ │ │ │长期记忆 │ │用户画像 │ │技能库 │ │历史 ││ │ │
│ │ │ └─────────┘ └─────────┘ └────────┘ └─────┘│ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Model Abstraction Layer │ │
│ │ OpenAI | Anthropic | Gemini | Kimi | Qwen | ... │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
2.2 核心组件解析
2.2.1 Unified Message Gateway（统一消息网关）
Hermes Agent 最大的工程创新之一：多平台统一接入。
支持的平台：
- 即时通讯：Telegram / Discord / Slack / WhatsApp / 微信
- 传统界面：CLI / Web Dashboard
- 企业集成：飞书 / 钉钉 / Microsoft Teams
技术实现：
# hermes/gateway/base.py
from abc import ABC, abstractmethod
from typing import AsyncIterator
from dataclasses import dataclass
@dataclass
class Message:
platform: str # 来源平台
user_id: str # 用户唯一标识
content: str # 消息内容
metadata: dict # 平台特定元数据
class PlatformAdapter(ABC):
"""平台适配器基类"""
@abstractmethod
async def listen(self) -> AsyncIterator[Message]:
"""监听消息流"""
pass
@abstractmethod
async def send(self, user_id: str, content: str):
"""发送回复"""
pass
@abstractmethod
async def get_user_context(self, user_id: str) -> dict:
"""获取用户上下文（如群组信息、权限等）"""
pass
# 统一网关
class UnifiedGateway:
def __init__(self):
self.adapters: dict[str, PlatformAdapter] = {}
def register(self, platform: str, adapter: PlatformAdapter):
self.adapters[platform] = adapter
async def route_message(self, msg: Message):
"""路由消息到核心 Agent"""
# 所有平台消息统一处理
context = await self.adapters[msg.platform].get_user_context(msg.user_id)
# 注入记忆系统
await self.memory.recall(msg.user_id, context)
# 触发 Agent 执行
response = await self.agent.execute(msg.content, context)
# 返回回复
await self.adapters[msg.platform].send(msg.user_id, response)
关键设计：每个平台实现 PlatformAdapter 接口，消息被标准化为 Message 对象，核心 Agent 完全不感知平台差异。
2.2.2 Core Agent Runtime
Hermes Agent 采用 Planner-Executor-Reflector 三段式执行模型：
# hermes/agent/runtime.py
class AgentRuntime:
def __init__(self, memory, tools, model):
self.planner = Planner(model, memory)
self.executor = Executor(tools, model)
self.reflector = Reflector(model)
self.learning_loop = LearningLoop()
async def execute(self, user_input: str, context: dict) -> str:
# 第一阶段：规划
plan = await self.planner.create_plan(user_input, context)
# 输出：{ "steps": [...], "required_skills": [...] }
# 第二阶段：执行
results = []
for step in plan.steps:
# 检查是否有已沉淀的技能
skill = await self.memory.find_skill(step.description)
if skill:
result = await self.executor.execute_skill(skill, step.params)
else:
result = await self.executor.execute_step(step)
results.append(result)
# 第三阶段：反思与学习
reflection = await self.reflector.reflect(
plan=plan,
results=results,
success=all(r.success for r in results)
)
# 触发学习闭环
if reflection.should_create_skill:
await self.learning_loop.create_skill(
task_description=user_input,
steps=plan.steps,
results=results,
reflection=reflection
)
return self._format_response(results, reflection)
三段式的意义：
- Planner：将模糊需求拆解为可执行步骤
- Executor：执行每一步，调用工具或已有技能
- Reflector：评估执行结果，决定是否沉淀为技能
这不是简单的「调用 API」，而是完整的任务生命周期管理。
三、核心创新：闭环学习系统
3.1 学习闭环（Learning Loop）的工作原理
Hermes Agent 的核心竞争力：自动从任务中抽象技能。
任务输入 → 规划 → 执行 → 反思 → 技能抽象 → 持久化
↑ │
└────────────── 下次任务复用 ─────────────┘
3.1.1 GEPA 引擎：自动技能生成
GEPA（Generative Experience-based Pattern Abstraction）是 Hermes Agent 的自进化引擎。
# hermes/learning/gepa.py
from dataclasses import dataclass
from typing import List
import json
@dataclass
class TaskExperience:
"""任务经验"""
user_request: str # 用户原始请求
plan_steps: List[dict] # 执行步骤
tool_calls: List[dict] # 调用的工具
outputs: List[str] # 输出结果
success: bool # 是否成功
user_feedback: str | None # 用户反馈（如有）
@dataclass
class Skill:
"""沉淀的技能"""
name: str # 技能名称
description: str # 功能描述
trigger_patterns: List[str] # 触发模式（关键词/正则）
template: dict # 执行模板
parameters: dict # 参数定义
success_rate: float # 历史成功率
usage_count: int # 使用次数
class GEPAEngine:
"""基于生成式经验抽象的技能引擎"""
async def analyze_and_abstract(self, exp: TaskExperience) -> Skill | None:
"""分析任务经验，抽象为技能"""
if not exp.success:
return None # 失败的任务不沉淀技能
# 第一步：识别模式
pattern = await self._identify_pattern(exp)
if not pattern:
return None # 过于特殊，无法抽象
# 第二步：参数化提取
params = self._extract_parameters(exp, pattern)
# 第三步：生成技能模板
template = self._generate_template(exp, params)
# 第四步：命名与描述
name = await self._generate_skill_name(exp, pattern)
description = await self._generate_description(exp, pattern)
# 第五步：触发模式生成
triggers = await self._generate_triggers(exp.user_request)
return Skill(
name=name,
description=description,
trigger_patterns=triggers,
template=template,
parameters=params,
success_rate=1.0, # 初始成功率
usage_count=0
)
async def _identify_pattern(self, exp: TaskExperience) -> dict | None:
"""识别任务模式"""
prompt = f"""
分析以下任务执行过程，判断是否包含可复用的模式：
用户请求：{exp.user_request}
执行步骤：
{json.dumps(exp.plan_steps, indent=2, ensure_ascii=False)}
工具调用：
{json.dumps(exp.tool_calls, indent=2, ensure_ascii=False)}
请回答：
1. 这个任务是否包含可复用模式？（是/否）
2. 如果是，描述这个模式的核心特征
3. 哪些部分是可变的（参数化），哪些是固定的？
"""
response = await self.model.generate(prompt)
# 解析响应，提取模式
return self._parse_pattern(response)
def _extract_parameters(self, exp: TaskExperience, pattern: dict) -> dict:
"""提取可参数化的部分"""
params = {}
for i, step in enumerate(exp.plan_steps):
# 识别步骤中的变量部分
variables = self._find_variables(step)
for var_name, var_value in variables.items():
params[var_name] = {
"type": self._infer_type(var_value),
"description": f"步骤{i+1}的{var_name}",
"default": var_value,
"required": True
}
return params
def _generate_template(self, exp: TaskExperience, params: dict) -> dict:
"""生成技能执行模板"""
template = {
"version": "1.0",
"steps": []
}
for step in exp.plan_steps:
# 将具体值替换为参数引用
parameterized_step = self._parameterize(step, params)
template["steps"].append(parameterized_step)
return template
3.1.2 技能文件的存储结构
沉淀的技能以 Markdown 文件形式存储：
# skills/deploy_to_aws.md
## 元数据
- name: deploy_to_aws
- description: 将 Docker 镜像部署到 AWS ECS
- created_at: 2026-07-31
- usage_count: 12
- success_rate: 0.92
## 触发模式
- 部署.*AWS
- ECS.*部署
- 推送到.*亚马逊
## 参数定义
```yaml
parameters:
image_name:
type: string
description: Docker 镜像名称
required: true
environment:
type: string
description: 部署环境
default: staging
enum: [staging, production]
region:
type: string
description: AWS 区域
default: us-east-1
执行模板
steps:
- action: validate_image
params:
name: ${image_name}
- action: push_to_ecr
params:
image: ${image_name}
region: ${region}
- action: update_ecs_service
params:
cluster: ${environment}-cluster
service: ${image_name}-service
image_tag: latest
注意事项
- 确保 AWS 凭证已配置
- 生产环境部署需要二次确认
**关键设计**：技能文件既是机器可读的执行模板，也是人类可读的文档。这是「可解释性」的重要体现。
### 3.2 技能复用机制
当新任务到来时，Hermes Agent 会首先搜索已有技能：
```python
# hermes/memory/skill_retrieval.py
class SkillRetriever:
def __init__(self, skills_dir: str, embedding_model):
self.skills_dir = skills_dir
self.embedder = embedding_model
self.index = self._build_index()
async def find_relevant_skill(self, user_request: str) -> Skill | None:
"""查找相关技能"""
# 第一步：关键词匹配
keyword_matches = self._keyword_search(user_request)
# 第二步：语义相似度搜索
request_embedding = await self.embedder.embed(user_request)
semantic_matches = self._semantic_search(request_embedding)
# 第三步：融合排序
candidates = self._merge_and_rank(keyword_matches, semantic_matches)
if not candidates:
return None
# 第四步：阈值过滤
best_match = candidates[0]
if best_match.score > 0.75: # 相似度阈值
return best_match.skill
return None
async def execute_skill(self, skill: Skill, user_request: str) -> str:
"""执行技能"""
# 第一步：参数提取
params = await self._extract_params_from_request(user_request, skill)
# 第二步：验证参数
validation = self._validate_params(params, skill.parameters)
if not validation.ok:
return f"参数错误：{validation.message}"
# 第三步：执行模板
results = []
for step in skill.template["steps"]:
result = await self._execute_step(step, params)
results.append(result)
# 第四步：更新技能统计
skill.usage_count += 1
# ... 保存更新
return self._format_output(results)
技能复用的意义：
- 减少重复规划：相似任务直接复用已有方案
- 积累最佳实践：成功的经验自动沉淀
- 个性化定制：技能库因用户使用习惯而异
四、四层记忆系统：从「短时记忆」到「知识库」
Hermes Agent 的记忆系统是其「越用越聪明」的根基。四层架构：
4.1 第一层：MEMORY.md（长期记忆）
存储环境事实、经验教训、重要决策。
# MEMORY.md
## 环境信息
- 操作系统：macOS 15.5 (Apple Silicon)
- Python 版本：3.11
- 常用工具：git, docker, kubectl, tmux
- 编辑器：VS Code + Claude Code
## 项目知识
- 主项目：/Users/dev/my-app (Next.js + PostgreSQL)
- API 基础 URL：https://api.my-app.dev
- 数据库连接：已配置环境变量 DATABASE_URL
## 经验教训
- 2026-07-28：部署到 AWS 时忘记更新安全组规则，导致服务无法访问
- 解决方案：在 deploy 脚本中添加安全组检查步骤
- 2026-07-25：使用 PostgreSQL 事务时忘记处理死锁
- 解决方案：在事务中添加 SET lock_timeout = '5s'
## 重要决策
- 2026-07-20：选择 Redis 作为缓存层
- 理由：团队熟悉，运维成熟，成本可控
- 替代方案：Memcached（性能相当但功能单一）
4.2 第二层：USER.md（用户画像）
存储用户偏好、工作习惯、个人目标。
# USER.md
## 基本信息
- 角色：全栈工程师
- 主要语言：TypeScript, Python
- 经验水平：5 年
- 工作风格：快速迭代，偏好自动化
## 沟通偏好
- 语言：中文为主，技术术语用英文
- 详细程度：适中，关键步骤要有解释
- 代码风格：函数式优先，避免嵌套回调
## 工作习惯
- 工作时间：10:00 - 19:00
- 响应偏好：非紧急消息异步处理
- 工具偏好：命令行 > GUI
## 当前目标
- 短期：完成项目重构（迁移到 Next.js 15）
- 中期：学习 Rust 语言
- 长期：成为独立开发者
4.3 第三层：Skills/（技能库）
自动沉淀的可复用技能集合。
skills/
├── deploy_to_aws.md
├── create_api_endpoint.md
├── write_unit_tests.md
├── review_pull_request.md
├── optimize_sql_query.md
└── debug_memory_leak.md
每个技能文件都是完整的执行方案，包含触发条件、参数定义、执行步骤、注意事项。
4.4 第四层：SQLite + FTS5（全量历史）
所有对话的全文检索索引。
-- 对话历史表
CREATE TABLE conversations (
id INTEGER PRIMARY KEY,
user_id TEXT NOT NULL,
platform TEXT NOT NULL,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
role TEXT CHECK(role IN ('user', 'assistant', 'system')),
content TEXT NOT NULL
);
-- 全文检索虚拟表
CREATE VIRTUAL TABLE conversations_fts USING fts5(
content,
tokenize='porter unicode61'
);
-- 触发器：自动同步到 FTS 索引
CREATE TRIGGER conversations_ai AFTER INSERT ON conversations BEGIN
INSERT INTO conversations_fts(rowid, content)
VALUES (new.id, new.content);
END;
查询示例：
# hermes/memory/history_search.py
import sqlite3
class HistorySearch:
def __init__(self, db_path: str):
self.conn = sqlite3.connect(db_path)
def search(self, query: str, limit: int = 10) -> list[dict]:
"""全文检索历史对话"""
cursor = self.conn.execute("""
SELECT c.id, c.timestamp, c.role, c.content
FROM conversations c
JOIN conversations_fts fts ON c.id = fts.rowid
WHERE conversations_fts MATCH ?
ORDER BY bm25(conversations_fts) -- BM25 排序
LIMIT ?
""", (query, limit))
return [
{
"id": row[0],
"timestamp": row[1],
"role": row[2],
"content": row[3]
}
for row in cursor.fetchall()
]
def recall_context(self, query: str, window_size: int = 5) -> list[dict]:
"""召回相关上下文（包含前后对话）"""
# 先找到最相关的消息
matches = self.search(query, limit=1)
if not matches:
return []
match_id = matches[0]["id"]
# 取前后 window_size 条消息
cursor = self.conn.execute("""
SELECT * FROM conversations
WHERE id BETWEEN ? AND ?
ORDER BY id
""", (match_id - window_size, match_id + window_size))
return cursor.fetchall()
4.5 四层记忆的协同工作
# hermes/memory/recall.py
class MemoryRecall:
"""四层记忆系统的统一召回接口"""
async def recall(self, user_id: str, context: dict) -> dict:
"""根据当前上下文召回相关记忆"""
# 第一步：加载用户画像（常驻内存）
user_profile = await self.load_user_profile(user_id)
# 第二步：加载长期记忆（按需）
long_term_memory = await self.load_memory_md(user_id)
# 第三步：搜索相关技能
relevant_skills = await self.search_skills(context["current_request"])
# 第四步：检索历史对话
relevant_history = await self.search_history(context["current_request"])
return {
"user_profile": user_profile,
"long_term_memory": long_term_memory,
"skills": relevant_skills,
"history": relevant_history
}
async def persist(self, user_id: str, experience: dict):
"""持久化新经验"""
# 判断是否更新长期记忆
if self._is_important(experience):
await self.update_memory_md(user_id, experience)
# 判断是否创建新技能
if experience.get("should_create_skill"):
await self.create_skill(user_id, experience)
# 始终写入历史记录
await self.append_history(user_id, experience)
四层架构的意义：
- 分层抽象：不同粒度的记忆服务于不同场景
- 高效检索：FTS5 全文索引 + 语义向量的混合搜索
- 可解释性：所有记忆都是人类可读的 Markdown 文件
五、Honcho 协议：记忆系统的通信标准
5.1 为什么需要协议？
Hermes Agent 的记忆系统需要与多个组件交互：
- 核心 Agent 运行时
- 技能执行引擎
- 外部 MCP 服务器
- 第三方工具集成
Honcho 协议定义了一套统一的接口规范，确保记忆数据在不同组件间流通。
5.2 Honcho 协议规范
# Honcho Protocol v1.0
# 基础数据类型
types:
MemoryEntry:
id: string # 唯一标识
user_id: string # 用户 ID
type: enum # [long_term, skill, history, user_profile]
content: string # 内容（Markdown 格式）
metadata: object # 元数据
created_at: datetime
updated_at: datetime
# 标准操作接口
operations:
# 查询接口
- name: recall
input:
user_id: string
query: string # 自然语言查询
type_filter: array[string] | null # 类型过滤
limit: integer
output:
entries: array[MemoryEntry]
total: integer
# 写入接口
- name: memorize
input:
user_id: string
entry: MemoryEntry
output:
id: string
status: [created, updated]
# 删除接口
- name: forget
input:
user_id: string
entry_id: string
output:
status: [deleted, not_found]
# 技能相关
- name: find_skill
input:
user_id: string
task_description: string
output:
skill: MemoryEntry | null
confidence: float
# 批量导入导出
- name: export
input:
user_id: string
format: [json, markdown, yaml]
output:
data: string
- name: import
input:
user_id: string
data: string
format: [json, markdown, yaml]
merge_strategy: [overwrite, merge, skip]
output:
imported_count: integer
errors: array[string]
5.3 协议实现示例
# hermes/protocols/honcho.py
from abc import ABC, abstractmethod
from typing import Protocol
class HonchoServer(Protocol):
"""Honcho 协议服务端"""
async def recall(
self,
user_id: str,
query: str,
type_filter: list[str] | None = None,
limit: int = 10
) -> dict:
"""召回记忆"""
...
async def memorize(self, user_id: str, entry: dict) -> dict:
"""存储记忆"""
...
async def forget(self, user_id: str, entry_id: str) -> dict:
"""删除记忆"""
...
async def find_skill(self, user_id: str, task_description: str) -> dict:
"""查找技能"""
...
class HonchoClient:
"""Honcho 协议客户端"""
def __init__(self, server_url: str):
self.server_url = server_url
async def recall(self, query: str, user_id: str = "default") -> list[dict]:
"""召回记忆"""
async with aiohttp.ClientSession() as session:
async with session.post(
f"{self.server_url}/recall",
json={"user_id": user_id, "query": query}
) as resp:
data = await resp.json()
return data["entries"]
async def memorize(
self,
content: str,
entry_type: str,
user_id: str = "default",
metadata: dict = None
) -> str:
"""存储记忆"""
async with aiohttp.ClientSession() as session:
async with session.post(
f"{self.server_url}/memorize",
json={
"user_id": user_id,
"entry": {
"type": entry_type,
"content": content,
"metadata": metadata or {}
}
}
) as resp:
data = await resp.json()
return data["id"]
协议的意义：
- 标准化接口：不同实现可以互换
- 工具生态：第三方工具可以接入 Hermes 记忆系统
- 版本演进：协议版本管理，向后兼容
六、Skills Hub：技能共享生态
6.1 Skills Hub 是什么
Skills Hub 是 Hermes Agent 的技能共享平台。用户可以：
- 发布自己沉淀的技能
- 发现和安装他人的技能
- 评分和反馈
- 版本管理
6.2 技能发布流程
# 创建技能
hermes skill create "部署到阿里云"
# 编辑技能文件
vim skills/deploy_to_aliyun.md
# 测试技能
hermes skill test deploy_to_aliyun --params '{"app_name": "my-app"}'
# 发布到 Skills Hub
hermes skill publish deploy_to_aliyun \
--name "deploy_to_aliyun" \
--description "一键部署 Docker 镜像到阿里云 ECS" \
--tags "deployment,aliyun,docker"
6.3 技能安装流程
# 搜索技能
hermes skill search "数据库迁移"
# 安装技能
hermes skill install migrate_postgres
# 查看已安装技能
hermes skill list
# 更新技能
hermes skill update migrate_postgres
6.4 技能质量评分
Skills Hub 使用多维度评分系统：
# Skills Hub 评分模型
class SkillRating:
accuracy: float # 准确性：执行成功率
completeness: float # 完整性：文档完整性
usability: float # 易用性：参数设计合理性
maintainability: float # 可维护性：模板清晰度
popularity: float # 流行度：使用次数 + 点赞数
@property
def overall_score(self) -> float:
"""综合评分"""
weights = {
"accuracy": 0.35,
"completeness": 0.20,
"usability": 0.20,
"maintainability": 0.15,
"popularity": 0.10
}
return sum(
getattr(self, attr) * weight
for attr, weight in weights.items()
)
七、实战：从零部署 Hermes Agent
7.1 环境准备
系统要求：
- Python 3.10+
- Node.js 18+（用于 CLI 工具）
- Git 2.0+
- 至少 2GB 可用内存
硬件建议：
- 最低：2 核 CPU，4GB 内存
- 推荐：4 核 CPU，8GB 内存
- 生产：8 核 CPU，16GB 内存 + SSD
7.2 安装步骤
# 克隆仓库
git clone https://github.com/NousResearch/Hermes-Agent.git
cd Hermes-Agent
# 安装依赖
pip install -e .
# 初始化配置
hermes init
# 选择模型提供商
# 支持：OpenAI / Anthropic / Kimi / Qwen / 自定义
7.3 配置模型
# ~/.hermes/config.yaml
model:
provider: anthropic
model_name: claude-opus-5-20250514
api_key: ${ANTHROPIC_API_KEY} # 从环境变量读取
# 或自定义端点
# base_url: https://your-proxy.com/v1
memory:
storage_path: ~/.hermes/memory
fts_enabled: true
tools:
builtin: true
custom_tools_dir: ~/.hermes/tools
platforms:
cli:
enabled: true
telegram:
enabled: true
bot_token: ${TELEGRAM_BOT_TOKEN}
discord:
enabled: false
7.4 启动 Agent
# CLI 模式
hermes chat
# Web Dashboard
hermes web --port 8080
# 多平台模式
hermes serve --platforms cli,telegram
7.5 第一个任务
用户: 帮我创建一个 FastAPI 项目，包含用户认证和 PostgreSQL 数据库
Hermes: 好的，我来帮你创建。首先规划一下步骤：
1. 创建项目目录结构
2. 配置依赖（FastAPI, SQLAlchemy, Pydantic, python-jose）
3. 创建数据库模型
4. 实现用户认证 API
5. 添加配置管理
开始执行...
[执行过程省略]
✅ 项目创建完成！
项目结构：
my-fastapi-app/
├── app/
│ ├── __init__.py
│ ├── main.py
│ ├── models/
│ │ └── user.py
│ ├── routers/
│ │ └── auth.py
│ ├── schemas/
│ │ └── user.py
│ └── core/
│ ├── config.py
│ └── security.py
├── requirements.txt
└── .env.example
启动命令：
uvicorn app.main:app --reload
[技能沉淀]
已创建技能：create_fastapi_project
触发词：创建 FastAPI 项目、FastAPI 脚手架
7.6 Docker 部署
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
# 安装依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# 复制代码
COPY . .
# 创建数据目录
RUN mkdir -p /data/memory /data/skills
# 环境变量
ENV HERMES_MEMORY_PATH=/data/memory
ENV HERMES_SKILLS_PATH=/data/skills
# 启动
CMD ["hermes", "serve", "--platforms", "cli,telegram"]
# docker-compose.yml
version: '3.8'
services:
hermes:
build: .
ports:
- "8080:8080" # Web Dashboard
volumes:
- ./data:/data
- ./config:/root/.hermes
environment:
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
- TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
restart: unless-stopped
八、进阶：自定义工具与 MCP 集成
8.1 自定义工具开发
Hermes Agent 支持扩展自定义工具：
# ~/.hermes/tools/my_tools.py
from hermes import tool, ToolResult
@tool(
name="query_my_database",
description="查询我的 PostgreSQL 数据库",
parameters={
"query": {
"type": "string",
"description": "SQL 查询语句（只支持 SELECT）"
}
}
)
async def query_my_database(query: str) -> ToolResult:
"""查询数据库"""
import asyncpg
# 安全检查
if not query.strip().upper().startswith("SELECT"):
return ToolResult(
success=False,
error="只允许 SELECT 查询"
)
# 连接数据库
conn = await asyncpg.connect(os.getenv("DATABASE_URL"))
try:
rows = await conn.fetch(query)
return ToolResult(
success=True,
data=[dict(row) for row in rows]
)
except Exception as e:
return ToolResult(
success=False,
error=str(e)
)
finally:
await conn.close()
8.2 MCP 服务器集成
Hermes Agent 原生支持 MCP（Model Context Protocol）：
// ~/.hermes/mcp_servers.json
{
"servers": {
"filesystem": {
"command": "mcp-filesystem",
"args": ["/home/user/projects"],
"env": {}
},
"postgres": {
"command": "mcp-postgres",
"args": [],
"env": {
"DATABASE_URL": "postgresql://user:pass@localhost/db"
}
}
}
}
# Hermes 自动发现 MCP 工具
hermes> 列出可用的 MCP 工具
可用工具：
- filesystem_read_file: 读取文件内容
- filesystem_write_file: 写入文件
- filesystem_list_directory: 列出目录
- postgres_query: 执行 SQL 查询
- postgres_list_tables: 列出所有表
九、性能优化与生产部署
9.1 记忆检索优化
Hermes Agent 使用混合检索策略：
# hermes/memory/hybrid_retrieval.py
class HybridRetriever:
"""混合检索：关键词 + 语义向量"""
def __init__(self):
self.keyword_searcher = FTS5Searcher()
self.semantic_searcher = VectorSearcher()
async def search(self, query: str, limit: int = 10) -> list[dict]:
# 第一步：关键词检索（快速）
keyword_results = await self.keyword_searcher.search(query, limit * 2)
# 第二步：语义检索（精确）
semantic_results = await self.semantic_searcher.search(query, limit * 2)
# 第三步：融合排序
merged = self._merge_results(
keyword_results,
semantic_results,
alpha=0.4 # 关键词权重
)
return merged[:limit]
def _merge_results(
self,
keyword_results: list,
semantic_results: list,
alpha: float
) -> list:
"""RRF（Reciprocal Rank Fusion）融合"""
scores = {}
for i, result in enumerate(keyword_results):
doc_id = result["id"]
scores[doc_id] = scores.get(doc_id, 0) + alpha / (i + 60)
for i, result in enumerate(semantic_results):
doc_id = result["id"]
scores[doc_id] = scores.get(doc_id, 0) + (1 - alpha) / (i + 60)
# 按分数排序
sorted_ids = sorted(scores.keys(), key=lambda x: scores[x], reverse=True)
return sorted_ids
9.2 技能执行优化
# hermes/executor/parallel.py
class ParallelExecutor:
"""并行执行器"""
async def execute_plan(self, plan: Plan) -> list[Result]:
"""并行执行无依赖的步骤"""
# 构建依赖图
dag = self._build_dag(plan.steps)
# 拓扑排序
levels = self._topological_sort(dag)
results = []
for level in levels:
# 同一层级的步骤可以并行执行
tasks = [
self.execute_step(step)
for step in level
]
level_results = await asyncio.gather(*tasks)
results.extend(level_results)
return results
9.3 生产部署清单
# 生产环境检查清单
基础设施：
- [ ] 至少 2 个实例（高可用）
- [ ] 负载均衡器配置
- [ ] 持久化存储（SSD）
- [ ] 监控与告警
安全配置：
- [ ] API Key 加密存储
- [ ] 通信 TLS 加密
- [ ] 访问控制（RBAC）
- [ ] 审计日志
性能优化：
- [ ] 向量索引预构建
- [ ] 常用技能缓存
- [ ] 数据库连接池
- [ ] 异步 I/O
备份恢复：
- [ ] 记忆数据定期备份
- [ ] 技能库版本控制
- [ ] 灾难恢复预案
十、与其他 AI Agent 框架对比
10.1 对比矩阵
| 特性 | Hermes Agent | Claude Code | OpenClaw | AutoGPT |
|---|---|---|---|---|
| 开源 | ✅ MIT | ❌ | ✅ AGPL | ✅ MIT |
| 持久记忆 | ✅ 四层架构 | ⚠️ 有限 | ✅ | ⚠️ 有限 |
| 技能沉淀 | ✅ 自动 | ❌ | ✅ 手动 | ⚠️ 插件 |
| 多平台 | ✅ 12+ | ❌ CLI | ✅ | ❌ |
| 模型无关 | ✅ 40+ | ❌ Claude only | ✅ | ✅ |
| 学习闭环 | ✅ GEPA 引擎 | ❌ | ⚠️ 有限 | ⚠️ 有限 |
| MCP 支持 | ✅ 原生 | ✅ | ✅ | ❌ |
| 生产就绪 | ✅ | ✅ | ✅ | ⚠️ 实验性 |
10.2 适用场景分析
选择 Hermes Agent：
- 需要长期运行的 AI 助手
- 团队协作，共享技能库
- 多平台统一接入
- 对数据隐私有要求（本地部署）
选择 Claude Code：
- 单一 Claude 模型深度使用
- VS Code 深度集成
- 不需要跨平台
选择 OpenClaw：
- 需要浏览器自动化
- GUI 操作场景
- 已有 Claude Code 工作流
十一、未来展望
11.1 路线图（2026-2027）
Q3 2026：
- 技能版本控制与回滚
- 多用户协作空间
- 性能监控 Dashboard
Q4 2026：
- 多 Agent 协作模式
- 技能市场商业化
- 企业级权限管理
2027：
- 跨 Agent 技能共享
- 联邦学习（隐私保护下的技能优化）
- 自主 Agent 编排
11.2 技术演进方向
- 更强的自主性：从「辅助工具」到「自主代理」
- 更深的记忆：从「文本记忆」到「多模态记忆」
- 更广的协作：从「单 Agent」到「Agent 网络」
结语：AI 的「成长」之路
Hermes Agent 的核心创新不是某个算法或工具，而是一个简单却深刻的理念：AI 应该在使用中成长。
传统 AI 是「出厂即定形」的产品，无论你用多久，它永远停留在初始状态。Hermes Agent 打破了这一限制——通过闭环学习系统，让 AI 能够：
- 记住你的偏好
- 积累你的最佳实践
- 避免重复犯同样的错
- 越用越懂你的工作方式
这不仅是技术进步，更是 AI 设计范式的转变：从「一次性工具」到「持续成长的伙伴」。
正如 Nous Research 的愿景：让每个开发者都有一个随时间变强的数字队友。
附录：常见问题
Q1: Hermes Agent 与 Claude Code 有什么区别？
核心区别：
- Claude Code 仅支持 Claude 模型，Hermes 支持任意模型
- Claude Code 无持久记忆，Hermes 有四层记忆系统
- Claude Code 不沉淀技能，Hermes 自动创建可复用技能
- Claude Code 仅 CLI，Hermes 支持 12+ 平台
Q2: 记忆数据会占用多少存储？
典型使用场景：
- 日常使用（1 个月）：~50MB
- 中度使用（3 个月）：~200MB
- 重度使用（1 年）：~1GB
存储主要来自：
- 全量对话历史（SQLite）：70%
- 技能文件（Markdown）：20%
- 向量索引：10%
Q3: 技能沉淀会影响隐私吗？
不会：
- 所有记忆数据存储在本地
- 技能文件仅在用户授权下上传到 Skills Hub
- 支持完全离线运行
Q4: 支持哪些语言？
当前支持：
- 界面：中文 / 英文
- 对话：任意语言（取决于模型）
- 技能描述：Markdown（任意语言）
参考资料
本文约 8500 字，完整覆盖 Hermes Agent 的核心架构、学习闭环、四层记忆系统、Honcho 协议、Skills Hub、部署实践与未来展望。