【GitHub】NousResearch/Hermes-Agent 深度技术解析：自我进化的AI Agent新范式

一、项目概述与背景

1.1 项目简介

Hermes Agent （项目地址：https://github.com/NousResearch/hermes-agent）是由 Nous Research 团队开发的自我改进型 AI Agent 框架。该项目于2025年7月22日创建，短短数月内便积累了近 15万 Stars ，目前稳居 GitHub 全球排名第 47 位，是当下最受关注的开源 AI Agent 项目之一。

项目的核心设计理念是 "The agent that grows with you"（与你共同成长的AI智能体），强调以下几个关键特性：

特性	说明
内置学习循环	从经验中创建技能、在使用中改进、自动记忆知识
跨平台运行	支持 $5 VPS、GPU 集群、Serverless 等多种部署方式
灵活模型支持	支持 OpenAI、Anthropic、OpenRouter（200+模型）等多种 LLM 提供商
多渠道消息	Telegram、Discord、Slack、WhatsApp、飞书、钉钉等20+平台

1.2 技术栈与项目统计

项目名称: Hermes Agent
开发语言: Python (主要)
许可证: MIT
Stars: 149,500+
Forks: 23,600+
贡献者: 1,100+
版本: v0.2.0 ~ v0.13.0 (共13个正式版本)
主要依赖: 
  - Python 3.11+
  - Rich (终端UI)
  - prompt_toolkit (交互式输入)
  - SQLite/FTS5 (会话存储)
  - uv (包管理器)

---

二、核心架构设计

2.1 整体架构概览

Hermes Agent 采用高度模块化的架构设计，核心组件分布在以下目录中：

hermes-agent/
├── run_agent.py              # AIAgent 类 --- 核心对话循环 (~12k LOC)
├── model_tools.py            # 工具编排与函数调用处理
├── toolsets.py               # 工具集定义
├── cli.py                    # HermesCLI 类 --- 交互式CLI编排器 (~11k LOC)
├── hermes_state.py           # SessionDB --- SQLite会话存储 (FTS5搜索)
├── agent/                    # Agent内部核心模块
│   ├── memory_provider.py    # 记忆提供者抽象基类
│   ├── memory_manager.py     # 多记忆提供者编排器
│   ├── curator.py            # 技能生命周期管理系统
│   └── display.py            # KawaiiSpinner动画组件
├── hermes_cli/               # CLI子命令与皮肤引擎
├── tools/                    # 工具实现（自动发现机制）
│   ├── registry.py           # 工具注册表
│   └── environments/         # 终端后端 (local, docker, ssh, modal...)
├── gateway/                  # 消息网关
│   └── platforms/            # 20+平台适配器
├── plugins/                  # 插件系统
├── skills/                   # 内置技能
└── optional-skills/          # 可选技能

2.2 AIAgent 核心类设计

AIAgent 类是整个框架的核心，定义在 run_agent.py 文件中（约12,000行代码）。其构造函数签名如下：

class AIAgent:
    def __init__(
        self,
        base_url: str = None,           # API基础URL
        api_key: str = None,            # API密钥
        provider: str = None,           # LLM提供商
        api_mode: str = None,           # "chat_completions" | "codex_responses"
        model: str = "",                # 模型名称（空值自动解析）
        max_iterations: int = 90,       # 工具调用最大迭代次数
        enabled_toolsets: list = None,   # 启用的工具集
        disabled_toolsets: list = None, # 禁用的工具集
        quiet_mode: bool = False,       # 静默模式
        save_trajectories: bool = False,# 保存轨迹
        platform: str = None,           # 平台标识 "cli", "telegram"
        session_id: str = None,         # 会话ID
        skip_context_files: bool = False,# 跳过上下文文件
        skip_memory: bool = False,      # 跳过记忆
        credential_pool = None,         # 凭证池
        iteration_budget = None,        # 迭代预算
        fallback_model = None,         # 回退模型
        checkpoints_config = None,     # 检查点配置
        prefill_messages = None,       # 预填充消息
        service_tier = None,           # 服务层级
        reasoning_config = None,       # 推理配置
        callbacks = None,              # 回调函数
        # ... 更多参数
    )

核心接口方法：

方法	返回值	说明
chat(message: str)	str	简单接口，返回最终响应字符串
run_conversation(user_message, system_message, conversation_history, task_id)	dict	完整接口，返回包含 final_response + messages 的字典

---

三、Agent 循环深度解析

3.1 核心对话循环机制

Agent 循环位于 run_conversation() 方法内，采用同步循环设计，包含以下关键机制：

def run_conversation(self, user_message: str, system_message: str = None,
                    conversation_history: list = None, task_id: str = None) -> dict:
    """
    核心Agent循环：同步执行，支持中断检查和预算跟踪
    """
    
    # 初始化消息列表
    messages = self._build_messages(user_message, system_message, conversation_history)
    api_call_count = 0
    
    # 主循环：迭代执行直到达到最大迭代次数或被中断
    while (api_call_count < self.max_iterations and 
           self.iteration_budget.remaining > 0) or self._budget_grace_call:
        
        # 检查中断请求
        if self._interrupt_requested:
            break
        
        # 调用LLM API
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            tools=tool_schemas,
            stream=False
        )
        
        # 处理工具调用
        if response.tool_calls:
            for tool_call in response.tool_calls:
                # 执行工具并获取结果
                result = handle_function_call(
                    tool_call.name, 
                    tool_call.args, 
                    task_id
                )
                # 将工具结果追加到消息历史
                messages.append(tool_result_message(result))
            api_call_count += 1
        else:
            # 无工具调用，返回最终响应
            return {"final_response": response.content, "messages": messages}
    
    # 达到最大迭代次数
    return {"final_response": self._format_max_iterations_response(),
            "messages": messages}

3.2 循环关键特性

特性	说明
同步执行	Agent循环是同步的，父级等待子Agent完成后才继续
中断检查	每次迭代检查 self._interrupt_requested，支持Ctrl+C中断
迭代预算	iteration_budget 控制剩余迭代次数，防止无限循环
宽限调用	_budget_grace_call 允许在预算耗尽后进行一次额外调用
消息累积	工具调用结果追加到 messages 列表，保持上下文连贯性

3.3 消息格式规范

Hermes Agent 采用 OpenAI 兼容的消息格式：

# 标准消息格式
message = {
    "role": "system" | "user" | "assistant" | "tool",
    "content": str,                    # 消息内容
    "name": str,                      # 可选：工具名称（tool角色）
    "tool_call_id": str,              # 可选：工具调用ID
    "reasoning": str,                 # 可选：推理内容
}

# 示例：用户消息
{"role": "user", "content": "帮我写一段快速排序算法"}

# 示例：助手工具调用
{
    "role": "assistant",
    "tool_calls": [
        {"id": "call_123", "name": "write_file", "args": {...}}
    ]
}

# 示例：工具结果
{"role": "tool", "tool_call_id": "call_123", "content": '{"success": true}'}

---

四、记忆系统架构

4.1 记忆提供者插件架构

Hermes Agent 采用可插拔的记忆后端架构，支持多种记忆提供者：

plugins/memory/
├── honcho/           # Honcho记忆提供者
├── mem0/             # Mem0记忆服务
├── supermemory/      # SuperMemory
├── byterover/        # ByteRover
├── hindsight/        # Hindsight
├── holographic/      # Holographic
├── openviking/       # OpenViking
└── retaindb/         # RetainDB

4.2 记忆提供者抽象接口

所有记忆提供者必须实现 MemoryProvider 抽象基类：

# agent/memory_provider.py
from abc import ABC, abstractmethod

class MemoryProvider(ABC):
    """记忆提供者抽象基类"""
    
    @abstractmethod
    def sync_turn(self, turn_messages: list) -> None:
        """
        同步对话轮次
        - turn_messages: 包含 role/content 的消息列表
        - 将当前对话轮次存储到记忆系统
        """
        pass
    
    @abstractmethod
    def prefetch(self, query: str) -> list:
        """
        预取相关记忆
        - query: 当前用户查询
        - 返回与查询相关的历史记忆列表
        """
        pass
    
    @abstractmethod
    def shutdown(self) -> None:
        """关闭时清理资源"""
        pass
    
    def post_setup(self, hermes_home: Path, config: dict) -> None:
        """
        可选：设置向导集成
        - 在hermes setup过程中调用
        """
        pass

4.3 记忆编排器

agent/memory_manager.py 负责编排多个记忆提供者：

class MemoryManager:
    """
    记忆管理器：协调多个记忆提供者
    """
    
    def __init__(self, providers: list[MemoryProvider]):
        self.providers = providers
    
    def sync_turn(self, turn_messages: list) -> None:
        """同步到所有活跃的记忆提供者"""
        for provider in self.providers:
            if provider.is_active:
                provider.sync_turn(turn_messages)
    
    def prefetch(self, query: str) -> list:
        """从所有提供者聚合记忆"""
        all_memories = []
        for provider in self.providers:
            if provider.is_active:
                memories = provider.prefetch(query)
                all_memories.extend(memories)
        return self._deduplicate_and_rank(all_memories)

4.4 重要设计决策（2026年5月政策）

重要 ：新内存提供者 不得 添加到 plugins/memory/ 目录。

解决方案 ：必须作为独立插件仓库发布，用户安装到 ~/.hermes/plugins/ 目录。

这一设计决策确保了：

• 内置记忆提供者集合是封闭的
• 避免核心代码膨胀
• 促进社区创新和第三方集成

---

五、工具系统详解

5.1 工具注册机制

Hermes Agent 采用自动发现的工具注册机制，文件依赖链如下：

tools/registry.py  ← 无依赖，核心注册表
       ↑
tools/*.py         ← 各工具文件，导入时自动注册
       ↑
model_tools.py    ← 导入 registry，触发工具发现
       ↑
run_agent.py, cli.py, batch_runner.py, environments/

5.2 工具注册表核心实现

# tools/registry.py
from dataclasses import dataclass
from typing import Callable, Optional

@dataclass
class ToolDefinition:
    """工具定义"""
    name: str                          # 工具名称
    toolset: str                       # 所属工具集
    schema: dict                        # JSON Schema
    handler: Callable                   # 处理函数
    check_fn: Optional[Callable] = None  # 可用性检查
    requires_env: list = []            # 必需的环境变量

class ToolRegistry:
    """
    全局工具注册表
    - Schema 收集与分发
    - 可用性检查
    - 错误包装
    """
    
    def __init__(self):
        self._tools: dict[str, ToolDefinition] = {}
    
    def register(
        self,
        name: str,
        toolset: str,
        schema: dict,
        handler: Callable,
        check_fn: Optional[Callable] = None,
        requires_env: list = []
    ) -> None:
        """注册工具到注册表"""
        self._tools[name] = ToolDefinition(
            name=name,
            toolset=toolset,
            schema=schema,
            handler=handler,
            check_fn=check_fn,
            requires_env=requires_env
        )
    
    def get_tool(self, name: str) -> Optional[ToolDefinition]:
        """获取工具定义"""
        return self._tools.get(name)
    
    def get_tools_by_toolset(self, toolset: str) -> list:
        """获取工具集内的所有工具"""
        return [t for t in self._tools.values() if t.toolset == toolset]
    
    def get_available_tools(self) -> list:
        """获取所有可用工具（通过check_fn验证）"""
        return [
            t for t in self._tools.values()
            if t.check_fn is None or t.check_fn()
        ]

# 全局单例
registry = ToolRegistry()

5.3 工具实现示例

# tools/example_tool.py
import json
import os
from tools.registry import registry

def check_requirements() -> bool:
    """检查工具依赖是否满足"""
    return bool(os.getenv("EXAMPLE_API_KEY"))

def example_tool(param: str, task_id: str = None) -> str:
    """
    示例工具实现
    返回值必须是JSON字符串
    """
    result = {
        "success": True,
        "data": f"Processed: {param}",
        "task_id": task_id
    }
    return json.dumps(result)

# 在模块导入时自动注册
registry.register(
    name="example_tool",
    toolset="example",
    schema={
        "name": "example_tool",
        "description": "An example tool for demonstration",
        "parameters": {
            "type": "object",
            "properties": {
                "param": {
                    "type": "string",
                    "description": "The parameter to process"
                }
            },
            "required": ["param"]
        }
    },
    handler=lambda args, **kw: example_tool(
        param=args.get("param", ""),
        task_id=kw.get("task_id")
    ),
    check_fn=check_requirements,
    requires_env=["EXAMPLE_API_KEY"]
)

5.4 工具调用处理

# model_tools.py

def handle_function_call(tool_name: str, tool_args: dict, task_id: str) -> str:
    """
    处理工具函数调用
    
    Args:
        tool_name: 工具名称
        tool_args: 工具参数
        task_id: 任务ID
    
    Returns:
        JSON字符串格式的工具执行结果
    """
    # 获取工具定义
    tool_def = registry.get_tool(tool_name)
    
    if tool_def is None:
        return json.dumps({"error": f"Unknown tool: {tool_name}"})
    
    # 检查可用性
    if tool_def.check_fn and not tool_def.check_fn():
        missing = ", ".join(tool_def.requires_env)
        return json.dumps({
            "error": f"Tool not available. Missing: {missing}"
        })
    
    try:
        # 执行工具
        result = tool_def.handler(tool_args, task_id=task_id)
        return result
    except Exception as e:
        # 错误包装
        return json.dumps({
            "error": str(e),
            "tool": tool_name
        })

5.5 工具集（Toolsets）

工具集是工具的逻辑分组，控制哪些工具对Agent可见：

# toolsets.py
TOOLSETS = {
    # 核心工具集
    "browser": ["browse_url", "extract_content", "search_web"],
    "code_execution": ["execute_code", "run_script", "run_tests"],
    "file": ["read_file", "write_file", "patch", "search_files"],
    "terminal": ["terminal", "run_command"],
    "search": ["search_files", "search_web"],
    "vision": ["vision_analyze", "image_ocr"],
    
    # 平台工具集
    "discord": ["discord_send_message", "discord_get_messages"],
    "telegram": ["telegram_send_message", "telegram_get_updates"],
    
    # 功能工具集
    "delegation": ["delegate_task", "clarify"],
    "memory": ["memory_search", "memory_write"],
    "skills": ["skill_create", "skill_execute", "skill_list"],
    "cronjob": ["cron_schedule", "cron_list", "cron_delete"],
    "kanban": ["kanban_create", "kanban_complete", "kanban_show"],
    
    # ... 更多工具集
}

---

六、委托与多代理系统

6.1 委托系统概述

Hermes Agent 提供了强大的委托（Delegation）系统，允许Agent生成子Agent并行处理任务：

父Agent (Orchestrator)
    ├── 子Agent 1 (Leaf) → 并行执行
    ├── 子Agent 2 (Leaf) → 并行执行
    └── 子Agent 3 (Leaf) → 并行执行

6.2 委托工具实现

# tools/delegate_tool.py

def delegate_task(
    goal: str = None,              # 单任务目标
    tasks: list = None,             # 批量任务列表
    context: str = None,            # 共享上下文
    toolsets: list = None,          # 工具集配置
    role: str = "leaf",             # "leaf" | "orchestrator"
    task_id: str = None
) -> str:
    """
    委托工具：生成子Agent执行任务
    
    两种模式：
    1. Single: 传递 goal 创建单个子Agent
    2. Batch: 传递 tasks 并行创建多个子Agent
    """
    
    if tasks:
        # 批量模式：并行执行多个任务
        return _execute_batch_delegation(tasks, context, toolsets)
    elif goal:
        # 单任务模式
        return _execute_single_delegation(goal, context, toolsets, role)
    else:
        return json.dumps({"error": "Either goal or tasks must be provided"})

6.3 角色系统

角色	权限	使用场景
leaf (默认)	无 delegate_task、clarify、memory、send_message、execute_code	专注的工作者任务
orchestrator	保留 delegate_task	可生成自己的workers，复杂任务分解

6.4 配置参数

# config.yaml
delegation:
  max_concurrent_children: 3      # 最大并发子Agent数
  max_spawn_depth: 2              # 最大嵌套深度
  child_timeout_seconds: 300       # 子Agent超时时间
  orchestrator_enabled: true       # 是否允许orchestrator角色
  subagent_auto_approve: false    # 子Agent自动审批
  inherit_mcp_toolsets: true      # 继承MCP工具集
  max_iterations: 30               # 子Agent最大迭代次数

6.5 同步性规则

重要 ：delegate_task 不是 持久的。

对于必须存活于当前轮次之外的长时间运行任务，应使用：

• cronjob --- 定时任务
• terminal(background=True, notify_on_complete=True) --- 后台终端

---

七、技能系统（Skills）

7.1 双层技能架构

Hermes Agent 采用两层并行的技能系统：

类型	路径	说明
内置技能	skills/	随仓库发布，默认可加载
可选技能	optional-skills/	较重/专业化技能，默认不启用

# 安装可选技能
hermes skills install official/<category>/<skill>

# 示例
hermes skills install official/web-development/git-helper
hermes skills install official/security/code-scanner

7.2 技能目录结构

skills/<category>/<name>/
├── SKILL.md              # 技能定义文件（必须）
├── scripts/              # 辅助脚本（可选）
├── references/           # 参考文档（可选）
├── templates/            # 模板文件（可选）
└── .env.example          # 环境变量示例（可选）

目录结构规则：

• 辅助脚本必须放在 scripts/ 目录内
• 参考文档放在 references/
• 模板放在 templates/
• 不要期望模型每次调用时内联编写解析器、XML 解析器或复杂逻辑

7.3 SKILL.md 规范

---
name: git-helper
description: "Git操作辅助工具集"
version: "1.0.0"
author: "张三 @zhangsan"
license: MIT
platforms: [linux, macos, windows]
metadata:
  hermes:
    tags: [git, version-control, development]
    category: devops
    related_skills: [github-cli, code-review]
    config:
      default_branch: "main配置说明"
---

# Git Helper Skill

## When to Use
[何时使用此技能]

## Prerequisites
[前置条件：API密钥、MCP服务器等]

## How to Run
[如何使用]

## Quick Reference
[快速参考]

## Procedure
[详细步骤]

## Pitfalls
[已知陷阱]

## Verification
[验证方法]

7.4 技能硬性标准（HARDLINE）

#	标准	说明
1	description ≤ 60字符	避免列表膨胀，一句话描述，以句号结尾
2	使用原生Hermes工具	引用 search_files 而非 grep，read_file 而非 cat
3	平台声明匹配	使用POSIX特有原语的技能必须声明平台
4	作者署名规则	归功于人类贡献者
5	脚本目录规则	辅助脚本必须放在 scripts/
6	测试要求	必须有 tests/skills/test_<skill>_skill.py

---

八、技能自改进系统（Curator）

8.1 Curator概述

Curator 是 Hermes Agent 的后台技能维护系统，负责跟踪 Agent 创建的技能使用情况，并自动归档陈旧技能。

8.2 核心组件

组件	路径	职责
核心逻辑	agent/curator.py	审查循环、自动转换、LLM审查
备份	agent/curator_backup.py	运行前 tar.gz 快照
CLI	hermes_cli/curator.py	CLI编排
遥测	tools/skill_usage.py	~/.hermes/skills/.usage.json 使用追踪

8.3 技能状态机

┌─────────┐    长时间未使用     ┌────────┐    超过归档时间    ┌──────────┐
│ active  │ ────────────────→  │  stale │ ────────────────→  │ archived │
└─────────┘                    └────────┘                   └──────────┘
     ↑                               ↑
     │                                │
     └─────── 再次使用 ────────────────┘

8.4 CLI 命令

hermes curator status     # 查看状态
hermes curator run        # 运行审查
hermes curator pause      # 暂停
hermes curator resume     # 恢复
hermes curator pin        # 固定（免于自动转换）
hermes curator unpin      # 取消固定
hermes curator archive    # 手动归档
hermes curator restore    # 恢复
hermes curator prune      # 清理
hermes curator backup     # 备份
hermes curator rollback   # 回滚

8.5 配置参数

# config.yaml
curator:
  enabled: true
  interval_hours: 24              # 审查间隔
  min_idle_hours: 168             # 最小空闲时间（7天）
  stale_after_days: 14            # 14天未使用标记为stale
  archive_after_days: 30          # 30天后归档
  backup:
    enabled: true
    path: ~/.hermes/skills/.archive/

8.6 重要约束

约束	说明
只处理Agent创建的技能	created_by: "agent" 的技能才被处理
永不删除	最大破坏性操作是归档
固定技能例外	固定技能免于所有自动转换
恢复机制	归档目录 ~/.hermes/skills/.archive/，用户可恢复

---

九、定时任务系统（Cron）

9.1 调度格式

Hermes Agent 支持多种自然语言调度格式：

格式	示例	说明
Duration	"30m", "2h", "1d"	持续时间
"every" 短语	"every 2h", "every monday 9am"	自然语言
5字段 cron	"0 9 * * *"	标准 cron 表达式
ISO 时间戳	"2026-06-01T09:00:00Z"	一次性任务

9.2 作业定义

# cron/jobs.py
from dataclasses import dataclass
from typing import Optional

@dataclass
class CronJob:
    """定时任务定义"""
    id: str                          # 任务ID
    schedule: str                    # 调度表达式
    message: str                     # 用户消息/指令
    skills: list = []                # 技能列表
    model: Optional[str] = None       # 模型覆盖
    provider: Optional[str] = None   # 提供商覆盖
    script: Optional[str] = None     # 预运行数据收集脚本
    context_from: Optional[str] = None  # 上下文来源
    workdir: Optional[str] = None   # 工作目录
    platforms: list = []             # 投递平台
    max_retries: int = 3             # 最大重试次数

9.3 调度器架构

cron/
├── jobs.py          # 作业存储
└── scheduler.py     # 时钟循环

scheduler.py:
┌─────────────────────────────────────────────────────┐
│                    Clock Loop                        │
├─────────────────────────────────────────────────────┤
│  1. Acquire file lock (.tick.lock)                   │
│  2. Check due jobs                                   │
│  3. Enforce 3-minute hard interrupt                  │
│  4. Catch-up window enforcement                       │
│  5. Execute jobs with timeout                        │
│  6. Release lock                                      │
└─────────────────────────────────────────────────────┘

9.4 加固机制

机制	说明
3分钟硬中断	失控的Agent循环不能独占调度器
追赶窗口	作业周期的一半，限制在 120s--2h
宽限期	一次性作业错过触发时间时 120s 宽限
文件锁	~/.hermes/cron/.tick.lock 防止重复 tick
默认 skip_memory	Cron会话默认不使用记忆

---

十、插件系统

10.1 三类插件架构

Hermes Agent 采用三类插件系统：

类型	路径	发现机制
通用插件	plugins/<name>/	hermes_cli/plugins.py
内存提供者	plugins/memory/<name>/	独立发现系统
模型提供者	plugins/model-providers/<name>/	providers/__init__.py

10.2 通用插件能力

# plugins/example_plugin/__init__.py
from typing import Callable

def register_plugin(ctx: "PluginContext") -> None:
    """
    插件注册函数
    
    PluginContext 提供以下能力：
    """
    
    # 注册生命周期钩子
    ctx.register_hook("pre_tool_call", my_pre_tool_callback)
    ctx.register_hook("post_tool_call", my_post_tool_callback)
    ctx.register_hook("pre_llm_call", my_pre_llm_callback)
    ctx.register_hook("post_llm_call", my_post_llm_callback)
    ctx.register_hook("on_session_start", my_session_start)
    ctx.register_hook("on_session_end", my_session_end)
    
    # 注册新工具
    ctx.register_tool(
        name="my_custom_tool",
        schema={...},
        handler=my_tool_handler
    )
    
    # 注册CLI子命令
    ctx.register_cli_command(
        name="mycommand",
        description="My custom command",
        handler=my_command_handler
    )

def my_pre_llm_callback(messages: list, model: str) -> list:
    """LLM调用前拦截"""
    # 可以修改messages或model
    return messages, model

10.3 新生命周期钩子（v0.13.0）

def transform_llm_output(
    raw_output: str,
    model: str,
    session_id: str
) -> str:
    """
    transform_llm_output 钩子（v0.13.0新增）
    
    在LLM输出进入对话前对其进行重塑或过滤
    - 可用于：上下文窗口缩减、内容过滤、敏感信息脱敏
    """
    return raw_output

10.4 模型提供者插件

# plugins/model-providers/my-provider/__init__.py
from providers import ProviderProfile, register_provider

class MyProviderProfile(ProviderProfile):
    name = "my-provider"
    models = ["my-model-1", "my-model-2"]
    
    def get_client(self, api_key: str, base_url: str = None):
        # 返回兼容的客户端对象
        return MyClient(api_key, base_url)
    
    def get_chat_completion_params(self, model: str, messages: list, **kwargs):
        # 转换参数格式
        return {...}

# 注册提供者
register_provider(MyProviderProfile())

---

十一、安全特性

11.1 v0.13.0 安全加固

Hermes Agent v0.13.0 修复了 8个P0漏洞：

漏洞类型	严重程度	修复措施
密钥泄露	P0	默认开启密钥脱敏
Discord跨公会DM绕过	CVSS 8.1	DISCORD_ALLOWED_ROLES 限定到来源公会
WhatsApp陌生人消息	P0	默认拒绝陌生人，永不响应自聊
MCP OAuth TOCTOU	P0	关闭凭据保存时的竞态窗口
auth.json TOCTOU	P0	关闭凭据写入器的竞态窗口
浏览器SSRF	P0	云元数据SSRF限制底层路由
debug share泄露	P0	上传时脱敏日志内容
Cron提示注入	P0	扫描组装的提示（含技能内容）

11.2 安全配置

# config.yaml
security:
  # 命令审批模式
  command_approval:
    enabled: true
    mode: "whitelist" | "blacklist"
    commands: ["rm", "dd", "mkfs"]
  
  # DM配对
  dm_pairing:
    enabled: true
    require_verification: true
  
  # 容器隔离
  container_isolation:
    enabled: true
    allowed_operations: ["read", "write"]
    network: "none" | "limited" | "full"

11.3 密钥管理

# 密钥存储位置
~/.hermes/.env

# 密钥格式
OPENAI_API_KEY=sk-xxx
ANTHROPIC_API_KEY=sk-ant-xxx
TELEGRAM_BOT_TOKEN=xxx
DISCORD_BOT_TOKEN=xxx

# 密钥文件权限（自动设置）
chmod 0600 ~/.hermes/.env

---

十二、多智能体看板系统（Kanban）

12.1 概述

v0.13.0 新增的持久化多配置文件协作看板，实现了真正的多Agent团队协作：

"委托给真正能完成任务的AI团队"

12.2 核心特性

特性	说明
持久化多配置文件协作	一个安装实例，多个看板
心跳机制	工作节点定期汇报存活状态
任务回收	超时任务自动回收重分配
僵尸检测	识别并清理死亡工作节点
重试预算	每个任务可配置 max_retries
幻觉门控	工作节点创建卡片声明需验证
自动阻塞	未完成就退出的工作节点自动阻塞

12.3 CLI 动词

hermes kanban init              # 初始化看板
hermes kanban create <task>     # 创建任务
hermes kanban list              # 列出任务
hermes kanban assign <id> <worker>  # 分配任务
hermes kanban complete <id>      # 完成任务
hermes kanban block <id>        # 阻塞任务
hermes kanban heartbeat          # 工作节点心跳
hermes kanban stats             # 统计信息
hermes kanban daemon            # 启动守护进程

12.4 隔离模型

Board (硬边界)
├── Tenant A (软命名空间)
│   ├── Worker 1
│   └── Worker 2
└── Tenant B (软命名空间)
    └── Worker 3

• Board 是硬边界 --- worker 以 HERMES_KANBAN_BOARD 固定在环境变量
• Tenant 是 board 内的软命名空间

---

十三、部署与运维

13.1 安装方式

# Linux / macOS / WSL2 / Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Windows (WSL2 推荐)
# 先安装 WSL2，然后运行上述命令

# Android / Termux
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
# 参考 Termux 指南安装特殊依赖

13.2 开发者安装

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

# 运行设置脚本
./setup-hermes.sh

# 或手动安装
curl -LsSf https://astral.sh/uv/install.sh | sh
uv venv .venv --python 3.11
source .venv/bin/activate
uv pip install -e ".[all,dev]"

# 运行测试
scripts/run_tests.sh

13.3 七种终端后端

后端	说明	适用场景
local	本地执行	开发测试
docker	Docker容器	生产隔离
ssh	SSH远程执行	远程服务器
singularity	Singularity容器	HPC环境
modal	Modal Serverless	Serverless
daytona	Daytona沙箱	云沙箱
vercel	Vercel Functions	边缘计算

13.4 Docker 部署

# docker-compose.yml
version: '3.8'
services:
  hermes:
    image: nousresearch/hermes-agent:latest
    environment:
      - HERMES_DASHBOARD=1
    volumes:
      - ./config:/root/.hermes
    ports:
      - "3000:3000"  # Dashboard

13.5 环境变量配置

# 必需变量
HERMES_HOME=~/.hermes                    # 主目录
OPENAI_API_KEY=sk-xxx                    # OpenAI密钥

# 可选变量
HERMES_PROFILE=default                   # 配置文件
HERMES_LOG_LEVEL=INFO                   # 日志级别
HERMES_KANBAN_BOARD=default             # 看板名称
HERMES_SESSION_ID=xxx                    # 会话ID

---

十四、消息网关平台支持

14.1 支持的平台

平台	类型	说明
Telegram	即时通讯	需Bot Token
Discord	社区平台	需Bot Token
Slack	企业协作	需Webhook/App
WhatsApp	即时通讯	需WhatsApp Business API
飞书	企业协作	需企业自建应用
钉钉	企业协作	需机器人应用
企业微信	企业协作	需企业应用
QQ	即时通讯	QQBot
Signal	即时通讯	Signal账号
Matrix	去中心化	Matrix协议
Mattermost	企业协作	自托管
Google Chat	企业协作	Google Workspace
Email	邮件	SMTP/IMAP
SMS	短信	Twilio等
Home Assistant	IoT平台	智能家居控制

14.2 网关设置

# 启动网关设置向导
hermes gateway setup

# 选择平台并配置
# - Telegram: 输入Bot Token
# - Discord: 输入Bot Token和服务器ID
# - Slack: 输入Webhook URL

# 启动网关
hermes gateway start

# 停止网关
hermes gateway stop

---

十五、最新版本特性（v0.13.0）

15.1 核心更新

类别	特性	说明
架构	提供者插件化	ProviderProfile ABC，第三方无需修改核心
架构	平台插件钩子	env_enablement_fn、cron_deliver_env_var
协作	持久化看板	多Agent团队协作
协作	持久化目标 /goal	锁定Agent到目标，跨回合保持专注
安全	8个P0修复	默认安全策略收紧
多模态	视频理解	video_analyze 工具
语音	xAI Custom Voices	TTS + 声音克隆
i18n	7种语言	中文、日语、德语、西班牙语、法语等

15.2 新支持模型

模型	提供者
deepseek/deepseek-v4-pro	OpenRouter + Nous Portal
x-ai/grok-4.3	OpenRouter + Nous Portal
openrouter/owl-alpha	OpenRouter (免费)
tencent/hy3-preview	OpenRouter (付费)

---

十六、总结与展望

16.1 项目核心优势

优势	说明
自我进化	内置学习循环和技能创建机制，Agent能从经验中成长
高度模块化	插件化架构，工具、记忆、模型均可扩展
多Agent协作	委托系统和看板系统支持真正的团队协作
安全可靠	默认安全策略，多层防护机制
生态丰富	20+消息平台，七种终端后端
社区活跃	149k Stars，1100+贡献者

16.2 技术亮点

1. 自动发现机制 --- 工具、插件、技能的自动注册和发现
2. 同步Agent循环 --- 简洁可控的执行模型
3. 可插拔记忆 --- 支持多种记忆后端
4. 生命周期钩子 --- 灵活的扩展点
5. 持久化状态 --- 会话、检查点、看板的可靠存储

16.3 应用场景

场景	使用方式
个人助手	CLI直接对话，Telegram/Discord远程交互
开发伴侣	代码编写、调试、测试、Git操作
团队协作	看板系统多Agent任务分配
自动化运维	Cron定时任务，CI/CD集成
研究辅助	轨迹生成、数据处理、论文写作

16.4 未来展望

Hermes Agent 作为当前最受关注的开源AI Agent项目之一，其发展方向可能包括：

• 更强的自主学习能力
• 更丰富的MCP集成
• 更完善的调试和可观测性
• 更多垂直领域技能包
• 与现有开发工具链的深度集成

---

参考资源

资源	链接
GitHub仓库	https://github.com/NousResearch/hermes-agent
官方文档	https://hermes-agent.nousresearch.com/docs/
Discord社区	https://discord.gg/NousResearch
Skills Hub	https://agentskills.io
Nous Research	https://nousresearch.com

---

本文档基于 Hermes Agent v0.13.0 版本编写，涵盖了项目的核心架构设计、技术实现和应用场景，旨在帮助开发者深入理解这一强大的自我改进型AI Agent框架。