多 Agent 编排 —— Spawn 实例与 Tmux 协调、单发模式、PTY 模式、多 Agent 协作
简介
在前面的系列文章中，我们逐一掌握了 Hermes Agent 的方方面面：从核心架构到平台集成，从交互控制到自动化定时任务。你已经能够熟练使用单个 Hermes Agent 完成各种任务。
但现在，让我们面对一个现实：
单个 Agent 有局限性。
- 当一个任务需要同时做代码审查、文档更新、测试编写时，串行执行意味着 3 倍的等待时间
- 当你的项目涉及前端、后端、数据库、运维多个领域时，一个通用的 Agent 可能不如多个专精 Agent 的组合
- 当你想让一个 Agent 写代码，另一个 Agent 审查代码，第三个 Agent 运行测试时——你需要的是多 Agent 协作
这就是 Hermes Agent 的 多 Agent 编排系统 要解决的问题。
多 Agent 编排让 Hermes 能够：
- 动态创建多个 Agent 实例，每个实例可以有独立的模型、工具集、上下文
- 通过 Tmux 协调多个终端会话，实现可视化的多 Agent 管理
- 使用单发模式（Fire-and-forget）快速分发子任务
- 使用 PTY 模式进行交互式多 Agent 协作
- 编排复杂的协作模式：主从、并行、流水线、辩论
读完本文后，你将能够设计和实现多 Agent 协作系统，让多个 AI Agent 像一支团队一样协同工作。
目录
- 多 Agent 编排概述
- Spawn 实例：动态创建 Agent
- Tmux 协调：多会话管理
- 单发模式（Fire-and-forget）
- PTY 模式：交互式协作
- 多 Agent 协作模式
- 实战案例
- 总结与下篇预告
多 Agent 编排概述
为什么需要多 Agent？
┌─────────────────────────────────────────────────────────┐
│ 单 Agent vs 多 Agent │
│ │
│ 单 Agent: │
│ ┌──────────────────────────────────────┐ │
│ │ Agent (gpt-4o) │ │
│ │ │ │
│ │ 1. 审查代码 (2 min) │ │
│ │ 2. 更新文档 (3 min) │ │
│ │ 3. 编写测试 (4 min) │ │
│ │ 4. 运行测试 (1 min) │ │
│ │ │ │
│ │ 总耗时: 10 分钟 │ │
│ └──────────────────────────────────────┘ │
│ │
│ 多 Agent: │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Agent 1 │ │ Agent 2 │ │ Agent 3 │ │ Agent 4 │ │
│ │ 审查代码 │ │ 更新文档 │ │ 编写测试 │ │ 运行测试 │ │
│ │(claude) │ │(gpt-4o) │ │(gpt-4o) │ │(haiku) │ │
│ │ 2 min │ │ 3 min │ │ 4 min │ │ 1 min │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │ │
│ └────────────┴────────────┴────────────┘ │
│ │ │
│ 协调器 │
│ 汇总结果 │
│ │
│ 总耗时: 4 分钟（最慢子任务的时间） │
│ │
└─────────────────────────────────────────────────────────┘多 Agent 架构
┌──────────────────────────────────────────────────────────┐
│ 多 Agent 编排系统 │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 编排器 (Orchestrator) │ │
│ │ │ │
│ │ • 任务分解 │ │
│ │ • Agent 实例管理 │ │
│ │ • 依赖关系调度 │ │
│ │ • 结果聚合 │ │
│ │ • 冲突解决 │ │
│ └───────────────────┬────────────────────────────────┘ │
│ │ │
│ ┌──────────────┼──────────────┐ │
│ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Agent A │ │ Agent B │ │ Agent C │ │
│ │ model: │ │ model: │ │ model: │ │
│ │ gpt-4o │ │ claude │ │ haiku │ │
│ │ │ │ │ │ │ │
│ │ tools: │ │ tools: │ │ tools: │ │
│ │ terminal│ │ terminal│ │ terminal│ │
│ │ read │ │ read │ │ read │ │
│ │ search │ │ write │ │ write │ │
│ │ │ │ patch │ │ │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Tmux 会话协调层 │ │
│ │ │ │
│ │ • 每个 Agent 运行在独立的 Tmux pane │ │
│ │ • 编排器通过 Tmux API 管理 Agent 生命周期 │ │
│ │ • 支持实时监控和手动干预 │ │
│ └────────────────────────────────────────────────────┘ │
│ │
└──────────────────────────────────────────────────────────┘Spawn 实例：动态创建 Agent
什么是 Spawn？
Spawn 是 Hermes Agent 在运行时动态创建新 Agent 实例的能力。每个 Spawn 出来的 Agent 实例是完全独立的：
- 独立的 LLM 调用上下文
- 独立的工具执行环境
- 独立的会话状态
- 可以配置不同的模型和工具集
基本 Spawn 操作
# 在 TUI 中 Spawn 新 Agent
/spawn
# → 正在创建新 Agent 实例...
# → Agent #2 已创建 (session: worker-001)
# → 模型: gpt-4o (继承父 Agent)
# → 工具集: terminal, read_file, write_file, patch, search_files
# Spawn 并指定模型
/spawn --model claude-sonnet-4
# → Agent #3 已创建 (session: worker-002)
# → 模型: claude-sonnet-4
# Spawn 并指定工具集
/spawn --tools terminal,read_file,search_files
# → Agent #4 已创建 (session: worker-003)
# → 工具集: terminal, read_file, search_files（仅 3 个工具）
# Spawn 并指定工作目录
/spawn --workdir /path/to/project
# → Agent #5 已创建
# → 工作目录: /path/to/project
# Spawn 完整配置
/spawn --model haiku --tools terminal --workdir /tmp/sandbox --name test-runner
# → Agent #6 已创建
# → 名称: test-runner
# → 模型: haiku
# → 工具集: terminal
# → 工作目录: /tmp/sandbox查看所有 Spawn 的实例
/spawn list
# → 活跃 Agent 实例:
#
# ┌────┬──────────────┬──────────────┬──────────┬──────────┬────────────┐
# │ ID │ 名称 │ 模型 │ 工具数 │ 状态 │ 运行时间 │
# ├────┼──────────────┼──────────────┼──────────┼──────────┼────────────┤
# │ 1 │ main │ gpt-4o │ 10 │ ● 活跃 │ 2h 15m │
# │ 2 │ worker-001 │ gpt-4o │ 5 │ ● 活跃 │ 45m │
# │ 3 │ worker-002 │ claude-sonnet│ 5 │ ⏳ 工作中 │ 12m │
# │ 4 │ worker-003 │ gpt-4o │ 3 │ ✓ 完成 │ 8m │
# │ 5 │ test-runner │ haiku │ 1 │ ● 活跃 │ 3m │
# └────┴──────────────┴──────────────┴──────────┴──────────┴────────────┘
/spawn status worker-002
# → Agent #3 (worker-002) 状态:
#
# 模型: claude-sonnet-4
# 工具集: terminal, read_file, write_file, patch, search_files
# 工作目录: /opt/data/project
# 会话消息数: 28
# Token 使用: 输入 12,450 / 输出 3,200
# 当前状态: 正在执行 terminal 工具...
# 运行时间: 12m 34s
# 内存使用: 45MB管理 Spawn 实例
# 向指定 Agent 发送指令
/spawn send worker-001 "请审查 src/auth.py 文件"
# → 指令已发送到 Agent #2
# 接收指定 Agent 的输出
/spawn recv worker-001
# → Agent #2 (worker-001) 输出:
# 已完成对 src/auth.py 的审查...
# [审查报告内容]
# 等待 Agent 完成
/spawn wait worker-002
# → 等待 Agent #3 完成...
# → Agent #3 已完成 ✅
# 终止 Agent
/spawn kill worker-003
# → Agent #4 已终止
# 终止所有 Agent
/spawn kill --all
# → 已终止 4 个 Agent 实例（保留主 Agent）Tmux 协调：多会话管理
为什么用 Tmux？
Tmux 是终端复用器，它天然适合作为多 Agent 的协调层：
- 隔离性：每个 Agent 在独立的 pane 中运行，互不干扰
- 可视化：可以同时看到所有 Agent 的实时输出
- 持久性：即使 SSH 断开，Agent 仍在后台运行
- 可编程：通过
tmux命令行 API 可以程序化管理 - 可干预：随时可以 attach 到任意 pane 进行手动操作
启动 Tmux 协调模式
# 启动 Tmux 多 Agent 会话
hermes tmux start --session hermes-agents
# → 创建 Tmux 会话: hermes-agents
# → 创建面板布局:
# ┌──────────────────────────────────┐
# │ 编排器 (0) │
# ├──────────────┬───────────────────┤
# │ Agent A (1) │ Agent B (2) │
# ├──────────────┴───────────────────┤
# │ Agent C (3) │
# └──────────────────────────────────┘
# 指定布局
hermes tmux start --layout even-horizontal
# → 水平均分布局: [Agent A] [Agent B] [Agent C]
hermes tmux start --layout tiled
# → 平铺布局
hermes tmux start --layout main-vertical
# → 左侧大面板 + 右侧多个小面板Tmux 面板管理
# 列出所有面板
hermes tmux panes
# → 会话: hermes-agents
#
# ┌────┬──────────────┬────────┬──────────┐
# │ # │ 名称 │ 大小 │ 状态 │
# ├────┼──────────────┼────────┼──────────┤
# │ 0 │ orchestrator │ 80x10 │ ● 活跃 │
# │ 1 │ agent-a │ 40x20 │ ⏳ 工作 │
# │ 2 │ agent-b │ 40x20 │ ● 等待 │
# │ 3 │ agent-c │ 80x10 │ ✓ 完成 │
# └────┴──────────────┴────────┴──────────┘
# 向面板发送指令
hermes tmux send agent-a "请审查代码"
# → 已向面板 agent-a 发送指令
# 查看面板输出
hermes tmux capture agent-a --lines 20
# → 面板 agent-a 最近 20 行输出:
# [输出内容]
# Attach 到指定面板（手动干预）
hermes tmux attach agent-b
# → 已连接到面板 agent-b
# 按 Ctrl+B 然后 D 返回编排器
# 添加新面板
hermes tmux add --name agent-d --model gpt-4o
# → 已添加面板 agent-d
# 移除面板
hermes tmux remove agent-c
# → 已移除面板 agent-c（Agent 实例保留）
# 调整布局
hermes tmux resize --layout even-vertical
# → 布局已调整为垂直均分Tmux 布局示例
# main-vertical 布局
┌────────────────────────────────────────────────┐
│ 编排器 │
│ 正在协调 3 个 Agent 执行代码审查任务... │
│ [=====> ] 45% │
├───────────────────────┬────────────────────────┤
│ Agent A (审查) │ Agent B (文档) │
│ 分析 main.py... │ 更新 README... │
│ 发现 2 个问题 │ 完成 3 个章节 │
│ ▌ │ ▌ │
├───────────────────────┴────────────────────────┤
│ Agent C (测试) │
│ 生成测试用例... │
│ 已创建 15 个测试 │
│ 正在运行测试... │
│ ▌ │
└────────────────────────────────────────────────┘单发模式（Fire-and-forget）
什么是单发模式？
单发模式是一种"发射后不管"的任务分发方式。你给 Agent 一个任务，它自动执行并返回结果，你不需要等待它完成就可以去做其他事情。
使用单发模式
# 单发模式运行任务
/hermes spawn --mode fire-and-forget "审查 src/ 目录下的所有 Python 文件"
# → 任务已提交 (task-id: task-20250522-001)
# → Agent 正在执行中...
# → 完成后结果将自动发送
# 查看任务状态
/task status task-20250522-001
# → Task: task-20250522-001
# 状态: 执行中
# 进度: 审查 12/45 个文件
# 预计剩余时间: 3 分钟
# 模型: gpt-4o
# 已使用 Token: 8,450
# 等待任务完成
/task wait task-20250522-001
# → 等待中...
# → Task 完成 ✅
# 结果:
# ├── 审查完成: 45 个文件
# ├── 发现问题: 8 个
# ├── 高危: 2 个 (SQL 注入, 路径遍历)
# ├── 中危: 3 个
# └── 低危: 3 个批量单发任务
# 批量分发任务
/task batch <<EOF
{"task": "审查 src/auth/*.py", "model": "claude-sonnet-4", "priority": "high"}
{"task": "审查 src/api/*.py", "model": "gpt-4o", "priority": "medium"}
{"task": "审查 src/utils/*.py", "model": "gpt-4o", "priority": "low"}
{"task": "运行所有单元测试", "model": "haiku", "priority": "high"}
EOF
# → 批量任务已提交
# → 4 个子任务已创建:
# task-20250522-002 (high) - src/auth/*.py 审查
# task-20250522-003 (medium) - src/api/*.py 审查
# task-20250522-004 (low) - src/utils/*.py 审查
# task-20250522-005 (high) - 运行单元测试
# 查看批量任务状态
/task batch-status
# → ┌──────────────────┬──────────┬────────┬──────────┐
# │ 任务 │ 优先级 │ 状态 │ 进度 │
# ├──────────────────┼──────────┼────────┼──────────┤
# │ task-20250522-002│ 高 │ ✓ 完成 │ 100% │
# │ task-20250522-003│ 中 │ ⏳ 执行 │ 67% │
# │ task-20250522-004│ 低 │ ⏳ 执行 │ 23% │
# │ task-20250522-005│ 高 │ ✓ 完成 │ 100% │
# └──────────────────┴──────────┴────────┴──────────┘
#
# 总体进度: 2/4 完成, 2/4 执行中单发模式的结果处理
# 单发任务结果配置
fire_and_forget:
# 结果回调
on_complete:
# 发送结果到 Telegram
- type: "telegram"
chat_id: "-100987654321"
template: |
任务 {{task_id}} 已完成:
{{result}}
# 保存结果到文件
- type: "file"
path: "~/results/{{task_id}}.md"
# 错误处理
on_error:
# 重试
retry:
max_attempts: 2
delay: 60
# 错误通知
notify:
- type: "telegram"
chat_id: "-100987654321"
template: |
⚠️ 任务 {{task_id}} 执行失败:
{{error}}PTY 模式：交互式协作
什么是 PTY 模式？
PTY（Pseudo Terminal）模式允许你在一个伪终端中与 Agent 进行交互式对话。在多 Agent 场景中，PTY 模式让多个 Agent 可以在各自的终端中进行实时交互式协作。
启动 PTY 模式
# 启动 PTY 模式
hermes pty start
# → PTY 模式已启动
# → 连接到 /dev/pts/2
# → 输入 'exit' 或 Ctrl+D 退出
# 在 PTY 模式下交互
PTY> 帮我重构这个模块
Agent: 好的，让我先查看代码结构...
[调用 search_files]
[调用 read_file]
我发现了 3 个可以改进的地方...
PTY> 先从数据库层开始
Agent: 好的，让我重构数据库层...
[调用 write_file]
[调用 patch]
数据库层重构完成...
PTY> /spawn --pty --model claude
PTY> 请审查刚才的数据库层重构
PTY(spawn-1): 好的，让我检查修改...
我发现了以下问题:
1. 缺少事务处理...
2. 连接池配置需要优化...
PTY> 好的，我来修复这些问题PTY 模式下的多 Agent 协作
# 创建 PTY 会话并启动多 Agent
hermes pty session --name code-review
# → PTY 会话已创建: code-review
# → 会话 ID: pts-3
# 在会话中添加 Agent
/hermes pty add --name reviewer --model claude-sonnet-4
# → 已添加 reviewer Agent
/hermes pty add --name tester --model gpt-4o
# → 已添加 tester Agent
# 切换到指定 Agent
/hermes pty switch reviewer
# → 已切换到 reviewer Agent
# reviewer> 开始审查代码...
/hermes pty switch tester
# → 已切换到 tester Agent
# tester> 开始编写测试...
# 广播消息给所有 Agent
/hermes pty broadcast "代码已更新，请重新审查"
# → 消息已广播给 3 个 Agent
# reviewer> 收到，重新审查中...
# tester> 收到，更新测试用例...
# 查看会话状态
/hermes pty status
# → PTY 会话: code-review
# Agent 列表:
# - main (gpt-4o) ● 活跃
# - reviewer (claude) ⏳ 工作中
# - tester (gpt-4o) ● 等待PTY 模式 vs 单发模式
| 特性 | 单发模式 | PTY 模式 |
|---|---|---|
| 交互性 | 无（一次性任务） | 有（持续对话） |
| 适用场景 | 简单的独立任务 | 需要多轮对话的任务 |
| 结果返回 | 完成后一次性返回 | 实时流式输出 |
| 资源占用 | 低 | 较高 |
| 并发能力 | 高（可批量分发） | 中（受终端数限制） |
多 Agent 协作模式
模式 1：主从模式（Manager-Worker）
主 Agent 负责任务分解和结果汇总，多个 Worker Agent 并行执行子任务。
┌─────────────────────────────────────┐
│ Manager Agent │
│ (gpt-4o) │
│ │
│ 1. 分析需求，分解任务 │
│ 2. 分发子任务给 Worker │
│ 3. 等待所有 Worker 完成 │
│ 4. 汇总结果，生成最终输出 │
└──────────┬──────┬──────┬─────────────┘
│ │ │
┌─────┘ │ └─────┐
▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐
│Worker 1 │ │Worker 2 │ │Worker 3 │
│代码审查 │ │文档更新 │ │测试编写 │
│claude │ │gpt-4o │ │gpt-4o │
└─────────┘ └─────────┘ └─────────┘# 主从模式编排脚本
from hermes.orchestrate import Orchestrator
orchestrator = Orchestrator(mode="manager-worker")
# 定义任务
task = """
对以下 PR 进行完整审查：
- 代码质量审查
- 文档更新
- 测试用例编写
PR 链接: https://github.com/org/repo/pull/123
"""
# 配置 Worker
orchestrator.add_worker(
name="code-reviewer",
model="claude-sonnet-4",
system_prompt="你是一个资深的代码审查专家，关注代码质量、安全性和最佳实践。",
tools=["terminal", "read_file", "search_files", "patch"],
)
orchestrator.add_worker(
name="doc-writer",
model="gpt-4o",
system_prompt="你是一个技术文档专家，擅长编写清晰、准确的技术文档。",
tools=["terminal", "read_file", "write_file"],
)
orchestrator.add_worker(
name="test-engineer",
model="gpt-4o",
system_prompt="你是一个测试工程师，擅长编写全面的单元测试和集成测试。",
tools=["terminal", "read_file", "write_file"],
)
# 执行
result = orchestrator.run(task)
print(result.summary)模式 2：并行模式（Parallel）
多个 Agent 并行执行相同任务的不同部分，最后合并结果。
┌──────────────────────────────────────────────┐
│ 协调器 │
│ │
│ 将大文件拆分为多个部分，分发给不同 Agent │
└────┬──────┬──────┬──────┬────────────────────┘
│ │ │ │
▼ ▼ ▼ ▼
┌──────┐┌──────┐┌──────┐┌──────┐
│Part 1││Part 2││Part 3││Part 4│
│审查 ││审查 ││审查 ││审查 │
└──┬───┘└──┬───┘└──┬───┘└──┬───┘
│ │ │ │
└───────┴───────┴───────┘
│
▼
┌──────────────────────────────────┐
│ 结果合并 │
│ 合并 4 个部分的审查结果 │
│ 去重、排序、生成最终报告 │
└──────────────────────────────────┘# 并行模式编排脚本
from hermes.orchestrate import Orchestrator
orchestrator = Orchestrator(mode="parallel")
# 定义并行任务
# 将大文件列表拆分为 4 组，每组由一个 Agent 审查
files = [f"src/{f}.py" for f in [
"auth", "api", "models", "utils",
"config", "middleware", "validators", "serializers",
"managers", "signals", "admin", "templatetags"
]]
orchestrator.split(files, chunks=4) # 分为 4 组
orchestrator.add_worker(
model="gpt-4o",
system_prompt="审查 Python 代码，关注安全性和性能问题。",
tools=["read_file", "search_files"],
prompt_template="请审查以下文件:\n{files}\n\n生成审查报告。",
)
# 配置合并逻辑
orchestrator.set_merger("""
请合并以下审查报告:
{reports}
要求:
1. 去除重复的问题
2. 按严重程度排序
3. 按模块分组
4. 生成汇总统计
""")
result = orchestrator.run()模式 3：流水线模式（Pipeline）
Agent 按顺序串联，前一个 Agent 的输出作为后一个 Agent 的输入。
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Agent 1 │───▶│ Agent 2 │───▶│ Agent 3 │───▶│ Agent 4 │
│ 代码生成 │ │ 代码审查 │ │ 测试编写 │ │ 测试执行 │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
gpt-4o claude-sonnet gpt-4o haiku
输出: 输出: 输出: 输出:
源码文件 审查意见+ 测试文件 测试报告
修改后代码# 流水线模式编排脚本
from hermes.orchestrate import Orchestrator
orchestrator = Orchestrator(mode="pipeline")
# 定义流水线阶段
orchestrator.add_stage(
name="generate",
model="gpt-4o",
prompt="根据以下需求生成 Python 代码:\n{requirements}\n\n只输出代码，不要解释。",
tools=["write_file"],
)
orchestrator.add_stage(
name="review",
model="claude-sonnet-4",
prompt="审查以下代码，指出问题并修复:\n{input}\n\n输出修复后的完整代码。",
tools=["read_file", "patch"],
)
orchestrator.add_stage(
name="test",
model="gpt-4o",
prompt="为以下代码编写全面的单元测试:\n{input}\n\n输出测试代码。",
tools=["read_file", "write_file"],
)
orchestrator.add_stage(
name="verify",
model="haiku",
prompt="运行测试并报告结果:\n{input}\n",
tools=["terminal"],
)
# 执行流水线
requirements = "实现一个线程安全的缓存类，支持 TTL 过期和 LRU 淘汰。"
result = orchestrator.run(requirements=requirements)模式 4：辩论模式（Debate）
多个 Agent 就同一个问题提出不同观点，最终由裁决 Agent 做出决策。
┌──────────────────────────────────────────────┐
│ 议题: 使用哪种架构？ │
│ "微服务 vs 单体" │
└──────────┬───────────────────┬───────────────┘
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ Agent A (正方) │ │ Agent B (反方) │
│ 支持微服务 │ │ 支持单体 │
│ "可扩展性好..." │ │ "部署简单..." │
└────────┬─────────┘ └────────┬──────────┘
│ │
└──────────┬──────────┘
│
▼
┌──────────────────────────────────────────────┐
│ 多轮辩论 │
│ 第一轮: 陈述立场 │
│ 第二轮: 反驳对方 │
│ 第三轮: 总结陈词 │
└──────────────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────────────┐
│ 裁决 Agent │
│ 综合双方论点，给出推荐方案 │
│ 说明选择理由 │
└──────────────────────────────────────────────┘# 辩论模式编排脚本
from hermes.orchestrate import Orchestrator
orchestrator = Orchestrator(mode="debate")
# 定义议题
topic = "我们的新项目应该使用微服务架构还是单体架构？"
# 配置辩论双方
orchestrator.add_debater(
side="pro",
name="微服务支持者",
model="gpt-4o",
position="微服务架构",
arguments=[
"独立部署和扩展",
"技术栈自由选择",
"故障隔离",
"团队自治",
],
)
orchestrator.add_debater(
side="con",
name="单体架构支持者",
model="claude-sonnet-4",
position="单体架构",
arguments=[
"开发和部署简单",
"调试方便",
"数据一致性好",
"适合小型团队",
],
)
# 配置裁决
orchestrator.set_judge(
model="gpt-4o",
prompt="请综合以上辩论双方的论点，给出你的推荐和建议。",
)
# 执行辩论
result = orchestrator.run(topic=topic, rounds=3)
print(result.judgment)实战案例
实战 1：自动化 PR 审查流水线
"""
自动化 PR 审查流水线
触发: 新 PR 创建时（通过 Webhook）
执行: 并行代码审查 + 安全检查 + 文档检查 → 汇总报告
"""
from hermes.orchestrate import Orchestrator
import os
class PRReviewPipeline:
def __init__(self, pr_number):
self.pr_number = pr_number
self.orchestrator = Orchestrator(mode="parallel")
def setup(self):
# 获取 PR 信息
import subprocess
result = subprocess.run(
["gh", "pr", "view", str(self.pr_number), "--json", "files,body,title"],
capture_output=True, text=True
)
self.pr_info = result.stdout
# 获取变更文件列表
result = subprocess.run(
["gh", "pr", "diff", str(self.pr_number)],
capture_output=True, text=True
)
self.diff = result.stdout
def run(self):
self.setup()
# 配置并行 Worker
self.orchestrator.add_worker(
name="code-reviewer",
model="claude-sonnet-4",
prompt=f"审查以下代码变更，关注代码质量和最佳实践:\n\n{self.diff}",
max_tokens=4096,
)
self.orchestrator.add_worker(
name="security-scanner",
model="gpt-4o",
prompt=f"审查以下代码变更，关注安全问题（注入、XSS、CSRF 等）:\n\n{self.diff}",
max_tokens=2048,
)
self.orchestrator.add_worker(
name="doc-checker",
name="文档检查器",
model="gpt-4o-mini",
prompt=f"检查以下代码变更是否同步更新了文档:\n\nPR 描述: {self.pr_info}\n代码变更: {self.diff}",
max_tokens=1024,
)
# 配置合并
self.orchestrator.set_merger("""
合并以下审查报告，生成一份结构化的 PR 审查摘要:
代码审查: {code-reviewer}
安全审查: {security-scanner}
文档检查: {doc-checker}
格式:
## PR 审查摘要
### 代码质量
[代码审查结果]
### 安全问题
[安全审查结果]
### 文档
[文档检查结果]
### 建议
[综合建议]
### 结论
[Approve / Request Changes / Comment]
""")
return self.orchestrator.run()
# 执行
pipeline = PRReviewPipeline(pr_number=123)
result = pipeline.run()
print(result)实战 2：多 Agent 系统调试
"""
多 Agent 系统调试
场景: 系统出现性能问题，多个 Agent 从不同角度分析
"""
from hermes.orchestrate import Orchestrator
def debug_system():
orchestrator = Orchestrator(mode="manager-worker")
# Manager: 协调调试
orchestrator.manager_prompt = """
系统出现性能问题。请将调试任务分解并分发给 Worker:
1. 分析数据库查询性能
2. 分析 API 响应时间
3. 分析内存和 CPU 使用
4. 分析网络 I/O
汇总所有 Worker 的结果，给出诊断报告和修复建议。
"""
# Worker 1: 数据库分析
orchestrator.add_worker(
name="db-analyst",
model="gpt-4o",
system_prompt="你是数据库性能专家。",
prompt="""
分析数据库性能:
1. 运行: EXPLAIN ANALYZE <慢查询>
2. 检查索引使用情况
3. 分析查询计划
4. 给出优化建议
""",
tools=["terminal", "read_file"],
)
# Worker 2: API 分析
orchestrator.add_worker(
name="api-analyst",
model="claude-sonnet-4",
system_prompt="你是 API 性能专家。",
prompt="""
分析 API 性能:
1. 检查慢请求日志: grep "response_time>1000" /var/log/api.log
2. 识别最慢的端点
3. 分析请求链路
4. 给出优化建议
""",
tools=["terminal", "search_files"],
)
# Worker 3: 资源分析
orchestrator.add_worker(
name="resource-analyst",
model="gpt-4o",
system_prompt="你是系统资源分析专家。",
prompt="""
分析系统资源使用:
1. top -bn1 | head -20
2. free -h
3. df -h
4. iostat -x 1 5
5. 分析内存泄漏、CPU 瓶颈、磁盘 I/O
""",
tools=["terminal"],
)
return orchestrator.run()
result = debug_system()
print(result.summary)实战 3：Tmux + Spawn 多 Agent 编码会话
# 启动 Tmux 编码会话
hermes tmux start --session coding --layout main-vertical
# 添加编码 Agent
hermes tmux add --name coder --model gpt-4o --tools terminal,read_file,write_file,patch
hermes tmux add --name reviewer --model claude-sonnet-4 --tools terminal,read_file,search_files
# 向 coder 发送任务
hermes tmux send coder "实现一个 REST API 的用户认证模块，包括登录、注册、token 刷新"
# 等待 coder 完成
hermes tmux wait coder
# 向 reviewer 发送审查任务
hermes tmux send reviewer "审查 coder 刚完成的认证模块代码，关注安全性和最佳实践"
# 等待 reviewer 完成
hermes tmux wait reviewer
# 查看 reviewer 的输出
hermes tmux capture reviewer
# 如果有问题，向 coder 发送修改指令
hermes tmux send coder "根据 reviewer 的意见修改以下问题:\n[问题列表]"
# 循环直到满意总结与下篇预告
总结
本文全面介绍了 Hermes Agent 的多 Agent 编排系统：
核心要点：
Spawn 实例让你动态创建 Agent —— 每个实例独立运行，可以配置不同的模型、工具集、工作目录。这是多 Agent 协作的基础设施。
Tmux 协调提供了可视化的多 Agent 管理 —— 每个 Agent 在独立的 pane 中运行，你可以实时看到所有 Agent 的状态和输出，随时进行手动干预。
单发模式（Fire-and-forget）适合独立子任务 —— 你分发任务后不需要等待，结果会自动返回。支持批量分发、优先级调度、结果回调。
PTY 模式适合需要多轮对话的协作场景 —— 多个 Agent 在各自的终端中持续交互，编排者可以随时切换和广播。
四种协作模式覆盖绝大多数场景：
- 主从模式：Manager 分解任务，Worker 并行执行，Manager 汇总结果
- 并行模式：将大任务拆分，多个 Agent 并行处理，最后合并
- 流水线模式：Agent 按顺序串联，前一个的输出是后一个的输入
- 辩论模式：多个 Agent 就同一问题提出不同观点，裁决 Agent 做决策
最佳实践建议：
- 选择合适的协作模式：简单并行用并行模式，有依赖用流水线，复杂决策用辩论
- 为不同任务选择合适模型：复杂推理用 gpt-4o/claude，简单任务用 haiku 节省成本
- 用 Tmux 监控长时间运行的多 Agent 任务，随时可以介入
- 为关键任务配置超时和失败重试，避免 Agent 卡死
- 合理控制 Spawn 的 Agent 数量，避免并发过多导致 API 限流
下篇预告
生产环境部署 —— Docker 容器化、Kubernetes 编排、监控与告警、高可用架构
在下一篇文章中，我们将把 Hermes Agent 从开发环境推向生产环境：
- Docker 容器化：构建 Hermes Agent 的 Docker 镜像，配置多阶段构建
- Kubernetes 编排：在 K8s 上部署多 Agent 集群，配置自动扩缩容
- 监控与告警：集成 Prometheus + Grafana，监控 Agent 健康状态和性能指标
- 高可用架构：多实例部署、故障转移、数据持久化、备份恢复
从开发到生产，让 Hermes Agent 在真实环境中稳定、高效地运行。
敬请期待！