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

码流怪侠
0 阅读20分钟

一、项目概述与背景

1.1 项目简介

Hermes Agent（项目地址：github.com/NousResearc… 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）

#标准说明
1description ≤ 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 快照
CLIhermes_cli/curator.pyCLI编排
遥测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_memoryCron会话默认不使用记忆

十、插件系统

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.1DISCORD_ALLOWED_ROLES 限定到来源公会
WhatsApp陌生人消息P0默认拒绝陌生人，永不响应自聊
MCP OAuth TOCTOUP0关闭凭据保存时的竞态窗口
auth.json TOCTOUP0关闭凭据写入器的竞态窗口
浏览器SSRFP0云元数据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本地执行开发测试
dockerDocker容器生产隔离
sshSSH远程执行远程服务器
singularitySingularity容器HPC环境
modalModal ServerlessServerless
daytonaDaytona沙箱云沙箱
vercelVercel 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 AssistantIoT平台智能家居控制

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 VoicesTTS + 声音克隆
i18n7种语言中文、日语、德语、西班牙语、法语等

15.2 新支持模型

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

十六、总结与展望

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仓库github.com/NousResearc…
官方文档hermes-agent.nousresearch.com/docs/
Discord社区discord.gg/NousResearc…
Skills Hubagentskills.io
Nous Researchnousresearch.com

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

avatar
文章
阅读
粉丝