24 小时处理 90+ Issues：一套多智能体协作的实战案例
2026/7/14大约 8 分钟
如何让多个 AI 智能体协同工作？
如何实现 24 小时自动开发、测试并同步进度？
飞书智能体接单、Claude 规划、Codex 和 Grok 双路交付、CC 交叉验证
两天处理 90+ issues，消耗 25 亿 Tokens
这是一套真实的多智能体协作系统实战案例
问题背景
协作项目的痛点：
┌─────────────────────────────────────────────────────────┐
│ 协作项目的任务处理困境 │
├─────────────────────────────────────────────────────────┤
│ │
│ 典型场景： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Issues 来源分散： │ │
│ │ · 飞书文档 │ │
│ │ · 群聊消息 │ │
│ │ · 内部系统 │ │
│ │ │ │
│ │ 人工处理成本高： │ │
│ │ · 需要人工接单 │ │
│ │ · 需要人工规划 │ │
│ │ · 需要人工开发 │ │
│ │ · 需要人工测试 │ │
│ │ · 需要人工回复 │ │
│ │ │ │
│ │ 效率问题： │ │
│ │ · 响应慢 │ │
│ │ · 容易遗漏 │ │
│ │ · 质量不稳定 │ │
│ │ · 成本高 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘解决方案：多智能体协作系统
系统架构：
┌─────────────────────────────────────────────────────────┐
│ 多智能体协作系统架构 │
├─────────────────────────────────────────────────────────┤
│ │
│ 任务来源层： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │飞书文档 │ │ 群聊消息 │ │内部系统 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │ │ │ │
│ │ └─────────────┴─────────────┘ │ │
│ │ │ │ │
│ │ ┌───────▼───────┐ │ │
│ │ │ 飞书智能体 │ (接单层) │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ └───────────────────────┼────────────────────────┘ │
│ │ │
│ 调度规划层： │ │
│ ┌────────────────────────┼────────────────────────┐ │
│ │ │ │ │
│ │ ┌───────▼───────┐ │ │
│ │ │ Mac Mini │ │ │
│ │ │ (调度器) │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ┌───────▼───────┐ │ │
│ │ │ Claude │ (规划层) │ │
│ │ │ (规划器) │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ └────────────────────────┼────────────────────────┘ │
│ │ │
│ 双路交付层： │ │
│ ┌────────────────────────┼────────────────────────┐ │
│ │ │ │ │
│ │ ┌───────────┴───────────┐ │ │
│ │ │ │ │ │
│ │ ┌──────▼──────┐ ┌──────▼──────┐ │ │
│ │ │ Codex │ │ Grok │ │ │
│ │ │ (交付 A) │ │ (交付 B) │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ │ │
│ │ │ │ │ │
│ └────────────┼───────────────────────┼────────────┘ │
│ │ │ │
│ 交叉验证层： │ │ │
│ ┌────────────┴───────────────────────┴────────────┐ │
│ │ │ │
│ │ ┌───────────┐ │ │
│ │ │ CC │ (交叉验证) │ │
│ │ │ (验证器) │ │ │
│ │ └─────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 自动测试 │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 同步进度 │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 自动回复 │ │ │
│ │ └───────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘工作流程详解
1. 接单层：飞书智能体
功能：统一接单入口
┌─────────────────────────────────────────────────────────┐
│ 飞书智能体：统一接单入口 │
├─────────────────────────────────────────────────────────┤
│ │
│ 数据来源： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 飞书文档 │ │
│ │ · 任务文档 │ │
│ │ · 需求文档 │ │
│ │ · Bug 反馈 │ │
│ │ │ │
│ │ 2. 群聊消息 │ │
│ │ · 项目群讨论 │ │
│ │ · 客户反馈 │ │
│ │ · 团队沟通 │ │
│ │ │ │
│ │ 3. 内部系统 │ │
│ │ · Jira / 禅道等项目管理工具 │ │
│ │ · 代码仓库 Issues │ │
│ │ · 监控告警 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 核心能力： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 实时监听：24 小时监听各个数据源 │ │
│ │ · 智能识别：自动识别任务类型和优先级 │ │
│ │ · 统一格式：将不同来源的任务标准化 │ │
│ │ · 自动分发：根据规则将任务分发给调度器 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘2. 规划层：Claude 规划器
功能：任务拆解与规划
┌─────────────────────────────────────────────────────────┐
│ Claude 规划器：任务拆解与规划 │
├─────────────────────────────────────────────────────────┤
│ │
│ 核心能力： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 理解任务 │ │
│ │ · 分析任务需求 │ │
│ │ · 识别技术难点 │ │
│ │ · 评估工作量 │ │
│ │ │ │
│ │ 2. 拆解任务 │ │
│ │ · 将复杂任务拆解为子任务 │ │
│ │ · 识别任务依赖关系 │ │
│ │ · 确定执行顺序 │ │
│ │ │ │
│ │ 3. 制定计划 │ │
│ │ · 选择合适的模型（Codex 或 Grok） │ │
│ │ · 分配资源 │ │
│ │ · 设定时间节点 │ │
│ │ │ │
│ │ 4. 生成指令 │ │
│ │ · 为 Codex 生成详细的开发指令 │ │
│ │ · 为 Grok 生成详细的开发指令 │ │
│ │ · 为 CC 生成验证标准 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 为什么选择 Claude？ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 擅长复杂推理和规划 │ │
│ │ · 代码理解能力强 │ │
│ │ · 上下文窗口大，可以处理复杂任务 │ │
│ │ · 输出结构化，易于后续处理 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘3. 交付层：Codex 和 Grok 双路交付
功能：并行开发，提高效率和质量
┌─────────────────────────────────────────────────────────┐
│ Codex 和 Grok：双路并行交付 │
├─────────────────────────────────────────────────────────┤
│ │
│ 双路交付架构： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 同一个任务 ──→ Claude 规划 ──→ 两份指令 │ │
│ │ │ │ │
│ │ ┌────────────────┴────────┐ │ │
│ │ │ │ │ │
│ │ ┌───────▼──────┐ ┌───────▼───┴┐ │ │
│ │ │ Codex 路径 │ │ Grok 路径 │ │ │
│ │ │ │ │ │ │ │
│ │ │ · 代码生成 │ │ · 代码生成 │ │ │
│ │ │ · Bug 修复 │ │ · Bug 修复 │ │ │
│ │ │ · 功能开发 │ │ · 功能开发 │ │ │
│ │ └───────┬──────┘ └───────┬─────┘ │ │
│ │ │ │ │ │
│ │ └─────────┬───────────────┘ │ │
│ │ │ │ │
│ │ ┌──────▼──────┐ │ │
│ │ │ CC 交叉验证 │ │ │
│ │ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 双路交付的优势： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 提高效率 │ │
│ │ · 并行开发，缩短时间 │ │
│ │ · 充分利用两个模型的计算能力 │ │
│ │ │ │
│ │ 2. 提高质量 │ │
│ │ · 两个模型可能产生不同的解决方案 │ │
│ │ · 交叉验证可以发现更多问题 │ │
│ │ · 减少单一模型的偏差 │ │
│ │ │ │
│ │ 3. 降低风险 │ │
│ │ · 即使一个模型失败，另一个模型可以兜底 │ │
│ │ · 提高系统的容错能力 │ │
│ │ │ │
│ │ 4. 促进创新 │ │
│ │ · 不同模型可能有不同的思路 │ │
│ │ · 可以从中选择更好的方案 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Codex vs Grok： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 特性 │ Codex │ Grok │ │
│ │ ├──────────────┼────────────────┼───────────────┤ │
│ │ 擅长领域 │ 代码生成 │ 代码生成 │ │
│ │ 语言支持 │ 多语言 │ 多语言 │ │
│ │ 推理能力 │ 中等 │ 较强 │ │
│ │ 上下文窗口 │ 较大 │ 较大 │ │
│ │ 成本 │ 中等 │ 中等 │ │
│ │ 速度 │ 较快 │ 较快 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘4. 验证层：CC 交叉验证
功能：质量保证和交叉验证
┌─────────────────────────────────────────────────────────┐
│ CC 交叉验证：质量保证和交叉验证 │
├─────────────────────────────────────────────────────────┤
│ │
│ 验证流程： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 代码对比 │ │
│ │ · 对比 Codex 和 Grok 的输出 │ │
│ │ · 检查代码一致性 │ │
│ │ · 识别差异和冲突 │ │
│ │ │ │
│ │ 2. 功能验证 │ │
│ │ · 运行自动化测试 │ │
│ │ · 检查功能完整性 │ │
│ │ · 验证边界条件 │ │
│ │ │ │
│ │ 3. 质量检查 │ │
│ │ · 代码规范检查 │ │
│ │ · 安全漏洞扫描 │ │
│ │ · 性能评估 │ │
│ │ │ │
│ │ 4. 选择最优方案 │ │
│ │ · 如果两个方案都可行，选择更好的 │ │
│ │ · 如果只有一个可行，采用它 │ │
│ │ · 如果都不可行，触发人工干预 │ │
│ │ │ │
│ │ 5. 生成报告 │ │
│ │ · 详细的验证报告 │ │
│ │ · 问题清单和建议 │ │
│ │ · 决策依据 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 为什么选择 CC？ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 强大的代码理解能力 │ │
│ │ · 擅长代码审查和质量检查 │ │
│ │ · 可以生成结构化的验证报告 │ │
│ │ · 成本相对较低 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘5. 自动化闭环
功能：24 小时自动运行
┌─────────────────────────────────────────────────────────┐
│ 自动化闭环：24 小时自动运行 │
├─────────────────────────────────────────────────────────┤
│ │
│ 自动化流程： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌──────────┐ │ │
│ │ │ 接单 │ ← 飞书智能体 24 小时监听 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 规划 │ ← Claude 自动拆解和规划 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 交付 │ ← Codex + Grok 并行开发 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 验证 │ ← CC 交叉验证 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 测试 │ ← 自动化测试 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 同步 │ ← 自动同步进度到飞书 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┐ │ │
│ │ │ 回复 │ ← 自动回复用户 │ │
│ │ └────┬─────┘ │ │
│ │ │ │ │
│ │ └──────────────────────────────────┐ │ │
│ │ │ │ │
│ │ ┌───────────▼──┴┐ │ │
│ │ │ 等待新任务 │ │ │
│ │ └───────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 核心特点： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 24 小时运行：无需人工干预 │ │
│ │ · 实时同步：进度实时同步到飞书 │ │
│ │ · 自动回复：完成后自动回复用户 │ │
│ │ · 异常处理：遇到问题自动触发人工干预 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘成效数据
两天运行成果：
┌─────────────────────────────────────────────────────────┐
│ 成效数据 │
├─────────────────────────────────────────────────────────┤
│ │
│ 处理能力： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · Issues 处理：90+ 个 │ │
│ │ · 运行时间：2 天 (48 小时) │ │
│ │ · 平均每小时：1.875 个 issues │ │
│ │ · 峰值处理：更高 │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Token 消耗： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ · 总消耗：25 亿 Tokens │ │
│ │ · 平均每个 issue：约 2780 万 Tokens │ │
│ │ │ │
│ │ Token 分布（估算）： │ │
│ │ ┌───────────────────────────────────────────┐ │ │
│ │ │ Claude 规划：约 30% │ │ │
│ │ │ Codex 交付：约 30% │ │ │
│ │ │ Grok 交付：约 30% │ │ │
│ │ │ CC 验证：约 10% │ │ │
│ │ └───────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 成本估算（假设）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 假设每百万 Tokens 成本： │ │
│ │ · Claude: $3 │ │
│ │ · Codex: $2 │ │
│ │ · Grok: $2 │ │
│ │ · CC: $2 │ │
│ │ │ │
│ │ 总成本： │ │
│ │ 25 亿 Tokens = 2500 百万 Tokens │ │
│ │ Claude: 7.5 亿 × $3/百万 = $2250 │ │
│ │ Codex: 7.5 亿 × $2/百万 = $1500 │ │
│ │ Grok: 7.5 亿 × $2/百万 = $1500 │ │
│ │ CC: 2.5 亿 × $2/百万 = $500 │ │
│ │ 总计：约 $5750 │ │
│ │ │ │
│ │ 平均每个 issue 成本：约 $64 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 效率对比： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 传统人工处理： │ │
│ │ · 每个 issue 需要 2-4 小时 │ │
│ │ 90 个 issues 需要 180-360 小时 │ │
│ │ 需要 22.5-45 个工作日 │ │
│ │ │ │
│ │ Agent 协作系统： │ │
│ │ · 48 小时处理 90+ 个 issues │ │
│ │ 平均每个 issue 约 30 分钟 │ │
│ │ │ │
│ │ 效率提升： │ │
│ │ · 时间效率：提升 4-8 倍 │ │
│ │ · 成本效率：显著低于人工成本 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘技术选型分析
为什么选择这些模型？
┌─────────────────────────────────────────────────────────┐
│ 技术选型分析 │
├─────────────────────────────────────────────────────────┤
│ │
│ Claude（规划层）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 优势： │ │
│ │ · 擅长复杂推理和任务拆解 │ │
│ │ · 代码理解能力强，可以分析复杂代码库 │ │
│ │ · 上下文窗口大，可以处理长文档 │ │
│ │ · 输出结构化，易于后续处理 │ │
│ │ │ │
│ │ 适用场景： │ │
│ │ · 任务规划和拆解 │ │
│ │ · 代码审查和分析 │ │
│ │ · 架构设计 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Codex（交付层 A）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 优势： │ │
│ │ · 专为代码生成优化 │ │
│ │ · 支持多种编程语言 │ │
│ │ · 代码质量高 │ │
│ │ · 速度快 │ │
│ │ │ │
│ │ 适用场景： │ │
│ │ · 代码生成 │ │
│ │ · Bug 修复 │ │
│ │ · 功能开发 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Grok（交付层 B）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 优势： │ │
│ │ · 推理能力强 │ │
│ │ · 上下文窗口大 │ │
│ │ · 可以处理复杂任务 │ │
│ │ · 实时信息更新 │ │
│ │ │ │
│ │ 适用场景： │ │
│ │ · 代码生成 │ │
│ │ · 复杂问题解决 │ │
│ │ · 需要实时信息的任务 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ CC（验证层）： │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 优势： │ │
│ │ · 强大的代码理解能力 │ │
│ │ · 擅长代码审查 │ │
│ │ · 可以生成详细的分析报告 │ │
│ │ · 成本相对较低 │ │
│ │ │ │
│ │ 适用场景： │ │
│ │ · 代码验证 │ │
│ │ · 质量检查 │ │
│ │ · 交叉验证 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘经验总结
多智能体协作的最佳实践：
┌─────────────────────────────────────────────────────────┐
│ 经验总结：多智能体协作的最佳实践 │
├─────────────────────────────────────────────────────────┤
│ │
│ 1. 合理分工 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 每个智能体应该有明确的职责： │ │
│ │ · 飞书智能体：接单和分发 │ │
│ │ · Claude：规划和拆解 │ │
│ │ · Codex/Grok：代码生成 │ │
│ │ · CC：验证和质量保证 │ │
│ │ │ │
│ │ 避免职责重叠，提高效率 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 2. 双路交付 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 使用两个模型并行交付的优势： │ │
│ │ · 提高效率：并行开发，缩短时间 │ │
│ │ · 提高质量：交叉验证，减少错误 │ │
│ │ · 降低风险：即使一个失败，另一个可以兜底 │ │
│ │ · 促进创新：不同模型可能有不同思路 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 3. 交叉验证 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 使用独立的模型进行交叉验证： │ │
│ │ · 对比两个模型的输出 │ │
│ │ · 检查代码一致性和质量 │ │
│ │ · 选择最优方案 │ │
│ │ │ │
│ │ 提高最终交付的质量 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 4. 自动化闭环 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 实现完全自动化的工作流： │ │
│ │ · 自动接单 │ │
│ │ · 自动规划 │ │
│ │ · 自动开发 │ │
│ │ · 自动测试 │ │
│ │ · 自动同步 │ │
│ │ · 自动回复 │ │
│ │ │ │
│ │ 最小化人工干预，提高效率 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 5. 异常处理 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 设计异常处理机制： │ │
│ │ · 当两个模型的输出冲突时，如何处理 │ │
│ │ · 当验证失败时，如何触发人工干预 │ │
│ │ · 当任务超时时，如何报警 │ │
│ │ │ │
│ │ 保证系统的稳定性和可靠性 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 6. 成本优化 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 合理选择模型，优化成本： │ │
│ │ · Claude 用于规划（高价值任务） │ │
│ │ · Codex/Grok 用于交付（中等价值） │ │
│ │ · CC 用于验证（低价值） │ │
│ │ │ │
│ │ 在保证质量的前提下，降低成本 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ 7. 实时同步 │
│ ┌─────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 实时同步进度到飞书： │ │
│ │ · 让用户随时了解进度 │ │
│ │ · 提高透明度 │ │
│ │ · 减少用户的焦虑 │ │
│ │ │ │
│ │ 改善用户体验 │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘收尾金句
- 如何让多个 AI 智能体协同工作？
- 飞书智能体接单 + Claude 规划 + Codex/Grok 双路交付 + CC 交叉验证
- 两天处理 90+ issues，消耗 25 亿 Tokens
- 这是一套真实的多智能体协作系统实战案例
多智能体协作：让 AI 智能体协同工作，24 小时自动处理任务
从接单到回复的完整自动化，提高效率 4-8 倍
"