Hermes Agent 深度拆解：当 AI 终于学会「从经验中学习」——三层记忆、Skill 自进化与后台 Review 机制的全链路实战

引言：从「金鱼脑」到「长期记忆体」的进化

你有没有遇到过这种场景：用 AI 助手调试了一个复杂问题，第二天再问同样的问题，它已经忘得一干二净，你又得重新解释一遍背景、环境和细节。这就是大多数 AI Agent 的现状——每次对话都是一次性的，经验无法沉淀，能力不会增长。

Hermes Agent 由 Nous Research 开发，MIT 开源协议，目前 GitHub 已收获 21.6 万 Stars。它解决了 AI Agent 最核心的痛点：让 AI 真正拥有「长期记忆」和「从经验中学习」的能力。

本文将深度拆解 Hermes Agent 的核心架构：

• 三层记忆系统：L1 核心记忆（800 tokens）+ L2 用户画像（500 tokens）+ L3 会话记忆（SQLite + FTS5）
• Skill 自进化机制：前台执行 + 后台 Review，将复杂任务固化为可复用技能
• 闭环学习架构：策划记忆 → 创建 Skill → Skill 自改进 → FTS5 召回 → 用户建模

配完整代码实战与生产部署指南，让你从零到一理解这套「自进化 AI Agent」的工程实现。

一、为什么传统 AI Agent 永远是「临时工」

1.1 痛点：上下文窗口是瓶颈，不是解决方案

大多数 AI Agent 的记忆能力受限于模型的上下文窗口（Context Window）。即使模型支持 200K tokens，一旦对话结束，所有信息都丢失了。下次对话时，Agent 又要从零开始理解你的需求。

核心问题：

1. 信息无法跨会话传递：每次对话都是独立的，无法记住你之前说过什么
2. 经验无法沉淀：解决了复杂问题，但下次遇到类似问题还是要重新摸索
3. 个性化无从谈起：无法记住你的偏好、习惯、技术栈

1.2 OpenClaw vs Hermes Agent：两种架构路径

OpenClaw 和 Hermes 常被拿来对比，但两者解决的是不同层面的问题：

关键差异：OpenClaw 更像「多渠道个人助理操作系统」，Hermes 则是「会复盘、会学习的执行体」。

二、三层记忆架构：从 CPU 缓存设计借鉴的工程智慧

Hermes Agent 的记忆系统借鉴了 CPU 多级缓存的设计思想，通过分层存储实现「高频信息快速访问，低频信息按需检索」。

2.1 L1 核心记忆：Agent 的「记事本」

存储位置：~/.hermes/memories/MEMORY.md
容量限制：800 tokens
生命周期：每次会话启动时冻结为快照，注入系统提示词

L1 核心记忆类似 CPU 的 L1 缓存——容量小但访问速度极快。Hermes 会在每次启动新会话时，将 MEMORY.md 的内容注入到系统提示词中，确保关键上下文不丢失。

实际应用示例：

# MEMORY.md

## 当前项目
- 名称：电商后台管理系统
- 技术栈：Next.js 14 + TypeScript + Tailwind CSS + Prisma + PostgreSQL
- 部署环境：Vercel + Supabase
- 上次工作：用户权限模块，已实现 RBAC，待集成到订单系统

## 关键决策
- 使用 Prisma 而非 TypeORM，因为类型推断更强
- 认证方案：NextAuth.js + JWT
- 权限模型：五角色（管理员、运营、财务、客服、用户）

## 待办事项
- [ ] 订单列表页的分页逻辑优化（性能问题）
- [ ] 集成支付网关（支付宝、微信支付）
- [ ] 导出报表功能

为什么限制在 800 tokens？

• 保证每次请求都能携带核心上下文
• 避免 token 预算被「记忆信息」占用过多
• 强迫 Agent 只保留真正重要的信息

2.2 L2 用户画像：理解「你是谁」

存储位置：~/.hermes/memories/USER.md
容量限制：500 tokens
功能：记录用户偏好、技术栈倾向、沟通风格

L2 用户画像让 Hermes 能够提供个性化服务。它通过分析历史对话自动提取以下维度：

# USER.md

## 技术偏好
- 主语言：TypeScript（90%）、Python（10%）
- 前端框架：Next.js > React > Vue
- 后端框架：NestJS > Express > FastAPI
- 数据库：PostgreSQL > MySQL > MongoDB
- 部署：Vercel > AWS > 阿里云

## 沟通风格
- 偏好：简洁直接，不要废话
- 代码示例：必须有，带注释
- 错误处理：要完整，包含边界情况
- 文档风格：实战优先，理论靠后

## 工作习惯
- 时区：Asia/Shanghai（UTC+8）
- 工作时间：10:00-22:00
- 常用工具：GitHub、VSCode、Docker、Postman

实际效果：
当你问「帮我加个新页面」时，Hermes 会自动检索到你的技术栈偏好，直接用 Next.js 14 + TypeScript 创建页面组件，样式用 Tailwind CSS，而不是问你「用什么框架」。

2.3 L3 会话记忆：全量存储 + 毫秒级检索

存储位置：~/.hermes/sessions.db（SQLite）
索引方式：FTS5 全文索引
特点：不会主动加载，按需检索

L3 会话记忆是 Hermes 的「长期存储」，所有历史对话都会被保存。关键创新在于：

1. 全量存储：不丢弃任何信息
2. 按需检索：通过 session_search 工具查询历史对话
3. 毫秒级响应：FTS5 全文索引保证检索速度

检索示例：

# Hermes 内部的 session_search 工具实现（简化版）

import sqlite3
from typing import List, Dict

def search_sessions(query: str, limit: int = 10) -> List[Dict]:
    """
    从 SQLite 数据库中检索历史会话
    
    使用 FTS5 全文索引，支持：
    - 关键词搜索
    - 时间范围过滤
    - 相关性排序
    """
    conn = sqlite3.connect('~/.hermes/sessions.db')
    cursor = conn.cursor()
    
    # FTS5 全文搜索
    cursor.execute("""
        SELECT 
            session_id,
            timestamp,
            content,
            bm25(sessions_fts) as relevance
        FROM sessions_fts
        WHERE sessions_fts MATCH ?
        ORDER BY relevance
        LIMIT ?
    """, (query, limit))
    
    results = []
    for row in cursor.fetchall():
        results.append({
            'session_id': row[0],
            'timestamp': row[1],
            'content': row[2],
            'relevance': row[3]
        })
    
    conn.close()
    return results

# 使用示例：检索所有关于「数据库优化」的对话
results = search_sessions("数据库优化 OR database optimization")

FTS5 的优势：

• 支持布尔查询（AND、OR、NOT）
• 支持短语匹配
• 内置相关性排序（bm25）
• 支持中文分词（需额外配置）

三、Skill 自进化机制：从「执行者」到「学习者」

Hermes Agent 最核心的创新在于 Skill 自进化机制：完成复杂任务后，自动将解决方案固化为可复用的 Skill，并在后续使用中持续改进。

3.1 什么是 Skill？

Skill 是 Hermes 的「肌肉记忆」——将反复执行的复杂操作固化为自动化脚本。每个 Skill 都是一个 Markdown 文件，包含：

1. 触发条件：什么情况下使用这个 Skill
2. 执行步骤：具体的操作流程
3. 参数说明：需要哪些输入
4. 注意事项：边界情况、常见问题

示例 Skill：

# ~/.hermes/skills/deploy_to_vercel.md

# Deploy to Vercel

## 触发条件
- 用户要求「部署到 Vercel」
- 项目是 Next.js 应用
- 需要配置环境变量

## 参数
- `project_name`: 项目名称
- `env_vars`: 环境变量字典（可选）
- `team_slug`: Vercel 团队 slug（可选）

## 执行步骤

1. **检查项目配置**
   ```bash
   # 检查是否有 vercel.json
   if [ ! -f "vercel.json" ]; then
       echo "Creating vercel.json..."
       cat > vercel.json << 'EOF'
   {
     "framework": "nextjs",
     "buildCommand": "npm run build",
     "installCommand": "npm install",
     "outputDirectory": ".next"
   }
   EOF
   fi

2. 安装 Vercel CLI

   if ! command -v vercel &> /dev/null; then
       npm install -g vercel
   fi
   

3. 部署项目

   # 登录 Vercel（如果未登录）
   vercel login
   
   # 部署到生产环境
   vercel --prod
   

4. 配置环境变量（如果提供）

   for key in "${!env_vars[@]}"; do
       vercel env add ${key} production <<< "${env_vars[$key]}"
   done
   

注意事项

• 确保 vercel.json 配置正确
• 首次部署需要交互式登录
• 环境变量区分 production/preview/development
• 团队项目需要指定 --scope

常见问题

1. 部署失败：Build Error

   • 检查 package.json 的 scripts 是否正确
   • 查看 Vercel 控制台的详细日志

2. 环境变量未生效

   • 确认添加到了正确的环境（production/preview）
   • 重新部署才能生效

改进历史

• 2026-08-10: 首次创建，支持基础部署
• 2026-08-15: 添加环境变量批量配置
• 2026-08-18: 修复团队项目部署问题

### 3.2 Skill 的创建流程：前台执行 + 后台 Review

Hermes 的 Skill 创建不是简单的「达到阈值就写文件」，而是一套**前台执行与后台复盘的分离架构**。

#### 阶段一：前台执行（Task Execution）

Hermes 在执行任务时，会在系统提示词中注入以下引导：

```python
# agent/prompt_builder.py 中的 SKILLS_GUIDANCE（简化版）

SKILLS_GUIDANCE = """
After completing a complex task (5+ tool calls), fixing a tricky error, 
or discovering a reusable pattern, consider creating a Skill.

A Skill should capture:
1. What problem it solves
2. What steps you took
3. What parameters are needed
4. What could go wrong

Format:
# Skill Name
## Trigger
## Steps
## Parameters
## Notes
"""

def build_system_prompt(user_message: str, memory: str, skills: List[str]) -> str:
    """构建系统提示词"""
    return f"""
You are Hermes, an AI agent that learns from experience.

{SKILLS_GUIDANCE}

## Current Memory
{memory}

## Available Skills
{chr(10).join(skills)}

## User Request
{user_message}

Remember: After completing complex tasks, CREATE SKILLS that can help you 
solve similar problems faster in the future.
"""

阶段二：后台 Review（Skill Review Loop）

任务完成后，Hermes 会在后台启动一个独立的 Review 进程，检查：

1. 是否值得创建 Skill？

   • 任务复杂度（工具调用次数 >= 5）
   • 是否解决了通用问题
   • 是否有复用价值

2. Skill 质量检查

   • 触发条件是否清晰
   • 步骤是否可复现
   • 参数是否完整

3. 与现有 Skill 的冲突检测

   • 是否与已有 Skill 功能重叠
   • 是否应该合并或替换

后台 Review 的实现：

# agent/review_loop.py（简化版）

import asyncio
from typing import Optional
from dataclasses import dataclass

@dataclass
class SkillCandidate:
    """Skill 候选"""
    name: str
    trigger: str
    steps: List[str]
    parameters: Dict[str, str]
    notes: List[str]
    confidence: float  # 0.0 - 1.0

class SkillReviewLoop:
    """后台 Skill Review 进程"""
    
    def __init__(self, skills_dir: str):
        self.skills_dir = skills_dir
        self.existing_skills = self._load_existing_skills()
    
    async def review_session(self, session_log: List[Dict]) -> Optional[SkillCandidate]:
        """审查会话日志，判断是否应该创建 Skill"""
        
        # 1. 分析任务复杂度
        tool_calls = [msg for msg in session_log if msg.get('tool_call')]
        if len(tool_calls) < 5:
            return None  # 任务太简单，不创建 Skill
        
        # 2. 提取问题-解决方案模式
        problem = self._extract_problem(session_log)
        solution = self._extract_solution(session_log)
        
        if not problem or not solution:
            return None
        
        # 3. 检查是否已存在类似 Skill
        if self._is_duplicate(problem):
            return None
        
        # 4. 生成 Skill 候选
        skill = SkillCandidate(
            name=self._generate_name(problem),
            trigger=self._generate_trigger(problem),
            steps=self._extract_steps(solution),
            parameters=self._extract_parameters(solution),
            notes=self._extract_notes(session_log),
            confidence=self._calculate_confidence(session_log)
        )
        
        # 5. 置信度阈值检查
        if skill.confidence < 0.7:
            return None
        
        # 6. 写入 Skill 文件
        self._write_skill(skill)
        
        return skill
    
    def _write_skill(self, skill: SkillCandidate):
        """将 Skill 写入文件"""
        content = f"""# {skill.name}

## 触发条件
{skill.trigger}

## 执行步骤
{chr(10).join(f'{i+1}. {step}' for i, step in enumerate(skill.steps))}

## 参数
{chr(10).join(f'- `{k}`: {v}' for k, v in skill.parameters.items())}

## 注意事项
{chr(10).join(f'- {note}' for note in skill.notes)}

## 改进历史
- {datetime.now().strftime('%Y-%m-%d')}: 首次创建
"""
        with open(f"{self.skills_dir}/{skill.name}.md", 'w') as f:
            f.write(content)
    
    def _calculate_confidence(self, session_log: List[Dict]) -> float:
        """计算 Skill 创建的置信度"""
        score = 0.0
        
        # 因素1：任务复杂度（最高 0.3）
        tool_calls = len([msg for msg in session_log if msg.get('tool_call')])
        score += min(tool_calls / 10, 0.3)
        
        # 因素2：是否解决了问题（最高 0.4）
        if any(msg.get('success') for msg in session_log):
            score += 0.4
        
        # 因素3：是否有通用性（最高 0.3）
        if self._is_reusable(session_log):
            score += 0.3
        
        return score

3.3 Skill 的自改进机制

当现有 Skill 在执行中失败时，Hermes 会自动尝试修复并更新 Skill：

# agent/skill_improver.py（简化版）

class SkillImprover:
    """Skill 自改进引擎"""
    
    def __init__(self, skills_dir: str):
        self.skills_dir = skills_dir
    
    async def improve_skill(
        self, 
        skill_name: str, 
        failure_context: Dict
    ) -> bool:
        """根据失败上下文改进 Skill"""
        
        skill_path = f"{self.skills_dir}/{skill_name}.md"
        
        # 1. 读取现有 Skill
        with open(skill_path, 'r') as f:
            skill_content = f.read()
        
        # 2. 分析失败原因
        failure_reason = self._analyze_failure(failure_context)
        
        # 3. 生成改进建议
        improvement = await self._generate_improvement(
            skill_content, 
            failure_reason
        )
        
        if not improvement:
            return False
        
        # 4. 更新 Skill 文件
        updated_content = self._apply_improvement(
            skill_content, 
            improvement
        )
        
        with open(skill_path, 'w') as f:
            f.write(updated_content)
        
        # 5. 记录改进历史
        self._log_improvement(skill_name, improvement)
        
        return True
    
    def _apply_improvement(
        self, 
        skill_content: str, 
        improvement: Dict
    ) -> str:
        """应用改进到 Skill 内容"""
        
        # 在「改进历史」部分添加新记录
        lines = skill_content.split('\n')
        
        # 找到改进历史部分
        history_index = -1
        for i, line in enumerate(lines):
            if '改进历史' in line:
                history_index = i
                break
        
        if history_index == -1:
            # 添加改进历史部分
            lines.append('\n## 改进历史')
            history_index = len(lines) - 1
        
        # 插入改进记录
        timestamp = datetime.now().strftime('%Y-%m-%d')
        improvement_record = f"- {timestamp}: {improvement['description']}"
        lines.insert(history_index + 1, improvement_record)
        
        # 添加新的注意事项（如果有）
        if improvement.get('note'):
            notes_index = -1
            for i, line in enumerate(lines):
                if '注意事项' in line:
                    notes_index = i
                    break
            
            if notes_index != -1:
                lines.insert(
                    notes_index + 1, 
                    f"- {improvement['note']}"
                )
        
        return '\n'.join(lines)

四、闭环学习：从「执行」到「进化」的完整链路

Hermes 的自进化能力源于一个完整的闭环学习系统，包含五个环节：

策划记忆 → 创建 Skill → Skill 自改进 → FTS5 召回 → 用户建模
    ↑                                                        ↓
    └────────────────── 经验注入 ←───────────────────────────┘

4.1 环节一：策划记忆（Curate Memory）

任务完成后，Hermes 会自主判断「什么值得记住」：

# agent/memory_curator.py（简化版）

class MemoryCurator:
    """记忆策划器"""
    
    def curate_memory(self, session_log: List[Dict]) -> Dict:
        """从会话日志中提取值得记住的信息"""
        
        memory_updates = {
            'facts': [],      # 事实性信息
            'preferences': [], # 用户偏好
            'decisions': []    # 关键决策
        }
        
        for msg in session_log:
            # 提取事实
            if self._is_fact(msg):
                memory_updates['facts'].append(
                    self._extract_fact(msg)
                )
            
            # 提取偏好
            if self._is_preference(msg):
                memory_updates['preferences'].append(
                    self._extract_preference(msg)
                )
            
            # 提取决策
            if self._is_decision(msg):
                memory_updates['decisions'].append(
                    self._extract_decision(msg)
                )
        
        return memory_updates
    
    def _is_fact(self, msg: Dict) -> bool:
        """判断是否是事实性信息"""
        # 例如：「项目用 Next.js 14」
        patterns = [
            r'项目.*用.*',
            r'技术栈.*是.*',
            r'部署.*到.*',
            r'数据库.*是.*',
        ]
        return any(
            re.search(p, msg.get('content', ''))
            for p in patterns
        )

4.2 环节二：创建 Skill（Create Skill）

已在 3.2 节详细说明，核心是「前台执行 + 后台 Review」。

4.3 环节三：Skill 自改进（Improve Skill）

已在 3.3 节详细说明，核心是「失败分析 → 改进生成 → 应用更新」。

4.4 环节四：FTS5 召回（Retrieve Memory）

当用户提问时，Hermes 会先从 L3 会话记忆中检索相关信息：

# agent/memory_retriever.py（简化版）

class MemoryRetriever:
    """记忆检索器"""
    
    def retrieve_relevant_context(
        self, 
        query: str, 
        max_tokens: int = 2000
    ) -> str:
        """检索与当前查询相关的历史上下文"""
        
        # 1. 从 L3 会话记忆检索
        session_results = self._search_sessions(query, limit=5)
        
        # 2. 从 Skill 系统检索
        skill_results = self._search_skills(query, limit=3)
        
        # 3. 合并结果，控制 token 预算
        context_parts = []
        current_tokens = 0
        
        for result in session_results + skill_results:
            tokens = self._count_tokens(result['content'])
            if current_tokens + tokens <= max_tokens:
                context_parts.append(result['content'])
                current_tokens += tokens
            else:
                break
        
        return '\n\n---\n\n'.join(context_parts)
    
    def _search_sessions(self, query: str, limit: int) -> List[Dict]:
        """使用 FTS5 搜索会话记忆"""
        conn = sqlite3.connect('~/.hermes/sessions.db')
        cursor = conn.cursor()
        
        # FTS5 搜索，按相关性排序
        cursor.execute("""
            SELECT content, bm25(sessions_fts) as score
            FROM sessions_fts
            WHERE sessions_fts MATCH ?
            ORDER BY score
            LIMIT ?
        """, (query, limit))
        
        return [
            {'content': row[0], 'score': row[1]}
            for row in cursor.fetchall()
        ]

4.5 环节五：用户建模（User Modeling）

Hermes 会从历史对话中自动提取用户画像，更新 L2 用户记忆：

# agent/user_modeler.py（简化版）

class UserModeler:
    """用户建模器"""
    
    def update_user_profile(self, session_log: List[Dict]) -> Dict:
        """从会话日志中更新用户画像"""
        
        profile_updates = {}
        
        # 提取技术栈偏好
        tech_stack = self._extract_tech_stack(session_log)
        if tech_stack:
            profile_updates['tech_preferences'] = tech_stack
        
        # 提取沟通风格
        communication_style = self._extract_communication_style(session_log)
        if communication_style:
            profile_updates['communication_style'] = communication_style
        
        # 提取工作时间偏好
        work_hours = self._extract_work_hours(session_log)
        if work_hours:
            profile_updates['work_hours'] = work_hours
        
        # 更新 USER.md
        self._update_user_md(profile_updates)
        
        return profile_updates
    
    def _extract_tech_stack(self, session_log: List[Dict]) -> Optional[Dict]:
        """提取技术栈偏好"""
        
        tech_mentions = {}
        
        for msg in session_log:
            content = msg.get('content', '')
            
            # 统计技术栈提及次数
            if 'Next.js' in content or 'nextjs' in content:
                tech_mentions['Next.js'] = tech_mentions.get('Next.js', 0) + 1
            if 'React' in content:
                tech_mentions['React'] = tech_mentions.get('React', 0) + 1
            if 'Vue' in content:
                tech_mentions['Vue'] = tech_mentions.get('Vue', 0) + 1
            if 'TypeScript' in content or 'typescript' in content:
                tech_mentions['TypeScript'] = tech_mentions.get('TypeScript', 0) + 1
            if 'Python' in content:
                tech_mentions['Python'] = tech_mentions.get('Python', 0) + 1
        
        # 按提及次数排序
        sorted_tech = sorted(
            tech_mentions.items(), 
            key=lambda x: x[1], 
            reverse=True
        )
        
        if sorted_tech:
            return {
                'primary': sorted_tech[0][0] if sorted_tech else None,
                'secondary': [t[0] for t in sorted_tech[1:4]],
            }
        
        return None

五、实战：从零部署 Hermes Agent

5.1 安装方式对比

Hermes 支持多种安装方式：

5.2 方式一：桌面应用（推荐）

macOS / Windows：

1. 下载安装包

   • macOS: Hermes-Setup.dmg
   • Windows: Hermes-Setup.exe

2. 安装并启动

3. 配置模型（支持多种后端）

   • Nous Portal（推荐，免费额度）
   • OpenRouter（200+ 模型）
   • OpenAI
   • Anthropic
   • 本地模型（Ollama、vLLM）

Linux：

# 一键安装
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

5.3 方式二：服务器部署（生产环境）

# 1. 安装依赖
sudo apt update
sudo apt install -y python3.11 python3.11-venv git

# 2. 克隆仓库
git clone https://github.com/NousResearch/hermes-agent.git
cd hermes-agent

# 3. 创建虚拟环境
python3.11 -m venv venv
source venv/bin/activate

# 4. 安装依赖
pip install -r requirements.txt

# 5. 配置
cp config.example.yaml config.yaml
cp .env.example .env

# 编辑配置
nano config.yaml
nano .env

# 6. 启动
python run_agent.py

5.4 配置文件详解

config.yaml（主配置）：

# 模型配置
model:
  provider: "nous-portal"  # 或 openrouter, openai, anthropic
  model_name: "nous-hermes-3"
  temperature: 0.7
  max_tokens: 4096

# 终端配置
terminal:
  backend: "local"  # 或 docker, ssh
  shell: "/bin/bash"
  timeout: 300  # 秒

# 记忆配置
memory:
  enabled: true
  l1_max_tokens: 800
  l2_max_tokens: 500
  l3_db_path: "~/.hermes/sessions.db"

# Skill 配置
skills:
  enabled: true
  auto_create: true
  auto_improve: true
  skills_dir: "~/.hermes/skills"

# 工具配置
tools:
  web_search: true
  browser_automation: true
  file_operations: true
  code_execution: true

.env（密钥存储）：

# API Keys（权限设为 600）
NOUS_PORTAL_API_KEY=your_key_here
OPENAI_API_KEY=your_key_here  # 可选
ANTHROPIC_API_KEY=your_key_here  # 可选

# OAuth 认证（可选）
GITHUB_TOKEN=your_token_here

5.5 多平台接入

Hermes 支持通过 Gateway 接入多个消息平台：

# 配置 Telegram
hermes config set telegram.token "YOUR_BOT_TOKEN"
hermes config set telegram.enabled true

# 配置 Discord
hermes config set discord.token "YOUR_BOT_TOKEN"
hermes config set discord.enabled true

# 配置 Slack
hermes config set slack.bot_token "xoxb-..."
hermes config set slack.app_token "xapp-..."
hermes config set slack.enabled true

# 启动 Gateway
hermes gateway start

六、性能优化与生产实践

6.1 记忆系统优化

问题：L1 核心记忆容易溢出（800 tokens 限制）

解决方案：实现自动压缩机制

# agent/memory_compressor.py（简化版）

class MemoryCompressor:
    """记忆压缩器"""
    
    def compress_memory(self, memory: str, max_tokens: int = 800) -> str:
        """压缩记忆内容到指定 token 预算"""
        
        # 1. 计算 token 数量
        tokens = self._count_tokens(memory)
        
        if tokens <= max_tokens:
            return memory
        
        # 2. 提取关键信息
        key_facts = self._extract_key_facts(memory)
        
        # 3. 压缩格式
        compressed = self._format_compressed(key_facts)
        
        # 4. 检查是否超限
        if self._count_tokens(compressed) > max_tokens:
            # 递归压缩
            return self.compress_memory(compressed, max_tokens)
        
        return compressed
    
    def _extract_key_facts(self, memory: str) -> List[str]:
        """提取关键事实"""
        
        # 使用 LLM 提取（简化示例）
        lines = memory.split('\n')
        facts = []
        
        for line in lines:
            # 只保留「项目」「技术栈」「决策」等关键信息
            if any(keyword in line for keyword in ['项目', '技术栈', '决策', '部署', '数据库']):
                facts.append(line)
        
        return facts

6.2 Skill 质量控制

问题：低质量 Skill 会污染技能库

解决方案：实现多级审核机制

# agent/skill_qa.py（简化版）

class SkillQA:
    """Skill 质量保证系统"""
    
    def validate_skill(self, skill: SkillCandidate) -> Tuple[bool, List[str]]:
        """验证 Skill 质量"""
        
        errors = []
        
        # 1. 检查必填字段
        if not skill.trigger:
            errors.append("缺少触发条件")
        
        if not skill.steps:
            errors.append("缺少执行步骤")
        
        # 2. 检查步骤可执行性
        for i, step in enumerate(skill.steps):
            if not self._is_executable(step):
                errors.append(f"步骤 {i+1} 不可执行: {step}")
        
        # 3. 检查参数完整性
        for param, desc in skill.parameters.items():
            if not desc:
                errors.append(f"参数 '{param}' 缺少描述")
        
        # 4. 检查与现有 Skill 的冲突
        conflicts = self._check_conflicts(skill)
        if conflicts:
            errors.append(f"与现有 Skill 冲突: {conflicts}")
        
        return len(errors) == 0, errors
    
    def _is_executable(self, step: str) -> bool:
        """检查步骤是否可执行"""
        
        # 检查是否包含可执行的命令或操作
        executable_patterns = [
            r'```bash',  # bash 命令
            r'```python',  # Python 代码
            r'curl',  # HTTP 请求
            r'git',  # Git 操作
            r'npm',  # NPM 操作
            r'docker',  # Docker 操作
        ]
        
        return any(
            re.search(p, step)
            for p in executable_patterns
        )

6.3 并发与隔离

问题：多个用户同时使用时，Skill 和记忆会混乱

解决方案：使用配置文件隔离

# 创建多个配置文件
~/.hermes/
├── profiles/
│   ├── work/
│   │   ├── config.yaml
│   │   ├── memories/
│   │   └── skills/
│   ├── personal/
│   │   ├── config.yaml
│   │   ├── memories/
│   │   └── skills/
│   └── client_a/
│       ├── config.yaml
│       ├── memories/
│       └── skills/

# 启动不同实例
hermes run --profile work
hermes run --profile personal
hermes run --profile client_a

七、与其他 Agent 框架对比

核心差异：

• Hermes：唯一内置学习闭环的开源 Agent
• OpenClaw：多平台网关，记忆系统相对简单
• LangChain：应用开发框架，非独立 Agent
• AutoGPT：任务自动化，无长期记忆

八、最佳实践与踩坑记录

8.1 记忆系统最佳实践

问题：MEMORY.md 溢出导致关键信息丢失

解决方案：

1. 定期清理过时信息
2. 使用「项目」「待办」「决策」结构化存储
3. 将详细信息移至 L3 会话记忆

# MEMORY.md（最佳实践）

## 当前项目
- 名称：电商后台管理系统
- 技术栈：Next.js 14 + TypeScript + PostgreSQL
- 状态：开发中（权限模块已完成）

## 关键决策
- 使用 Prisma 而非 TypeORM
- 认证方案：NextAuth.js + JWT

## 待办
- [ ] 订单列表分页优化
- [ ] 集成支付网关

## 注意事项
- 时区：Asia/Shanghai
- 部署：Vercel

8.2 Skill 系统最佳实践

问题：Skill 数量爆炸，难以管理

解决方案：

1. 定期合并相似 Skill
2. 为 Skill 添加清晰的触发条件
3. 删除低频使用的 Skill

# 查看所有 Skill
ls ~/.hermes/skills/

# 合并相似 Skill
hermes skill merge deploy_to_vercel deploy_to_vercel_advanced

# 删除 Skill
hermes skill delete outdated_skill

8.3 常见问题与解决方案

Q1：Hermes 记忆不准确

原因：L1 核心记忆容量有限，信息可能被压缩

解决方案：

• 使用明确的表述（如「项目使用 Next.js 14」而非「用 Next.js」）
• 定期检查和更新 MEMORY.md
• 在对话中重复关键信息

Q2：Skill 创建失败

原因：任务复杂度不足或置信度过低

解决方案：

• 确保任务包含至少 5 次工具调用
• 明确描述问题、步骤和参数
• 手动创建 Skill（hermes skill create）

Q3：多平台消息混乱

原因：所有平台共享同一个记忆系统

解决方案：

• 使用配置文件隔离
• 为不同平台创建不同的 Hermes 实例
• 在 MEMORY.md 中明确标注平台来源

九、总结与展望

9.1 核心创新

Hermes Agent 的核心创新在于：

1. 三层记忆架构：L1（核心记忆）+ L2（用户画像）+ L3（会话记忆），实现「高频信息快速访问，低频信息按需检索」

2. Skill 自进化机制：前台执行 + 后台 Review，将复杂任务固化为可复用技能

3. 闭环学习系统：策划记忆 → 创建 Skill → Skill 自改进 → FTS5 召回 → 用户建模

9.2 适用场景

最适合：

• 长期运行的个人 AI 助理
• 需要积累经验的自动化任务
• 多平台消息调度 + 深度个性化

不太适合：

• 一次性任务
• 不需要记忆的场景
• 简单的问答对话

9.3 未来方向

Hermes Agent 仍在快速迭代，未来可能的发展方向：

1. 更智能的记忆压缩：使用 LLM 自动提取关键信息
2. Skill 协作：多个 Skill 组合解决复杂问题
3. 跨 Agent 共享：Skill 和记忆的跨实例共享
4. 图形化界面：更友好的配置和管理界面

十、快速开始清单

# 1. 安装（macOS/Linux）
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# 2. 配置
hermes config set model.provider "nous-portal"
hermes config set model.model_name "nous-hermes-3"

# 3. 设置 API Key
hermes config set api_key "YOUR_API_KEY"

# 4. 启动
hermes run

# 5. 测试
# 在 Telegram/Discord/CLI 中提问：
# "帮我部署一个 Next.js 项目到 Vercel"

# 6. 查看生成的 Skill
ls ~/.hermes/skills/

# 7. 查看记忆
cat ~/.hermes/memories/MEMORY.md
cat ~/.hermes/memories/USER.md

Hermes Agent 代表了 AI Agent 的一个重要方向：从「执行者」进化为「学习者」。它不再是一个只会回答问题的工具，而是一个会记住你、理解你、并随着时间变得越来越擅长为你服务的「数字员工」。

对于需要长期协作的自动化场景，Hermes Agent 是目前开源社区中最值得尝试的解决方案。