Hermes Agent 深度拆解：当 AI 智能体学会「自我进化」，一场关于记忆、技能与闭环学习的架构革命
2026年GitHub最火的开源AI Agent项目，上线6周狂揽21.6万Stars，增速是OpenClaw的三倍。它的核心创新不是「更强的模型」，而是「会学习的系统」——执行、提炼、沉淀、复用、自省，五阶段闭环让智能体越用越聪明。
引言：AI Agent的「金鱼困境」
如果你用过Claude Code、Cursor或任何AI编程助手，你一定经历过这种「金鱼时刻」：
每次对话都是独立的，AI不记得上次你教过它的东西。你反复告诉它「用中文注释」「避免过度抽象」「优先用async/await」——但这些偏好永远无法沉淀。Agent的每次启动，都像一条只有7秒记忆的金鱼。
问题本质：当前的AI Agent是无状态的。它们能执行任务，但不能积累经验。能输出代码，但不能沉淀技能。能回答问题，但不能形成工作方式。
2026年2月，Nous Research开源的Hermes Agent试图从根本上解决这个问题。它的官方Slogan——「The agent that grows with you」（与你共同成长的智能体）——精准概括了设计哲学：Agent不应该只是工具，而应该是持续进化的数字员工。
一、项目背景：从「训模人」到「做Agent」的基因优势
1.1 Nous Research是谁？
Nous Research成立于2023年，核心团队约20人，主要成员来自StabilityAI。这家机构的独特之处在于：他们是「训模人」出身，而非纯工具开发者。
此前推出的Hermes系列大模型（Hermes 1/2/3、Nomos系列）累计下载超5000万次，在开源社区有深厚积累。「训模人做Agent」的基因，让他们比纯工具团队更懂大模型的能力边界与潜力——这也是Hermes Agent能在技术上超越前任王者OpenClaw的深层原因。
2026年2月25日，Hermes Agent正式开源。首月GitHub Star突破2.2万，4月8日v0.8.0版本发布后单日新增超6400颗星。截至本文写作时，项目总Stars突破21.6万，多日霸榜全球开源项目排行第一，被中文社区戏称为「爱马仕」。
1.2 定位：不是聊天机器人，是「长期演进型Agent运行时」
Hermes Agent的定位非常清晰——它不是CLI工具，不是SDK，也不是前端界面，而是一套支撑Agent持续存在、持续学习、持续进化的底层系统。
官方定义：长期演进型Agent运行时（Agent Runtime）。
它把四个过去被割裂的模块——执行循环（Execution Loop）、经验沉淀（Skill Ingestion）、跨会话记忆（Persistent Memory）、安全边界（Sandboxed Execution）——第一次真正揉进同一个设计骨架里。你配置一次，它就能在飞书、Telegram、CLI甚至未来接入的微信生态里，以同一个「人格」、同一套技能、同一段记忆持续工作。
二、核心架构：自进化学习闭环的五阶段设计
Hermes Agent的核心创新，是一套完整的闭环学习系统（Closed-Loop Learning System）。这不是简单的「保存对话历史」，而是从任务执行到技能沉淀的全链路自动化。
2.1 五阶段闭环：执行→提炼→沉淀→复用→自省
用户下达任务
↓
┌─────────────────────────────────────────────┐
│ Stage 1: 执行（Execution） │
│ Agent自主规划、调用工具、完成任务 │
└─────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────┐
│ Stage 2: 提炼（Distillation） │
│ 分析执行轨迹，识别可复用模式 │
└─────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────┐
│ Stage 3: 沉淀（Precipitation） │
│ 生成SKILL.md，存储至技能库 │
└─────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────┐
│ Stage 4: 复用（Reuse） │
│ 新任务自动匹配已有技能，加速执行 │
└─────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────┐
│ Stage 5: 自省（Introspection） │
│ 发现更优路径，以patch方式更新技能 │
└─────────────────────────────────────────────┘
↓
能力持续增强，形成飞轮效应
Stage 1：执行（Execution）
用户下达任务后，Agent自主规划并执行。这一阶段的核心是任务分解与工具编排。
# Hermes Agent内部任务分解示例（简化版）
class TaskExecutor:
def __init__(self, agent):
self.agent = agent
self.tool_registry = agent.tools # 47种内置工具
async def execute(self, task: str):
# 1. 任务分解
subtasks = await self.decompose_task(task)
# 2. 工具选择与编排
for subtask in subtasks:
tools = self.select_tools(subtask)
result = await self.execute_subtask(subtask, tools)
# 3. 执行轨迹记录（关键！）
await self.record_execution_trace(task, subtasks, results)
关键创新：Hermes Agent会记录完整的执行轨迹，包括：
- 任务分解策略
- 工具调用序列
- 中间结果与决策点
- 失败重试路径
这些轨迹是后续「提炼」阶段的原始素材。
Stage 2：提炼（Distillation）
完成复杂任务后（定义为超过15次工具调用或执行时间超过5分钟），系统自动触发提炼阶段。
提炼引擎会分析执行轨迹，识别：
- 高频操作模式：哪些工具组合被反复使用？
- 决策关键点：哪些判断决定了执行路径？
- 失败恢复策略：遇到错误时如何调整？
- 可复用片段：哪些步骤可以参数化后复用？
# 提炼引擎核心逻辑（简化版）
class SkillDistiller:
async def distill(self, execution_trace: ExecutionTrace):
# 1. 模式识别
patterns = self.identify_patterns(execution_trace)
# 2. 参数化
parameterized = self.parameterize_patterns(patterns)
# 3. 验证可复用性
reusable = await self.validate_reusability(parameterized)
# 4. 生成Skill描述
skill = self.generate_skill_md(reusable)
return skill
提炼的结果是一个结构化的Skill描述，包含：
- 触发条件：什么类型的任务应该调用这个Skill？
- 参数定义：哪些输入可以动态配置？
- 执行步骤：标准化的工作流程
- 验证方法：如何判断执行成功？
Stage 3：沉淀（Precipitation）
提炼后的Skill会被格式化为Markdown文件（SKILL.md），存储到本地技能库。
# SKILL: 代码审查助手
## 触发条件
- 任务包含「review」「审查」「检查代码」关键词
- 涉及PR分析或代码质量评估
## 参数
- `target_branch`: 目标分支名
- `review_depth`: 审查深度（quick/standard/deep）
- `focus_areas`: 关注领域（security|performance|style）
## 执行步骤
1. 获取PR差异（gh pr diff）
2. 解析变更文件列表
3. 按关注领域分类检查
4. 生成审查报告
## 验证
- 报告包含所有关键发现
- 建议可操作且具体
技能库默认路径：~/.hermes/skills/。每个Skill一个独立的SKILL.md文件，支持版本管理。
Stage 4：复用（Reuse）
新任务到达时，Hermes Agent会自动匹配已有技能。
匹配算法结合：
- 语义相似度：任务描述与Skill触发条件的向量相似度
- 参数兼容性：任务是否提供足够的参数满足Skill需求
- 历史成功率：该Skill过往执行的胜率
class SkillMatcher:
async def match_skills(self, task: str) -> List[Skill]:
# 1. 向量检索
candidates = await self.vector_search(task, self.skill_library)
# 2. 参数兼容性检查
compatible = [s for s in candidates if self.check_params(s, task)]
# 3. 历史胜率排序
ranked = sorted(compatible, key=lambda s: s.success_rate, reverse=True)
return ranked[:3] # 返回Top 3匹配技能
效果数据：根据Nous Research的测试，连续运行3个月后，65%的新任务可以直接调用已有技能，平均执行时间减少40%。
Stage 5：自省（Introspection）
这是Hermes Agent区别于所有竞品的杀手级特性：技能自我优化。
当Agent发现某次执行比Skills描述的流程更高效时，会自动生成patch更新技能，而非全量重写。这种设计有两个优势：
- 安全性：patch是增量更新，保留原有的核心逻辑
- 效率：patch只需记录差异，token消耗更少
--- a/skills/code-review/SKILL.md
+++ b/skills/code-review/SKILL.md
@@ -12,6 +12,8 @@
## 执行步骤
1. 获取PR差异（gh pr diff）
+1.5. 过滤自动生成的文件（lock文件、构建产物）
2. 解析变更文件列表
+2.5. 按文件大小排序，优先审查大文件
3. 按关注领域分类检查
4. 生成审查报告
2.2 闭环的时间维度：从第1天到第30天的能力跃迁
Nous Research提供了30天使用周期的能力演进数据：
| 时间 | 能力表现 |
|---|---|
| 第1天 | 标准通用代码生成，无个性化 |
| 第7天 | 自动应用用户偏好的代码风格（简洁/详细） |
| 第14天 | 识别用户项目的技术栈偏好（React/Vue、Go/Java） |
| 第30天 | 主动调用已沉淀技能处理复杂需求，自主设计工作流 |
关键洞察：Agent的能力提升不是线性的，而是加速的。前7天的积累为后续学习提供了更高效的基础。
三、记忆架构：四层持久化设计
Hermes Agent的另一核心创新是四层记忆系统。这套架构解决了「Agent如何跨会话保持上下文」的经典难题。
3.1 四层记忆详解
┌─────────────────────────────────────────────────────┐
│ Layer 1: 常驻提示记忆（Resident Prompt Memory） │
│ MEMORY.md + USER.md │
│ 上限：3575字符 │
│ 触发：每次会话自动加载 │
└─────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────┐
│ Layer 2: 会话归档（Session Archive） │
│ SQLite + FTS5全文索引 │
│ 触发：用户查询历史信息 │
└─────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────┐
│ Layer 3: 技能库（Skill Library） │
│ ~/.hermes/skills/*.md │
│ 触发：任务匹配已有技能 │
└─────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────┐
│ Layer 4: 全量历史（Full History） │
│ JSON Lines格式，按时间索引 │
│ 触发：深度上下文检索 │
└─────────────────────────────────────────────────────┘
Layer 1：常驻提示记忆
MEMORY.md：存储环境事实、经验教训、关键决策。
# MEMORY.md
## 环境
- 工作目录：/Users/xxx/projects
- 偏好编辑器：VSCode + Vim键绑定
- 主要语言：Python、TypeScript
## 经验教训
- pytest需要用`-v`参数才能看到详细输出
- Docker Compose的volumes路径用相对路径更安全
- 代码审查优先关注安全性问题
## 关键决策
- 2026-07-15：决定用FastAPI替代Flask
- 2026-07-20：启用pre-commit hooks自动格式化
USER.md：存储用户画像、职业背景、工作目标。
# USER.md
## 基本信息
- 职业：后端工程师
- 公司：某电商平台
- 工作年限：5年
## 偏好
- 代码风格：简洁、类型完整
- 文档语言：中文
- 注重：性能优化、可维护性
## 当前目标
- 完成订单系统的微服务拆分
- 学习Kubernetes部署
关键设计：常驻提示记忆有3575字符的上限。这不是随意设定，而是基于大模型上下文窗口的性价比计算：
- 过短：关键信息丢失
- 过长：Token成本过高，且可能干扰推理
Hermes Agent会自动判断哪些信息值得写入，无需用户手动配置。
Layer 2：会话归档
所有对话历史存储在本地SQLite数据库，启用FTS5全文检索。
-- 会话归档表结构
CREATE TABLE sessions (
id INTEGER PRIMARY KEY,
created_at TIMESTAMP,
summary TEXT,
full_content TEXT
);
-- FTS5虚拟表
CREATE VIRTUAL TABLE sessions_fts USING fts5(
summary,
full_content,
tokenize='unicode61'
);
当用户问「上周我们讨论的数据库优化方案是什么？」，Agent会通过FTS5快速检索相关对话。
Layer 3：技能库
所有自动生成的Skills存储在~/.hermes/skills/目录，每个Skill一个独立的SKILL.md文件。
$ tree ~/.hermes/skills/
├── api-design/
│ └── SKILL.md
├── code-review/
│ └── SKILL.md
├── database-migration/
│ └── SKILL.md
└── testing/
└── SKILL.md
技能库支持：
- 版本管理：通过Git追踪变更
- 导入导出：与团队成员共享技能
- 手动编辑：用户可以直接修改SKILL.md
Layer 4：全量历史
完整的执行日志，以JSON Lines格式存储，按时间索引。
{"timestamp":"2026-07-30T09:00:00Z","type":"task","content":"重构用户认证模块","result":"success"}
{"timestamp":"2026-07-30T09:15:00Z","type":"skill_created","content":"auth-refactor","path":"skills/auth/SKILL.md"}
{"timestamp":"2026-07-30T09:30:00Z","type":"memory_update","content":"学会了用JWT替代Session"}
3.2 记忆的生命周期管理
Hermes Agent的记忆不是无限增长的，而是有生命周期管理：
- 短期记忆（当次会话）：会话结束后自动清理
- 中期记忆（常驻提示）：超过上限时，自动压缩低频信息
- 长期记忆（技能库）：永不删除，除非用户手动移除
- 归档记忆（SQLite）：保留90天，超期自动归档冷存储
class MemoryManager:
async def manage_lifecycle(self):
# 1. 检查常驻提示大小
if len(self.memory_md) > 3575:
await self.compress_resident_memory()
# 2. 清理过期会话
await self.archive_old_sessions(days=90)
# 3. 优化技能库索引
await self.reindex_skill_library()
四、技术实现：从Python到生产级部署
4.1 核心代码架构
Hermes Agent的技术栈：
- 核心语言：Python 3.11+
- Web框架：FastAPI（API服务）
- 数据库：SQLite + FTS5（本地存储）
- 向量检索：FAISS（技能匹配）
- 沙箱执行：Docker / Podman（安全隔离）
hermes-agent/
├── hermes/
│ ├── core/
│ │ ├── executor.py # 执行引擎
│ │ ├── distiller.py # 提炼引擎
│ │ ├── memory.py # 记忆管理
│ │ └── sandbox.py # 沙箱执行
│ ├── tools/
│ │ ├── base.py # 工具基类
│ │ ├── filesystem.py # 文件操作
│ │ ├── web.py # 网络请求
│ │ └── code.py # 代码执行
│ ├── platforms/
│ │ ├── telegram.py # Telegram适配
│ │ ├── feishu.py # 飞书适配
│ │ └── cli.py # CLI适配
│ └── llm/
│ ├── providers.py # 模型提供者
│ └── router.py # 模型路由
├── skills/ # 技能库
├── memory/ # 记忆存储
└── config/
└── hermes.yaml # 配置文件
4.2 执行引擎实现
# hermes/core/executor.py
from typing import List, Optional
from dataclasses import dataclass
import asyncio
@dataclass
class ExecutionTrace:
task: str
subtasks: List[str]
tool_calls: List[dict]
results: List[dict]
timestamp: float
class TaskExecutor:
def __init__(self, llm_client, tool_registry, memory_manager):
self.llm = llm_client
self.tools = tool_registry
self.memory = memory_manager
self.max_iterations = 50 # 防止无限循环
async def execute(self, task: str) -> ExecutionTrace:
"""主执行循环"""
trace = ExecutionTrace(
task=task,
subtasks=[],
tool_calls=[],
results=[],
timestamp=time.time()
)
# 1. 加载上下文
context = await self.memory.load_context(task)
# 2. 任务分解
subtasks = await self.decompose_task(task, context)
trace.subtasks = subtasks
# 3. 执行子任务
for subtask in subtasks:
await self.execute_subtask(subtask, trace)
# 检查是否需要人类确认
if self.needs_human_approval(subtask):
await self.request_approval(subtask)
# 4. 记录执行轨迹
await self.memory.record_trace(trace)
# 5. 触发提炼（如果满足条件）
if self.should_distill(trace):
await self.trigger_distillation(trace)
return trace
async def decompose_task(self, task: str, context: dict) -> List[str]:
"""使用LLM分解任务"""
prompt = f"""
任务：{task}
已有上下文：
{context}
已有技能：
{await self.memory.list_skills()}
请将任务分解为可执行的子任务列表。
每个子任务应该：
1. 明确具体
2. 可独立执行
3. 有明确的完成标准
"""
response = await self.llm.generate(prompt)
return self.parse_subtasks(response)
async def execute_subtask(self, subtask: str, trace: ExecutionTrace):
"""执行单个子任务"""
# 1. 匹配已有技能
matched_skills = await self.memory.match_skills(subtask)
if matched_skills:
# 使用已有技能
skill = matched_skills[0]
result = await self.execute_with_skill(subtask, skill)
else:
# 动态规划执行
result = await self.execute_dynamic(subtask)
# 记录工具调用和结果
trace.tool_calls.append(result.tool_calls)
trace.results.append(result.output)
def should_distill(self, trace: ExecutionTrace) -> bool:
"""判断是否触发提炼"""
# 复杂任务：超过15次工具调用或执行时间超过5分钟
tool_call_count = sum(len(calls) for calls in trace.tool_calls)
execution_time = time.time() - trace.timestamp
return tool_call_count > 15 or execution_time > 300
4.3 提炼引擎实现
# hermes/core/distiller.py
import re
from difflib import unified_diff
from pathlib import Path
class SkillDistiller:
def __init__(self, llm_client, skill_library_path: Path):
self.llm = llm_client
self.skill_library = skill_library_path
async def distill(self, trace: ExecutionTrace) -> Optional[Skill]:
"""从执行轨迹提炼技能"""
# 1. 模式识别
patterns = await self.identify_patterns(trace)
if not patterns:
return None
# 2. 参数化
parameterized = await self.parameterize(patterns)
# 3. 生成Skill描述
skill_md = await self.generate_skill_md(trace, parameterized)
# 4. 保存到技能库
skill_path = self.skill_library / parameterized.name / "SKILL.md"
skill_path.parent.mkdir(parents=True, exist_ok=True)
skill_path.write_text(skill_md, encoding='utf-8')
return Skill(name=parameterized.name, path=skill_path)
async def identify_patterns(self, trace: ExecutionTrace) -> List[Pattern]:
"""识别可复用的执行模式"""
prompt = f"""
分析以下执行轨迹，识别可复用的模式：
任务：{trace.task}
工具调用序列：{trace.tool_calls}
结果：{trace.results}
请识别：
1. 高频工具组合
2. 决策关键点
3. 可参数化的步骤
4. 失败恢复策略
"""
response = await self.llm.generate(prompt)
return self.parse_patterns(response)
async def generate_skill_md(self, trace: ExecutionTrace, pattern: Pattern) -> str:
"""生成SKILL.md内容"""
return f"""# SKILL: {pattern.name}
## 触发条件
{pattern.trigger_conditions}
## 参数
{pattern.parameters}
## 执行步骤
{pattern.steps}
## 验证
{pattern.validation}
## 来源
- 创建时间：{trace.timestamp}
- 来源任务：{trace.task}
- 执行次数：1
- 成功率：100%
"""
async def patch_skill(self, skill_path: Path, improvement: str):
"""以patch方式更新技能"""
current = skill_path.read_text(encoding='utf-8')
patch = await self.generate_patch(current, improvement)
# 应用patch
updated = self.apply_patch(current, patch)
skill_path.write_text(updated, encoding='utf-8')
# 记录patch历史
patch_log = skill_path.parent / "PATCH_LOG.md"
with open(patch_log, 'a', encoding='utf-8') as f:
f.write(f"\n## {time.time()}\n{patch}\n")
4.4 沙箱执行与安全边界
Hermes Agent支持6种沙箱后端：
- Docker：最成熟，适合Linux/macOS
- Podman：无daemon，适合企业环境
- Firecracker：轻量级微VM，适合云部署
- Kata Containers：安全容器，适合多租户
- nsjail：Linux命名空间隔离
- 本地执行：无隔离，仅用于受信任环境
# hermes/core/sandbox.py
from abc import ABC, abstractmethod
import subprocess
class SandboxBackend(ABC):
@abstractmethod
async def execute(self, command: str, timeout: int = 300) -> ExecutionResult:
pass
class DockerSandbox(SandboxBackend):
def __init__(self, image: str = "hermes/runtime:latest"):
self.image = image
async def execute(self, command: str, timeout: int = 300) -> ExecutionResult:
"""在Docker容器中执行命令"""
cmd = [
"docker", "run", "--rm",
"--network=none", # 禁用网络
"--memory=512m", # 内存限制
"--cpus=1", # CPU限制
"--timeout", str(timeout),
self.image,
"sh", "-c", command
]
result = subprocess.run(
cmd,
capture_output=True,
timeout=timeout + 10 # 额外10秒缓冲
)
return ExecutionResult(
stdout=result.stdout.decode(),
stderr=result.stderr.decode(),
exit_code=result.returncode
)
class SandboxManager:
def __init__(self, config: dict):
self.backends = {
"docker": DockerSandbox(),
"podman": PodmanSandbox(),
"firecracker": FirecrackerSandbox(),
}
self.default = config.get("sandbox_backend", "docker")
async def execute_safe(self, command: str, risk_level: str = "medium") -> ExecutionResult:
"""根据风险等级选择沙箱"""
if risk_level == "high":
# 高风险操作使用Firecracker微VM
backend = self.backends["firecracker"]
elif risk_level == "medium":
# 中等风险使用Docker
backend = self.backends["docker"]
else:
# 低风险直接执行
return await self.execute_local(command)
return await backend.execute(command)
五、平台适配：从CLI到企业级部署
5.1 多平台消息网关
Hermes Agent支持6大消息平台：
- Telegram：个人用户最常用
- 飞书：企业团队协作
- Discord：社区与开源项目
- Slack：国际团队标准
- 钉钉：国内企业生态
- CLI：开发者本地调试
# hermes/platforms/base.py
from abc import ABC, abstractmethod
class PlatformAdapter(ABC):
@abstractmethod
async def receive_message(self) -> Message:
"""接收消息"""
pass
@abstractmethod
async def send_message(self, content: str, reply_to: Optional[str] = None):
"""发送消息"""
pass
@abstractmethod
async def send_file(self, file_path: Path, caption: str = ""):
"""发送文件"""
pass
# hermes/platforms/telegram.py
from telegram import Bot, Update
from telegram.ext import Application, MessageHandler, filters
class TelegramAdapter(PlatformAdapter):
def __init__(self, token: str):
self.bot = Bot(token)
self.app = Application.builder().token(token).build()
async def receive_message(self) -> Message:
"""处理Telegram消息"""
async def handle(update: Update, context):
message = Message(
id=update.message.message_id,
user_id=update.message.from_user.id,
content=update.message.text,
timestamp=update.message.date
)
await self.message_queue.put(message)
self.app.add_handler(MessageHandler(filters.TEXT, handle))
await self.app.run_polling()
5.2 模型路由与负载均衡
Hermes Agent支持超过200种大模型，包括：
- OpenAI: GPT-4o, GPT-4.5, o1, o3
- Anthropic: Claude 3.5, Claude 4, Claude Opus 5
- Google: Gemini 2.5 Pro, Gemini Flash
- 本地模型: Llama 3.1, Qwen 2.5, Mistral
- 国产模型: DeepSeek, Kimi, GLM-4
# hermes/llm/router.py
from typing import Dict, List
from dataclasses import dataclass
@dataclass
class ModelConfig:
provider: str
model_name: str
api_key: str
max_tokens: int
cost_per_1k_tokens: float
class ModelRouter:
def __init__(self, config: Dict[str, ModelConfig]):
self.models = config
self.default = "claude-opus-5"
async def route(self, task: str, complexity: str = "medium") -> ModelConfig:
"""根据任务复杂度路由模型"""
if complexity == "high":
# 高复杂度用最强模型
return self.models["claude-opus-5"]
elif complexity == "medium":
# 中等复杂度用性价比模型
return self.models["claude-sonnet-4"]
else:
# 低复杂度用快速模型
return self.models["claude-haiku-3.5"]
async def estimate_cost(self, task: str) -> float:
"""估算任务成本"""
# 基于历史数据的Token估算
estimated_tokens = await self.estimate_tokens(task)
model = await self.route(task)
return (estimated_tokens / 1000) * model.cost_per_1k_tokens
5.3 一键部署：从零到生产
Hermes Agent的部署流程与OpenClaw基本一致，支持一键部署：
# 1. 克隆仓库
git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent
# 2. 安装依赖
pip install -r requirements.txt
# 3. 配置模型
export HERMES_LLM_PROVIDER="anthropic"
export ANTHROPIC_API_KEY="your-api-key"
# 4. 启动服务（CLI模式）
python -m hermes.cli
# 5. 启动服务（Telegram模式）
export TELEGRAM_BOT_TOKEN="your-bot-token"
python -m hermes.platforms.telegram
# 6. 企业部署（Docker Compose）
docker-compose up -d
OpenClaw用户一键迁移：
# Hermes Agent支持从OpenClaw迁移配置和数据
python -m hermes.migrate --from-openclaw ~/.openclaw
六、与OpenClaw对比：设计哲学的差异
Hermes Agent与OpenClaw（前任GitHub开源热榜第一）是两个设计哲学完全不同的项目。
6.1 核心差异对比
| 维度 | OpenClaw | Hermes Agent |
|---|---|---|
| 核心能力 | 工具调用、浏览器自动化、系统操作 | 自进化学习、技能沉淀、记忆持久化 |
| 状态管理 | 无状态或被动记忆型 | 主动学习型，自动沉淀技能 |
| 记忆架构 | 依赖外部存储配置 | 内置四层记忆系统 |
| 技能来源 | 手动编写Skill | 自动生成并持续优化 |
| 适用场景 | 任务执行自动化 | 长期协作、能力积累 |
| 学习曲线 | 较低，开箱即用 | 需要初期交互建立偏好 |
6.2 技术架构对比
OpenClaw架构：
用户 → Agent → 工具调用 → 结果返回
↓
手动配置Skills
Hermes Agent架构：
用户 → Agent → 工具调用 → 结果返回
↓ ↓
自动匹配Skills 记录执行轨迹
↓ ↓
执行Skills 分析模式
↓
生成新Skill
↓
更新技能库
↓
形成飞轮效应
6.3 使用场景推荐
选择OpenClaw，如果你需要：
- 快速执行一次性任务
- 浏览器自动化、GUI操作
- 简单的脚本调用
- 不需要跨会话记忆
选择Hermes Agent，如果你需要：
- 长期协作的数字员工
- 能记住你偏好的AI助手
- 持续积累项目知识
- 团队共享技能库
实际案例：某电商团队同时使用两者——OpenClaw处理日常运维自动化（定时巡检、日志分析），Hermes Agent处理核心业务开发（代码审查、架构设计），后者沉淀的技能库成为团队资产。
七、实战案例：用Hermes Agent构建数据分析助手
让我们通过一个完整案例，演示Hermes Agent如何从零开始学习并沉淀技能。
7.1 初始配置
# 初始化Hermes Agent
hermes init
# 配置模型
hermes config set llm.provider anthropic
hermes config set llm.model claude-sonnet-4
# 配置用户画像
cat > ~/.hermes/memory/USER.md << EOF
# USER.md
## 基本信息
- 职业：数据分析师
- 主要工作：电商数据分析
## 偏好
- 语言：Python + Pandas
- 可视化：Matplotlib + Seaborn
- 报告语言：中文
- 注重：数据质量、可复现性
EOF
7.2 第一次任务：分析销售数据
用户: 帮我分析一下上个月的销售数据，找出销量前10的商品
Hermes: [自动匹配技能：无]
[执行步骤]
1. 读取销售数据文件
2. 清洗数据（处理缺失值、异常值）
3. 按商品分组统计销量
4. 排序并取前10
5. 生成可视化图表
[工具调用]
- filesystem.read_file: sales_2026_06.csv
- python.execute: pandas分析脚本
- python.execute: matplotlib绘图
[结果]
销量前10商品：
1. 商品A - 1523件
2. 商品B - 1208件
...
[自动创建Skill]
→ ~/.hermes/skills/sales-analysis/SKILL.md
生成的SKILL.md：
# SKILL: 销售数据分析
## 触发条件
- 任务包含「分析」「销售」「数据」「销量」关键词
- 数据格式为CSV
## 参数
- `data_file`: 数据文件路径
- `time_range`: 时间范围（可选）
- `top_n`: 返回前N个结果（默认10）
## 执行步骤
1. 读取CSV文件（pandas.read_csv）
2. 检查数据质量（缺失值、异常值）
3. 按商品分组统计（groupby + sum）
4. 降序排序取前N（sort_values + head）
5. 生成柱状图（matplotlib）
## 验证
- 数据文件存在且可读
- 结果数量与参数一致
- 图表包含标题和标签
## 元数据
- 创建时间：2026-07-30
- 执行次数：1
- 成功率：100%
7.3 第二次任务：复用已有技能
用户: 帮我分析上周的销售数据，Top 5就行
Hermes: [自动匹配技能：sales-analysis]
[复用Skill，参数：data_file=sales_2026_w30.csv, top_n=5]
[执行步骤（简化）]
1. 读取sales_2026_w30.csv
2. 应用已验证的分析流程
3. 返回Top 5商品
销量前5商品：
1. 商品A - 342件
...
[执行时间：上次15秒 → 本次3秒]
7.4 第三次任务：触发技能优化
用户: 这次分析要排除退货订单
Hermes: [执行过程中发现优化点]
- 原Skill未处理退货过滤
- 添加过滤步骤：status != 'returned'
- 生成patch更新Skill
[自动生成的patch]
--- a/skills/sales-analysis/SKILL.md
+++ b/skills/sales-analysis/SKILL.md
@@ -5,6 +5,8 @@
## 参数
- `data_file`: 数据文件路径
+- `exclude_returned`: 是否排除退货（默认true）
- `time_range`: 时间范围（可选）
7.5 30天后的能力表现
经过30天的持续使用，Hermes Agent沉淀了以下技能：
$ tree ~/.hermes/skills/
├── sales-analysis/ # 销售数据分析
├── customer-segmentation/ # 客户分群
├── inventory-forecast/ # 库存预测
├── report-generation/ # 报告生成
├── data-quality-check/ # 数据质量检查
└── visualization-templates/ # 可视化模板
关键指标：
- 技能总数：6个
- 平均任务执行时间：减少67%
- 新任务技能匹配率：72%
- 代码生成个性化匹配度：94%
八、生态与社区：从开源到企业
8.1 开源生态
Hermes Agent采用MIT开源协议，社区活跃度极高：
- GitHub Stars：21.6万+（截至2026年7月）
- 贡献者：350+
- Discord社区：2.5万+成员
- 每周PR：平均50+
社区贡献的主要方向：
- 平台适配器：新增微信、企业微信等平台
- 工具插件：新增Jira、Confluence等工具
- 技能模板：通用技能模板库
- 文档翻译：中文、日文、韩文文档
8.2 企业版本
Nous Research提供企业版Hermes Agent，核心差异：
| 功能 | 开源版 | 企业版 |
|---|---|---|
| 团队技能共享 | 手动配置 | 自动同步 |
| 权限管理 | 无 | RBAC完整支持 |
| 审计日志 | 基础 | 完整合规日志 |
| 部署方式 | 自托管 | 云托管+私有部署 |
| SLA保障 | 无 | 99.9%可用性 |
| 技术支持 | 社区 | 专属支持团队 |
8.3 商业模式与可持续性
Nous Research在2026年完成5000万美元A轮融资（Paradigm与North Island Ventures领投），商业模式：
- 开源版：免费，社区驱动
- 企业版：按用户数订阅（$50-200/用户/月）
- 云服务：托管部署（按使用量计费）
- 定制开发：企业级定制（项目制）
可持续性分析：
- 开源版本积累社区口碑
- 企业版本提供稳定收入
- 技术护城河是「闭环学习」而非「工具调用」
九、局限性与未来展望
9.1 当前局限
- 学习冷启动：前7天需要较多交互才能建立基础偏好
- 技能迁移成本：跨领域任务需要重新学习
- Token消耗：自动提炼和记忆管理会增加Token成本
- 本地存储依赖：SQLite不适合大规模并发场景
9.2 未来路线图
根据官方Roadmap，Hermes Agent的后续规划：
2026 Q3：
- 支持多Agent协作（团队共享记忆）
- 引入强化学习优化技能选择
- 新增VSCode插件
2026 Q4：
- 云端记忆同步（跨设备共享）
- 技能市场（社区共享技能）
- 企业级权限管理
2027 H1：
- 多模态输入（图片、音频、视频）
- 领域专家模式（垂直行业预训练）
- Agent间通信协议
9.3 技术挑战与研究机会
- Skill冲突解决：多个技能适用时如何选择？
- 记忆一致性：分布式部署下如何保证记忆同步？
- 隐私与安全：敏感信息如何自动过滤？
- 可解释性：Agent决策过程如何透明化？
十、总结：AI Agent的「进化」时刻
Hermes Agent的核心价值，不在于「更强的模型」或「更多的工具」，而在于让Agent具备了学习能力。
回顾AI Agent的发展历程：
- 第一代：聊天机器人，能对话但不能执行
- 第二代：工具调用型Agent，能执行但不积累（OpenClaw代表）
- 第三代：自进化型Agent，能执行也能学习（Hermes Agent代表）
Hermes Agent的设计哲学——「The agent that grows with you」——指向了一个更本质的方向：AI不应该只是工具，而应该是伙伴。工具是静态的，伙伴是动态成长的。
对于开发者而言，Hermes Agent提供了：
- 可复用的技能沉淀机制
- 跨会话的持久记忆
- 渐进式的能力提升
对于企业而言，Hermes Agent提供了：
- 团队共享的数字员工
- 可追溯的知识资产
- 持续优化的工作流程
对于行业而言，Hermes Agent指出了AI Agent的下一个战场：不是比拼单次任务的表现，而是比拼长期学习的能力。
如果你正在寻找一个「越用越懂你」的AI助手，Hermes Agent值得深入体验。它不是完美的，但它是目前最接近「数字员工」定义的开源项目。
参考资料
本文作者：程序员茄子
发布时间：2026年7月30日
字数：约12000字