10 第8章多 Agent 协作

10.1 为什么要多 Agent

单 Agent 已经很强大了，为什么要折腾多个？答案很简单：不同的模型各有所长。

模型	强项	弱项	适合场景
Claude Sonnet 4.5	代码质量高、遵循指令好	速度一般、价格中等	核心业务代码编写
GPT-5.6	推理能力强、上下文窗口大	代码风格偏保守	架构设计、编排决策
Kimi K2	中文理解优秀、性价比高	复杂逻辑偶有错误	中文文档、前端组件
Grok Code	速度快、擅长 code review	创新性不足	代码审查、快速修复
DeepSeek V3.5	开源、成本低	指令遵循略弱	批量生成、测试用例

没有任何一个模型在所有方面都是最优的。如果你能让不同模型分工协作，你就能得到 1+1 > 2 的效果。

Herdr 的多 Agent 能力让这成为可能——在一个工作空间中同时运行多个 Agent，各司其职。

10.2 Herdr 的 Agent Skill 机制

10.2.1 问题：Agent 不知道怎么操作 Herdr

Claude Code、GPT-5.6 等 Coding Agent 本身并不知道 Herdr 的存在。它们不知道怎么 split pane、怎么启动另一个 Agent、怎么读取其他 pane 的输出。

10.2.2 解决方案：SKILL.md

Herdr 提供了一个 Skill 包——本质上是一份给 Agent 阅读的”操作手册”。安装后，Agent 就能学会如何操作 Herdr。

10.2.3 安装 Skill

# 全局安装 Herdr Skill
npx skills add herdrdev/herdr --skill herdr -g

# 输出：
# ✅ Skill 'herdr' installed
# 📍 Location: ~/.skills/herdr/SKILL.md
# 🔗 Linked to global agent config

安装后，Claude Code（以及其他支持 SKILL.md 的 Agent）会自动读取这个文件，学会如何操作 Herdr。

10.2.4 SKILL.md 核心内容解读

SKILL.md 教会 Agent 以下能力：

# Herdr Agent Skill

## 核心概念
- Workspace：当前 Herdr 工作空间
- Tab：标签页
- Pane：标签页内的终端面板
- Agent：被 Herdr 识别的 Coding Agent 实例

## 可用命令

### Layout 操作
- `herdr layout split vertical` — 垂直分屏
- `herdr layout split horizontal` — 水平分屏
- `herdr tab new [name]` — 新建标签页
- `herdr tab goto <name>` — 跳转标签页

### Pane 操作
- `herdr pane run <id> <command>` — 在指定 pane 执行命令
- `herdr pane wait-output <id>` — 等待 pane 输出
- `herdr pane read <id>` — 读取 pane 输出
- `herdr pane focus <id>` — 聚焦到 pane

### Agent 管理
- `herdr agent start --model <model> --prompt <prompt>` — 启动 Agent
- `herdr agent wait <id>` — 等待 Agent 完成
- `herdr agent read <id>` — 读取 Agent 输出
- `herdr agent prompt <id> <text>` — 向 Agent 发送消息

## 安全规则
- 不要关闭其他 Agent 的 pane
- 不要抢夺其他 pane 的焦点
- 所有操作基于 JSON ID，不要猜测

Agent 怎么学会的？

当 Claude Code 启动时，它会扫描 ~/.skills/ 目录下的所有 SKILL.md 文件，将其内容加载到 system prompt 中。这意味着 Agent 从第一轮对话就知道怎么操作 Herdr 了。

10.3 模式一：主 Agent 编排（Orchestrator）

这是最强大的多 Agent 模式。一个”主 Agent”负责思考和决策，它通过 Herdr 命令启动和编排其他 Agent。

10.3.1 架构

graph TD
    O["Orchestrator Agent<br/>GPT-5.6"] --> |herdr agent start| A1["Worker Agent 1<br/>Claude Sonnet"]
    O --> |herdr agent start| A2["Worker Agent 2<br/>Kimi K2"]
    O --> |herdr agent start| A3["Worker Agent 3<br/>Grok Code"]
    
    O --> |herdr agent wait| A1
    O --> |herdr agent wait| A2
    O --> |herdr agent wait| A3
    
    A1 --> |herdr agent read| O
    A2 --> |herdr agent read| O
    A3 --> |herdr agent read| O
    
    O --> |汇总 + 整合| R[最终输出]

10.3.2 完整编排示例

在一个标签页中启动 GPT-5.6 作为编排者：

# 启动编排 Agent
gpt-5.6

# 给它以下指令：

> 我需要你帮我完成一个全栈应用的开发。你是编排者，不要自己写代码。
> 
> 请按以下步骤操作：
> 1. 在 Herdr 中分出 3 个 pane
> 2. 在 pane 1 启动 Claude Sonnet，让它编写后端 API
> 3. 在 pane 2 启动 Kimi K2，让它编写前端页面
> 4. 在 pane 3 启动 Grok Code，让它编写测试用例
> 5. 等待所有 Agent 完成后，读取各自输出
> 6. 检查是否有冲突，协调修复

GPT-5.6 会使用 Herdr Skill 中的命令来编排：

# GPT-5.6 执行的命令（自动生成）：

# 步骤 1：分屏
herdr layout split vertical
herdr layout split vertical

# 步骤 2：启动后端 Agent（pane 1）
herdr agent start --model claude-sonnet-4.5 \
  --prompt "在 ~/projects/fullstack-app/backend 目录下，使用 Express.js 开发用户认证和文章 CRUD API。需要：注册、登录、JWT中间件、文章的增删改查。数据库用 MongoDB。"

# 输出：{"agentId": "agent-a1b2c3", "status": "started"}

# 步骤 3：启动前端 Agent（pane 2）
herdr agent start --model kimi-k2 \
  --prompt "在 ~/projects/fullstack-app/frontend 目录下，使用 React + Vite 开发前端页面。需要：登录注册页面、文章列表页、文章编辑器。调用后端 API：http://localhost:3000/api"

# 输出：{"agentId": "agent-d4e5f6", "status": "started"}

# 步骤 4：启动测试 Agent（pane 3）
herdr agent start --model grok-code \
  --prompt "在 ~/projects/fullstack-app/tests 目录下，为这个全栈应用编写端到端测试。使用 Playwright。覆盖：用户注册登录流程、文章 CRUD 流程。"

# 输出：{"agentId": "agent-g7h8i9", "status": "started"}

# 步骤 5：等待所有 Agent 完成
herdr agent wait agent-a1b2c3
herdr agent wait agent-d4e5f6
herdr agent wait agent-g7h8i9

# 步骤 6：读取各自输出
herdr agent read agent-a1b2c3
herdr agent read agent-d4e5f6
herdr agent read agent-g7h8i9

# 步骤 7：协调冲突（如果有）
# GPT-5.6 分析三个 Agent 的输出，发现 API 路径不一致
# 自动发消息给前端 Agent 修正
herdr agent prompt agent-d4e5f6 \
  "后端 API 的文章列表路径是 /api/articles（不是 /api/posts），请修正前端调用路径"

10.3.3 Bash 脚本编排（替代方案）

如果你不想用 GPT-5.6 做编排者，也可以用简单的 Bash 脚本：

#!/bin/bash
# orchestrate.sh — 多 Agent 编排脚本

echo "🚀 启动多 Agent 编排..."

# 分屏
herdr layout split vertical
herdr layout split vertical

# 启动后端 Agent
BACKEND_ID=$(herdr agent start \
  --model claude-sonnet-4.5 \
  --prompt "开发 Express.js 后端 API，包含用户认证和文章 CRUD" \
  | jq -r '.agentId')

echo "📋 后端 Agent: $BACKEND_ID"

# 启动前端 Agent
FRONTEND_ID=$(herdr agent start \
  --model kimi-k2 \
  --prompt "开发 React 前端页面，调用后端 API" \
  | jq -r '.agentId')

echo "📋 前端 Agent: $FRONTEND_ID"

# 启动测试 Agent
TEST_ID=$(herdr agent start \
  --model grok-code \
  --prompt "编写 Playwright 端到端测试" \
  | jq -r '.agentId')

echo "📋 测试 Agent: $TEST_ID"

# 等待所有完成
echo "⏳ 等待所有 Agent 完成..."
herdr agent wait $BACKEND_ID
herdr agent wait $FRONTEND_ID  
herdr agent wait $TEST_ID

# 读取结果
echo "📄 后端输出："
herdr agent read $BACKEND_ID

echo "📄 前端输出："
herdr agent read $FRONTEND_ID

echo "📄 测试输出："
herdr agent read $TEST_ID

echo "✅ 编排完成！"

10.4 模式二：写→审查流水线

这是一种更精细的协作模式。不是让多个 Agent 同时写不同部分，而是让它们形成流水线。

10.4.1 架构

graph LR
    A["Kimi K2<br/>编写代码"] --> B["Herdr<br/>自动切换"]
    B --> C["Grok Code<br/>审查代码"]
    C --> |通过| D[✅ 合并]
    C --> |有问题| A

10.4.2 完整流程

# 步骤 1：Kimi 写代码
# 在 agent-write 标签页
kimik2

# > 请实现用户注册接口，包含密码哈希、输入验证、错误处理

# Kimi 完成后...

# 步骤 2：通过 Herdr 启动 code review
# 在 orchestrator 标签页执行
herdr agent start \
  --model grok-code \
  --prompt "请审查 src/controllers/authController.js 的代码质量。重点检查：安全性（SQL注入、XSS）、错误处理、代码风格。给出具体的修改建议。"

# 等待 review 完成
herdr agent wait <review-agent-id>

# 读取 review 结果
herdr agent read <review-agent-id>

# 如果有问题，反馈给 Kimi
herdr agent prompt <write-agent-id> \
  "Code review 发现以下问题：1. 密码哈希使用了过时的 MD5，请改用 bcrypt。2. 缺少 rate limiting。请修复。"

10.4.3 自动化流水线脚本

#!/bin/bash
# pipeline.sh — 写→审查流水线

WRITE_AGENT=$1  # 编写 Agent 的 ID
FILE_PATTERN=$2  # 要审查的文件模式

echo "📝 等待编写 Agent 完成..."
herdr agent wait $WRITE_AGENT

echo "🔍 启动 code review..."
REVIEW_ID=$(herdr agent start \
  --model grok-code \
  --prompt "审查以下文件的代码质量：$FILE_PATTERN。输出 JSON 格式的审查结果，包含 {severity, file, line, issue, suggestion}。" \
  | jq -r '.agentId')

herdr agent wait $REVIEW_ID

echo "📊 审查结果："
herdr agent read $REVIEW_ID

# 解析审查结果，如果有严重问题，自动反馈
ISSUES=$(herdr agent read $REVIEW_ID | jq '[.[] | select(.severity == "critical")] | length')

if [ "$ISSUES" -gt 0 ]; then
  echo "⚠️ 发现 $ISSUES 个严重问题，反馈给编写 Agent..."
  herdr agent prompt $WRITE_AGENT \
    "Code review 发现 $(herdr agent read $REVIEW_ID | jq '.[] | select(.severity == "critical")') 个严重问题，请修复。"
fi

10.5 模式三：人机协作

多 Agent 不意味着把人排除在外。最有生产力的模式往往是人 + 多 Agent的混合协作。

10.5.1 工作方式

┌──────────────────────────────────────────────┐
│  Tab: workspace                              │
├──────────────┬───────────────┬───────────────┤
│              │               │               │
│  Agent A     │  你（人类）   │  Agent B      │
│  (写代码)    │  (审查/决策)  │  (写测试)     │
│              │               │               │
├──────────────┴───────────────┴───────────────┤
│  你随时可以切入任意 pane                      │
│  - 在 Agent A 的 pane 中打断它               │
│  - 修改 Agent B 正在测试的文件               │
│  - 然后放手，让 Agent 继续                   │
└──────────────────────────────────────────────┘

10.5.2 具体操作

# Agent A 正在写代码，你想介入

# 1. 切到 Agent A 的 pane
herdr pane focus pane-a1b2c3

# 2. 直接在 Agent 的终端中输入（Claude Code 支持打断）
# 按 Escape 打断 Agent
# 然后输入你的指示
> 等一下，不要用 axios，改用 fetch。这个项目不想引入额外依赖。

# 3. Agent A 会重新调整方案

# 4. 同时你可以切到 Agent B 的 pane
herdr pane focus pane-d4e5f6

# 5. 手动运行一下测试看看
npm test

# 6. 然后放手，让 Agent B 继续工作

人机协作的关键

人类的价值在于判断和决策，Agent 的价值在于执行效率。让人做决策（用什么技术栈、怎么设计架构、哪个方案更好），让 Agent 做执行（写样板代码、跑测试、修 bug）。

10.6 三大原语（Primitives）详解

Herdr 的多 Agent 能力建立在三个核心原语之上。理解它们，你就能组合出任意复杂的工作流。

10.6.1 1. Layout（布局）

Layout 描述了工作空间的物理拓扑：

graph TD
    WS[Workspace] --> T1[Tab: main]
    WS --> T2[Tab: agents]
    WS --> T3[Tab: logs]
    
    T2 --> P1[Pane: agent-backend]
    T2 --> P2[Pane: agent-frontend]
    T2 --> P3[Pane: agent-tests]

Layout 操作命令：

# 标签页操作
herdr tab new agents        # 新建标签页
herdr tab goto agents       # 跳转到标签页
herdr tab close agents      # 关闭标签页
herdr tab list              # 列出所有标签页

# Pane 操作
herdr layout split vertical    # 垂直分屏（左右）
herdr layout split horizontal  # 水平分屏（上下）
herdr layout close             # 关闭当前 pane

10.6.2 2. Pane（终端面板）

Pane 是最基本的控制单元——就是一个终端。Herdr 可以通过 ID 管理任意 pane：

# 每个 pane 有唯一 ID
herdr pane list
# 输出：
# pane-a1b2 | tab: main   | "vim src/index.ts"
# pane-c3d4 | tab: agents | "claude"
# pane-e5f6 | tab: agents | "kimik2"
# pane-g7h8 | tab: logs   | "tail -f app.log"

# 在指定 pane 中运行命令
herdr pane run pane-c3d4 "echo hello"

# 等待 pane 中的命令完成
herdr pane wait-output pane-c3d4

# 读取 pane 的输出历史
herdr pane read pane-c3d4
herdr pane read pane-c3d4 --lines 50  # 最后 50 行

10.6.3 3. Agent（智能体生命周期）

Agent 是 Pane 的上层抽象。Pane 是通用终端，Agent 是被识别的 Coding Agent 实例：

# 启动 Agent
herdr agent start \
  --model claude-sonnet-4.5 \
  --prompt "实现用户认证模块" \
  --cwd ~/projects/my-app
# 返回：{"agentId": "agent-x1y2z3", "paneId": "pane-c3d4", "status": "started"}

# 等待 Agent 完成（阻塞直到 Agent 进入 idle 状态）
herdr agent wait agent-x1y2z3

# 读取 Agent 的输出
herdr agent read agent-x1y2z3

# 向 Agent 发送新的 prompt
herdr agent prompt agent-x1y2z3 "现在请添加密码重置功能"

# 查看 Agent 状态
herdr agent status agent-x1y2z3
# 输出：{"agentId": "agent-x1y2z3", "status": "working", "duration": "5m23s", "filesChanged": 8}

10.6.4 三者的关系

graph TD
    L[Layout] --> |包含| T[Tab]
    T --> |包含| P[Pane]
    P --> |可以是| A[Agent]
    P --> |也可以是| S[普通 Shell]
    
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style S fill:#eee,stroke:#333

核心理解

Layout 管”在哪”——工作空间的物理布局
Pane 管”做什么”——终端中运行的命令
Agent 管”做得怎样”——智能体的状态和生命周期

所有 Herdr 的多 Agent 命令，都是对这三个原语的组合操作。

10.7 `agent` 命令完整工作流

让我们用一个完整的示例串联 agent 相关的所有命令：

# 1. 启动第一个 Agent（后端开发）
herdr agent start \
  --model claude-sonnet-4.5 \
  --prompt "在 backend/ 目录下开发 Express API" \
  --cwd ~/projects/my-app
# → {"agentId": "agent-001", "paneId": "pane-a", "status": "started"}

# 2. 启动第二个 Agent（前端开发）
herdr agent start \
  --model kimi-k2 \
  --prompt "在 frontend/ 目录下开发 React 页面" \
  --cwd ~/projects/my-app
# → {"agentId": "agent-002", "paneId": "pane-b", "status": "started"}

# 3. 检查状态
herdr agent status agent-001
# → {"status": "working", "duration": "3m12s"}

herdr agent status agent-002
# → {"status": "blocked", "duration": "2m45s", "reason": "waiting for user input"}

# 4. Agent 002 被阻塞了，查看它需要什么
herdr agent read agent-002
# → "我需要确认：前端使用 TypeScript 还是 JavaScript？"

# 5. 回答它
herdr agent prompt agent-002 "使用 TypeScript"

# 6. 等待两个 Agent 都完成
herdr agent wait agent-001
herdr agent wait agent-002

# 7. 读取最终输出
herdr agent read agent-001
herdr agent read agent-002

# 8. 让 Agent 001 做后续工作
herdr agent prompt agent-001 \
  "前端已经完成，请根据前端的 API 调用调整后端路由。前端调用的路径是 /api/v1/users"

10.8 `pane` 命令：原始终端控制

当你不需要 Agent 级别的管理，只想控制终端时，用 pane 命令：

# 在指定 pane 运行命令
herdr pane run pane-x "npm install"
herdr pane run pane-x "npm run build"

# 等待命令完成（检测 shell prompt 回归）
herdr pane wait-output pane-x

# 读取输出
herdr pane read pane-x --lines 100

# 发送按键（模拟键盘输入）
herdr pane send-keys pane-x "test" Enter

# 停止 pane 中的进程
herdr pane send-keys pane-x C-c

10.9 Alternate-Screen 输出限制

10.9.1 问题

许多 TUI 程序（vim, less, htop, Claude Code 的某些界面）使用 alternate screen（备用屏幕）。当这些程序运行时，它们会切换到一个干净的终端缓冲区，之前的内容被”藏起来”了。

这意味着：

# ❌ 这个时候读取 pane 输出，可能得不到有用信息
herdr pane read pane-x
# 因为 Claude Code 正在 alternate screen 中渲染 UI
# 读取到的是 alternate screen 的内容，不是对话历史

10.9.2 解决方案

方案	适用场景	命令
使用 `agent read` 代替	Agent 级别的读取	`herdr agent read <id>`
设置 `--no-tui`	Agent 启动时禁用 TUI	`claude --no-tui`
使用日志文件	让 Agent 输出到文件	`claude --output log.txt`
等待 Agent 完成	完成后会退出 alt screen	`herdr agent wait <id>`

# 最佳实践：让 Agent 输出到日志文件
herdr agent start \
  --model claude-sonnet-4.5 \
  --prompt "开发 API" \
  -- --output /tmp/agent-backend.log

# 然后读取日志
tail -f /tmp/agent-backend.log

10.10 实战案例：三 Agent 并行开发全栈应用

让我们用一个完整的案例来演示多 Agent 协作的威力。

10.10.1 项目背景

开发一个任务管理系统（类似 Trello），包含： - 后端：Node.js + Express + PostgreSQL - 前端：React + TypeScript + Tailwind - 测试：Playwright 端到端测试

10.10.2 准备工作

# 创建项目目录
mkdir -p ~/projects/task-app/{backend,frontend,tests}
cd ~/projects/task-app

# 初始化 Git
git init

# 启动 Herdr
herdr

10.10.3 创建布局

# 标签页 1: orchestrator（编排控制）
# 标签页 2: backend-agent
# 标签页 3: frontend-agent
# 标签页 4: test-agent
# 标签页 5: postgres（数据库）

10.10.4 启动三个 Agent

在 orchestrator 标签页中执行：

# 启动后端 Agent
BACKEND=$(herdr agent start \
  --model claude-sonnet-4.5 \
  --prompt "你是后端开发专家。在 backend/ 目录下开发任务管理 API。

技术栈：Node.js + Express + TypeScript + Prisma + PostgreSQL

要求：
1. 数据模型：User（用户）、Board（看板）、List（列表）、Task（任务）
2. API 接口：
   - POST /api/auth/register - 注册
   - POST /api/auth/login - 登录
   - GET /api/boards - 获取看板列表
   - POST /api/boards - 创建看板
   - GET /api/boards/:id/lists - 获取列表
   - POST /api/boards/:id/lists - 创建列表
   - GET /api/lists/:id/tasks - 获取任务
   - POST /api/lists/:id/tasks - 创建任务
   - PATCH /api/tasks/:id - 更新任务
   - DELETE /api/tasks/:id - 删除任务
3. 使用 JWT 认证
4. 添加输入验证和错误处理
5. 数据库连接字符串从环境变量读取" \
  --cwd ~/projects/task-app/backend \
  | jq -r '.agentId')

echo "Backend Agent: $BACKEND"

# 启动前端 Agent
FRONTEND=$(herdr agent start \
  --model kimi-k2 \
  --prompt "你是前端开发专家。在 frontend/ 目录下开发任务管理界面。

技术栈：React + TypeScript + Vite + Tailwind CSS

要求：
1. 页面：登录注册页、看板列表页、看板详情页（含拖拽）
2. 调用后端 API（http://localhost:3000/api）
3. 使用 React Query 管理服务端状态
4. 使用 @dnd-kit 实现拖拽排序
5. 响应式设计，支持移动端

后端 API 文档：
- POST /api/auth/register {email, password} → {token}
- POST /api/auth/login {email, password} → {token}
- GET /api/boards → Board[]
- POST /api/boards {title} → Board
- GET /api/boards/:id/lists → List[]
- POST /api/boards/:id/lists {title} → List
- GET /api/lists/:id/tasks → Task[]
- POST /api/lists/:id/tasks {title} → Task
- PATCH /api/tasks/:id {title?, description?, position?} → Task
- DELETE /api/tasks/:id" \
  --cwd ~/projects/task-app/frontend \
  | jq -r '.agentId')

echo "Frontend Agent: $FRONTEND"

# 启动测试 Agent
TEST=$(herdr agent start \
  --model grok-code \
  --prompt "你是测试工程师。在 tests/ 目录下编写端到端测试。

技术栈：Playwright + TypeScript

测试场景：
1. 用户注册和登录流程
2. 创建看板
3. 创建列表
4. 创建和编辑任务
5. 拖拽任务到不同列表
6. 删除任务

前端运行在 http://localhost:5173
后端 API 在 http://localhost:3000/api

请先等待前后端都启动后再编写和运行测试。" \
  --cwd ~/projects/task-app/tests \
  | jq -r '.agentId')

echo "Test Agent: $TEST"

10.10.5 监控进度

# 查看所有 Agent 状态
herdr agent list
# → agent-001 | claude-sonnet-4.5 | working  | 5m  | files: 12
# → agent-002 | kimi-k2           | working  | 5m  | files: 8
# → agent-003 | grok-code         | waiting  | 5m  | "等待前后端启动"

10.10.6 处理 Agent 间的依赖

测试 Agent 需要等前后端就绪。你可以设置一个等待逻辑：

# 等待后端 Agent 完成核心 API
herdr agent wait $BACKEND

# 通知测试 Agent 后端已就绪
herdr agent prompt $TEST "后端 API 已就绪，运行在 localhost:3000"

# 等待前端 Agent 完成
herdr agent wait $FRONTEND

# 通知测试 Agent 前端已就绪
herdr agent prompt $TEST "前端已就绪，运行在 localhost:5173，可以开始运行测试了"

10.10.7 最终集成检查

# 所有 Agent 完成后，启动服务进行集成测试
cd ~/projects/task-app/backend && npm run dev &
cd ~/projects/task-app/frontend && npm run dev &

# 运行测试
cd ~/projects/task-app/tests && npx playwright test

10.11 安全规则

多 Agent 协作时，安全是第一要务。Herdr 遵循以下安全原则：

10.11.1 规则 1：不抢焦点

# ❌ 错误：Agent 切换到其他 pane，抢走焦点
herdr pane focus pane-other-agent

# ✅ 正确：Agent 只在自己的 pane 中操作
# Herdr 默认强制这条规则

10.11.2 规则 2：基于 JSON ID 操作

所有 Agent 之间的交互都通过 JSON 返回的 ID 进行，不猜测、不硬编码：

# ✅ 获取 ID 后再操作
AGENT_ID=$(herdr agent start ... | jq -r '.agentId')
herdr agent wait $AGENT_ID

# ❌ 不要猜测 ID
herdr agent wait agent-1  # 可能不存在

10.11.3 规则 3：不关闭他人 pane

# ❌ 错误：Agent A 关闭了 Agent B 的 pane
herdr layout close pane-other-agent

# ✅ 正确：只关闭自己创建的 pane
# Herdr 自动追踪 pane 归属

安全边界

Herdr 的安全模型是”协作信任”模式——它假设所有 Agent 都是善意的，但通过技术手段防止意外干扰。如果你运行不信任的 Agent，请在隔离的 Herdr 实例中运行。

10.12 小结

多 Agent 协作是 Herdr 的杀手级能力。本章我们学习了三种核心模式：

编排模式：一个主 Agent 通过 Herdr 命令编排多个 Worker Agent
流水线模式：Agent 形成写→审查→修复的流水线
人机协作模式：人类随时切入/切出 Agent 的工作流程

核心要点：

安装 Skill 包让 Agent 学会操作 Herdr
理解 Layout、Pane、Agent 三大原语
所有 Agent 间交互基于 JSON ID
注意 alternate-screen 的输出限制
遵守三大安全规则

10.1 为什么要多 Agent

10.2 Herdr 的 Agent Skill 机制

10.2.1 问题：Agent 不知道怎么操作 Herdr

10.2.2 解决方案：SKILL.md

10.2.3 安装 Skill

10.2.4 SKILL.md 核心内容解读

10.3 模式一：主 Agent 编排（Orchestrator）

10.3.1 架构

10.3.2 完整编排示例

10.3.3 Bash 脚本编排（替代方案）

10.4 模式二：写→审查流水线

10.4.1 架构

10.4.2 完整流程

10.4.3 自动化流水线脚本

10.5 模式三：人机协作

10.5.1 工作方式

10.5.2 具体操作

10.6 三大原语（Primitives）详解

10.6.1 1. Layout（布局）

10.6.2 2. Pane（终端面板）

10.6.3 3. Agent（智能体生命周期）

10.6.4 三者的关系

10.7 agent 命令完整工作流

10.8 pane 命令：原始终端控制

10.9 Alternate-Screen 输出限制

10.9.1 问题

10.9.2 解决方案

10.10 实战案例：三 Agent 并行开发全栈应用

10.10.1 项目背景

10.10.2 准备工作

10.10.3 创建布局

10.10.4 启动三个 Agent

10.10.5 监控进度

10.10.6 处理 Agent 间的依赖

10.10.7 最终集成检查

10.11 安全规则

10.11.1 规则 1：不抢焦点

10.11.2 规则 2：基于 JSON ID 操作

10.11.3 规则 3：不关闭他人 pane

10.12 小结

10.7 `agent` 命令完整工作流

10.8 `pane` 命令：原始终端控制