八大平台、十项任务、一支 “智能体军团”，账单到底长什么样？

一个吓人的数字

去年 2 月到今年 2 月，AI 编排者（AI Orchestrator）的招聘量一年涨了 1294%。这是 IT Brew 援引 Lightcast 数据报道的数字，背后的信号很明确：会 “指挥一群 AI 干活” 的人，正在变成最值钱的工种之一。

很多人第一反应是：玩智能体，尤其是 AI Agent，得烧钱吧？其实答案和你想象的相反。

这篇文章，我直接拿八个平台的真实部署来算账：10 项任务、10 个智能体团队，每个团队花多少钱、怎么省的，全部摊开给你看。

核心结论先放这儿：智能体最贵的是 token，而 token 的大头，是那些你根本没注意到的上下文堆叠。

我会保留每一步的关键代码和账单表格，你可以直接照着抄。

贵的从来不是智能体，是上下文

先记住这句话：上下文才是硬通货。 每一轮对话都会把历史记录重新塞进模型，每一次工具调用都会把输出追加进上下文堆栈，每多一个智能体，就多一套独立堆栈。

Anthropic 在多智能体研究系统的工程博客里给过一组真实数字：

• 单个智能体消耗的 token，大约是普通聊天的 4 倍；

• 多智能体系统消耗的 token，大约是普通聊天的 15 倍；

• 仅 token 用量一项，就解释了其浏览器评测约 80% 的性能差异。

智能体越多→ token越多 → 成本越高，这条链路是逃不掉的。而 Claude Code 官方成本指南里还有一组更现实的数据：

企业里每位开发者日均支出约 13 美元，月支出普遍在 150–250 美元；90% 的用户日均活跃支出低于 30 美元；当团队以计划模式运行时，token 消耗大约是标准会话的 7 倍。

那怎么办？这里提供两条解决路径。

路线一：把模型按难度分级

前沿模型做架构设计和疑难调试，中端模型做实现，小模型去跑测试、读日志、搜代码。你把小模型派到 “噪音大、推理浅” 的活上，能省一大半钱。

路线二：直接上本地 LLM

一台 64GB 显存（或统一内存）的机器，就能在本地跑 Gemma 4、Qwen 这类开源模型，把推理成本压到近乎为零。代价是输出质量打折扣。

所以，对每月只花 20 美元订阅的用户，本地 LLM 是最划算的选择；但对追求顶尖输出质量的团队，还是要混合着用。

提醒一句：别每天在 Claude 上裸奔跑 100 多个智能体，除非你付得起每月上千美元的 API 费，或每月 200 美元的 Max 订阅。跑自己的本地 LLM，这条规则自动失效。

七条规则，帮你把预算摁住

就算有本地 LLM，控制 token 也依然是基本功。公司愿意花 50 万美元雇一个能用 Claude 把整个团队自动化的人，原因就在这儿。

1. 按难度路由，别按习惯路由。架构设计、复杂调试上前沿模型；实现阶段用中端模型；搜索、日志读取、跑测试，交给小模型。

2. 清掉无关任务之间的上下文。Claude Code 里 /clear 免费；/compact 本身是一次大请求，模型得把要压缩的东西全读一遍。

3. 指令文件保持精简。Anthropic 建议 CLAUDE.md 不超过 200 行，专业工作流拆进技能模块，用到才加载。

4. 把 “噪音大的任务” 推给子智能体或钩子。子智能体能吞下 10000 行测试输出，只回报三行摘要；钩子函数能在任何模型看到输出前，先把它过滤一遍。

5. 多用命令行工具，少挂闲置的 MCP 服务器。gh、gcloud、aws 这类工具实际用起来几乎不花钱；而每个闲置 MCP 服务器，都会给每次请求加一点隐性开销。

6. 先在本地跑，再上云端。OpenAI 官方明确说过，Codex 云端任务比同等规模的本地任务消耗更多配额。

7. 设消费上限。Claude Code 的 --max-budget-usd 用于脚本化运行；Copilot 可以关掉超额费用；DeepSeek 在非高峰时段直接半价。

你写过最便宜的一个 “钩子”

下面这段是改编自 Anthropic 官方文档的钩子：在每次 Bash 调用前拦截，如果是跑测试，就只把失败结果透传给模型。大测试套件里，一次运行能省下几千个token。

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/filter-test-output.sh" }
        ]
      }
    ]
  }
}

#!/bin/bash
# filter-test-output.sh — 在 Claude 每次调用 Bash 之前运行
# 如果是测试命令，改写它，只让失败结果回来
input=$(cat)
cmd=$(echo "$input" | jq -r '.tool_input.command')


if [[ "$cmd" =~ ^(npm test|pytest|go test|cargo test) ]]; then
  # 只保留 FAIL/ERROR 行 + 5 行上下文，最多 100 行
  filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
  echo "$input" | jq --arg filtered "$filtered_cmd" \
    '{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: (.tool_input + {command: $filtered})}}'
else
  echo "{}"
fi

下面我们进入正题：八个平台、十项任务，每个团队怎么建、花多少钱。

Claude Code：最全的编排工具箱，适合严格管控的功能开发

Claude Code 是 Anthropic 的终端智能体，终端、VS Code、JetBrains、桌面和网页端都能跑，且共用同一引擎、同一 CLAUDE.md、同一组 MCP 服务器，配置跟着你走。

它的编排工具是目前最全的：子智能体、智能体团队、钩子、技能、插件、动态工作流一应俱全。订阅方面，Pro 每月 20 美元，Max 每月 100–200 美元。

这里的关键优势是：每个子智能体都有自己的模型、专属工具和独立上下文窗口。负责人保住设计一致性，各领域专家并行干活，互不干扰。我拿 "给 Web 应用加一个发票导出 CSV 功能" 来演示，覆盖 API、UI、测试和最终审查。

智能体团队

分步搭建

# 1) 安装（macOS/Linux/WSL，原生安装器会自动更新）
curl -fsSL https://claude.ai/install.sh | bash
claude --version


# 2) 建项目级子智能体目录，每个 .md 就是一个子智能体
cd your-project && mkdir -p .claude/agents


# 3) backend-dev：只允许碰服务端文件
cat > .claude/agents/backend-dev.md <<'EOM'
---
name: backend-dev
description: Implements backend API changes only.
model: sonnet
tools: Read, Edit, Write, Bash
---
You implement API endpoints. Touch only files under src/api/ and src/services/.
EOM


# 4) frontend-dev：只允许碰客户端文件
cat > .claude/agents/frontend-dev.md <<'EOM'
---
name: frontend-dev
description: Implements UI changes only.
model: sonnet
tools: Read, Edit, Write, Bash
---
You build UI components. Touch only files under src/web/.
EOM


# 5) test-runner：最小模型，读日志不需要深度推理
cat > .claude/agents/test-runner.md <<'EOM'
---
name: test-runner
description: Runs tests, reports ONLY failures.
model: haiku
tools: Bash, Read
---
Run the tests. Return test name, file:line and one-line probable cause. Never paste full logs.
EOM


# 6) reviewer：只读，能跑 git diff 但改不了任何文件
cat > .claude/agents/reviewer.md <<'EOM'
---
name: reviewer
description: Reviews diffs for bugs, security, missing tests. Read-only.
model: sonnet
tools: Read, Bash
---
Review current branch against main. Return a numbered list of issues, most severe first.
EOM

用 claude --model opus 发起主会话，按下 Shift+Tab 进入计划模式先批准导出计划，再用一条指令并行拉起所有工作人员：

Use backend-dev and frontend-dev in parallel to implement the approved plan.
When both finish, use test-runner. Fix any failures yourself.
Finally, use reviewer and address every issue it raises.

干完跑 claude --usage，它会把支出归因到每个子智能体，让你看清 token 去向。

预估账单（中型代码库，按列表价）

用 Pro/Max 套餐，这笔从套餐额度里扣，不从银行卡扣；走 API 的话，提示缓存通常还能把实际费用压到 5 美元以下。

OpenAI Codex：无头扇出的利器，适合并行扫测覆盖率

Codex 不是独立产品，而是整合进 ChatGPT 套餐的编码智能体。它能跑在命令行、IDE 插件、Web 应用和云沙箱里，把结果写回你的代码库。

最狠的是 codex exec 这个非交互命令：每个智能体都被压成一条 shell 命令，配合 git worktree，每个智能体拿到一份独立的代码库副本，互不覆盖。

按官方文档，默认模型是中等推理能力的模型；Codex 在 Terminal-Bench 2.0 上拿到过 82 分的最高分。

我拿 "同时为四个软件包补缺失的单元测试，再审查这四组测试" 来演示。

智能体团队

分步搭建

# 1) 安装并首次登录 ChatGPT
curl -fsSL https://chatgpt.com/codex/install.sh | sh
codex   # 首次运行引导登录


# 2) 建四个独立工作树，各智能体各占一份副本，永远不会互相踩
for pkg in auth billing search notify; do
  git worktree add ../wt-$pkg -b tests/$pkg
done


# 3) 并行启动四个测试编写智能体，各自在自己的工作树里跑
for pkg in auth billing search notify; do
  ( cd ../wt-$pkg && \
    codex exec "Write missing unit tests for packages/$pkg. Run them until they pass. \
                Do not modify any other package. Commit when done." \
    > ../log-$pkg.md 2>&1 ) &
done
wait   # 等四个都干完


# 4) 四个分支建好后，起第五个智能体审查员
codex exec "Review branches tests/auth, tests/billing, tests/search and tests/notify \
            against main. Flag weak assertions, flaky tests and missing edge cases. \
            Output a numbered list per branch." > review.md

修复审查员指出的问题后，合并分支，再 git worktree remove ../wt-<package> 收尾。

预估账单

按 GPT-5.3-Codex 的 API 等价定价（每百万输入 1.75 美元、每百万输出 14 美元）估算：

对每月 20 美元的 Plus 套餐，这种规模通常能落在滚动 5 小时的使用窗口内。

xAI Grok：比速度更比保密，适合原型竞赛

Grok Build 是 xAI 的终端编码智能体，CLI 面向 SuperGrok 和 X Premium+ 开放，于 2026 年 7 月开源了框架。

它带计划模式、子智能体、无头模式，还有高速专用编码模型 Grok Build 0.1。

特别提醒：有独立研究报告指出，7 月那次上传事件里 Grok 在未征得用户同意的情况下，上传过代码库压缩包，直到服务器端修复才停。所以，目前最好只在公开或临时代码库里用它。

当速度比保密更重要时，Grok 很合适。它的原型是一次性的、通常是公开的，快速建模收益巨大。

推荐玩法：让多个智能体互相竞争，再让一个评审智能体选赢家。我为 "给一个新开源工具做三个互相竞争的落地页原型，再评估" 来演示。

智能体团队

分步搭建

# 1) 安装并在全新、非保密代码库启动
curl -fsSL https://x.ai/cli/install.sh | bash
mkdir landing-race && cd landing-race && git init
grok   # 首次启动浏览器登录


# 2) 无头模式重跑评审，输出机器可读 JSON，方便喂给别的工具
grok -p "Re-run the critic on all three worktrees" --output-format streaming-json

并行生成三个原型智能体（各在自己的 git 工作树里，按已批准简报做静态 HTML/CSS），再生成 critic 智能体，明确指示它只打分不修改，最后按清晰度、速度和与简报的契合度评 1–10 分并推荐一个。

预估账单

按 Grok 4.6 API 价格（每百万输入 2 美元、每百万输出 6 美元）估算；我们对可信度打个折扣，因为 xAI 今年定价调过好几次。

SuperGrok 订阅里 CLI 使用费包含在套餐内，不再按 token 计费。

Google Antigravity：超长上下文+后台智能体，专治遗留单体库

Gemini CLI 在 6 月 18 日停止面向免费和 Pro/Ultra 订阅用户服务，接替它的是 Antigravity CLI。

这是一个新二进制 agy，用 Go 重写，和 Antigravity 2.0 桌面应用共享同一智能体框架。它专为异步、多智能体工作设计，智能体能在后台跑，你继续用终端。

Gemini 模型天生超长上下文，加上后台智能体，组合起来特别适合 "读陌生大代码库但不想停下手里活" 的场景。

任务：给一个含四个子系统的遗留单体库写架构概要。

智能体团队

分步搭建

# 1) 全新二进制安装（它不是 Gemini CLI 的升级，是新工具）
curl -fsSL https://antigravity.google/cli/install.sh | bash


# 2) 扫脚本和 CI 里残留的 gemini 命令——6月18日起消费者凭据已经失效
grep -rn --include="*.yml" --include="*.yaml" --include="*.sh" "gemini " .

从仓库根目录起 agy，首次运行确认工作区信任。然后，把四个映射智能体以只读后台智能体形式拉起：

• map-api 映射 services/api/ 下的网关路由鉴权
• map-data 映射 services/db/ 的 schema 和迁移
• map-jobs 映射 services/jobs/ 的队列调度
• map-web 映射 apps/web/ 的每个 API 调用

每个把发现写进 docs/arch/<agent-name>.md，最多 80 行。它们跑的时候你用 /agents 盯着，最后让负责人把四份报告合成一份架构文档，附依赖清单和 top 5 风险。

预估账单

按 Gemini Pro 级别（每百万输入 2 美元、每百万输出 12 美元）估算：

阅读是这类任务最烧钱的部分。所以，它就该用带免费额度、长上下文的方案来做。

GitHub Copilot：/fleet+/delegate，PR 场景的 “神器”

对编码智能体而言，微软这边真正相关的是 GitHub Copilot（Microsoft 365 Copilot 是管文档邮件的另一个产品）。

Copilot CLI 带两个杀手级命令：/fleet 把重复性任务拆成并行子智能体，/delegate 把顽固任务丢给云编码智能体、由它直接帮你打开拉取请求（PR）。

套餐从免费到 Pro 10 美元、Pro+ 39 美元、Max 100 美元，额外用量按每积分 0.01 美元计算。

任务：升级 12 个软件包的日志库，把搞不定的交给云端。

智能体团队

分步搭建

# 1) 安装（需 Node.js 22+），然后 /login 登录一次
npm install -g @github/copilot
# 或 brew install --cask copilot-cli


# 2) 一条 /fleet 指令拉起 12 个子智能体
#    /fleet Upgrade our logging library from v3 to v4 in every package under packages/.
#           Use one subagent per package. Each subagent updates imports, fixes breaking
#           changes, runs that package's tests, and reports PASS or FAIL with one line of detail.


# 3) 失败包用 /delegate 交给云智能体开 PR
#    /delegate Finish the logging v4 upgrade in packages/payments. Tests are failing on
#             structured-field serialisation. Open a pull request when tests pass.


# 4) 非交互模式做下一次检查，输出适合 CI 的静默信息
copilot -p "List every package still importing logging v3" -s

看完 fleet 报告，合并全部 PASS 的软件包，把 FAIL 的列出来丢给 /delegate。

预估账单

按中级模型定价（每百万输入 2 美元、每百万输出 10 美元）、每积分 0.01 美元估算：

Copilot Pro 每月 15 美元额度大约够跑两次这种规模。

OpenCode：廉价读者+高级撰稿人，本地 LLM 最该选它

OpenCode 是开源、与提供商无关的终端智能体，几乎什么模型都能接。

它有两个主要智能体：拥有完全访问权的 "构建" 智能体和默认禁用编辑的 "规划" 智能体（Tab 切换）；还带 General、Explore、Scout 三个子智能体，用 @name 调用。

每个智能体可以跑在不同模型上，客户端本身免费。这是把廉价模型和高级模型混在一个团队里最好用的工具。

任务：给整个代码库写 API 文档。文档是 "大量阅读+少量高质量写作"，所以让廉价模型负责阅读、让高端模型负责写作。

智能体团队

分步搭建

# 1) 安装并 /connect 添加两个提供商：Anthropic 管写，DeepSeek 管读
curl -fsSL https://opencode.ai/install | bash
opencode   # /connect 配 provider，/init 生成 AGENTS.md


# 2) doc-scout：只读提取器，用便宜模型跑大阅读量
mkdir -p ~/.config/opencode/agents
cat > ~/.config/opencode/agents/doc-scout.md <<'EOM'
---
description: Read-only extractor. Lists public functions, params, returns, side effects for ONE module.
mode: subagent
model: deepseek/deepseek-flash
permission:
  edit: deny
  bash: deny
---
For the module you are given, return a compact list of public APIs with one-line behaviour notes.
EOM


# 3) doc-checker：把已写文档和源码逐条比对
cat > ~/.config/opencode/agents/doc-checker.md <<'EOM'
---
description: Fact-checks documentation against source code. Read-only.
mode: subagent
model: deepseek/deepseek-flash
permission:
  edit: deny
  bash: deny
---
Compare each documented claim with the code. Return only the claims that are wrong, with file:line.
EOM

用 /models 把构建智能体切成 Sonnet，然后一条指令跑整个团队：

并行调 @doc-scout 五次（src/core、src/api、src/db、src/auth、src/utils），用它的输出写 docs/reference/<module>.md，再调 @doc-checker 逐文件纠错。结果不满意就用 /undo、/redo。

实验成本低，随便试。

预估账单

七个智能体的成本不到两美元，这就是智能体模式的红利。如果换用本地 LLM，这数字直接归零。

Pi：极简、可脚本化，批量翻译的性价比之王

Pi 是 libGDX 作者 Mario Zechner 做的极简编码智能体，只有读、写、编辑、bash 四个核心工具，支持 15+ 提供商，能交互、能 JSON 模式、能嵌进应用。

它没有内置子智能体，官方建议用 tmux 之类自己拼。

正因为每个 Pi 进程都是小而可预测的工作单元，一个 shell 脚本串起多个 Pi，就是一个零框架开销的编排器。

任务：把应用本地化成印地语、泰米尔语、西班牙语、德语四种语言并验证。

智能体团队

分步搭建

# 1) 安装，选个小而便宜的模型（如 Haiku）
curl -fsSL https://pi.dev/install.sh | sh
# npm 替代：npm install -g @earendil-works/pi-coding-agent


# 2) 编排脚本：四个翻译进程并行 + 一个验证进程
#    localise.sh
set -e
SRC=locales/en.json
for lang in hi ta es de; do
  pi -p "Translate every value in $SRC into language code '$lang'. Keep all keys and \
         {placeholders} unchanged. Write the result to locales/$lang.json." \
    > logs/translate-$lang.md 2>&1 &
done
wait
pi -p "Compare locales/en.json with hi.json, ta.json, es.json and de.json. Report missing keys, \
       broken {placeholders} and button strings longer than 40 characters." > logs/verify.md

最后一定请母语者抽查译文。因为机器翻译仍需人工判断，尤其是泰米尔语和印地语。

预估账单（Haiku，1美元/5美元）

Pi 全程不手把手教你，这正是资深开发者喜欢它的地方。

DeepSeek：把智能体当发动机用，非高峰时段最省钱

DeepSeek 更像 "驱动别的智能体的引擎" 而非独立智能体。它提供 deepseek-flash 和 deepseek-v4-pro，都是百万 token 上下文；非高峰时段价格是高峰的一半。

V4-Pro 在 8 月 14 日发布，财新报道价格涨幅最高可达 1100%。

任务：一个晚上给 200 个 Python 文件加类型提示，让 mypy 全库通过。

DeepSeek 提供 Anthropic 兼容 API，所以你能直接在 Claude Code 里跑这个团队。

智能体团队

分步搭建

# 1) 仅当前终端把 Claude Code 指向 DeepSeek，普通 Claude 会话不受影响
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_API_KEY="sk-..."   # DeepSeek 的 key，不是 Anthropic 的


# 2) 循环建四个打字智能体
mkdir -p .claude/agents
for i in 1 2 3 4; do
cat > .claude/agents/typer-$i.md <<EOM
---
name: typer-$i
description: Adds type hints to batch $i and makes mypy pass for that batch.
model: haiku
tools: Read, Edit, Bash
---
Work only on files listed in batches/batch-$i.txt. Add precise type hints.
Run mypy on those files until clean. Never change runtime behaviour.
EOM
done


# 3) 把 Python 文件切四个大致相等的批次
mkdir -p batches
git ls-files '*.py' > batches/all.txt
split -n l/4 -d -a 1 batches/all.txt batches/tmp-
for i in 0 1 2 3; do mv batches/tmp-$i batches/batch-$((i+1)).txt; done

非高峰时段用 claude --model opus 发起引导会话，一条指令并行拉起四个 typer，干完跑全库测试和 mypy。跑完关掉终端，DeepSeek 环境变量自动丢弃。

预估账单（非高峰）

不到两美元就完成了 200 个文件全带类型提示，mypy 干净利落。

Anthropic 的 "主智能体-工作者" 工作流

前面八个平台都是工具，这一节讲把它们串起来的方法论。

Anthropic 公开过最清晰的多智能体协作蓝图：

• 2024 年 12 月的《Building Effective Agents》命名并解释了 "编排者-工作者" 模式；
• 2025 年 6 月关于多智能体研究系统的工程博客，展示了同一模式在生产环境的运行。

架构就六步：

• 主智能体分析请求、写计划并保存；
• 给每个工作者定目标、输出格式、工具使用指导和明确边界；
• 各工作者并行跑（各自独立上下文）；
• 每个返回的是精简结论而非原始转储；
• 主智能体综合结果决定继续还是收尾；
• 最后一步验证输出。

效果很惊人：Anthropic 内部评测里，Opus 4 主导+Sonnet 4 工作者，比单个 Opus 4 智能体性能高 90.2%；并行工具调用还能把复杂查询的搜索时间缩短最多 90%。

五条日常能落地的经验：

1.教负责人精准分活：指令含糊，工作者就会互相重复，白烧 token。

2.按复杂度调投入：简单事实核查 1 个工作者需要 3–10 次工具调用；直接比较 2–4 个工作者、每人 10–15 次工具调用；复杂研究可能要 10 个以上工作者并明确分工。

3.先宽后窄：先抛宽泛问题，再细化，这是优秀研究员的工作方式。

4.高性能主导+低成本配合：主辅模型的分工本身就是一种预算策略。

5.评结果，不评路径：智能体可能走不同路径到达同一答案，用 LLM 当评委加人工抽查。

下面是能直接粘到任何支持子智能体的框架里的通用引导提示，一次应用整套方法：

You are the LEAD agent. Do not write code yet.
1. Read AGENTS.md and the task below. Write a plan to PLAN.md.
2. Classify the task: SIMPLE (do it yourself), COMPARISON (2-4 workers), or BROAD (5+ workers).
3. For each worker, define: objective, files in scope, files OUT of scope,
   output format (max 30 lines), and model tier (small or medium).
4. Run workers in parallel. Collect results in FINDINGS.md.
5. Synthesise and implement on a branch yourself.
6. Spawn ONE reviewer on a different model to try to break your change.
Budget: stop and report if you exceed 15 worker calls.

一句话总结：负责人定计划，工人干活，负责人收工，陌生人（不同模型的评审）来验收。

什么时候该上多智能体：看三个条件

工作范围够广、各部分互相独立、结果容易被低成本验证，这三个条件同时满足，多智能体就能赚回它的 token 账单。

前面八个任务全符合这个模式，所以每一单都值得花成本。值得上多智能体的典型模式如下：

• 对大型代码库做广泛阅读（如单体仓库映射）；

• 跨多个软件包做并行独立编辑（如依赖升级）；

• 功能专属的专家角色（如全栈构建）；

• 由评估者裁决的竞争方案（如原型竞赛）；

• 廉价读者供养高级作者（如文档团队）；

• 批量重复工作（如本地化和类型提示）；

• 跨厂商审查（Claude 写、Codex 审，或反过来也可以）。

多智能体协同工作能带来什么？比如：

• 一个下午跑完 40 万行单体库的架构图；
• 一晚上升级完 12 个软件包的依赖且测试全过；
• 午饭前，把应用程序翻译成四种语言；
• 早晨醒来，收获 200 个带类型提示、mypy 干净的文件。

什么时候不该上多智能体：五个特征

Anthropic 自己在文章里提到过：多智能体不适合智能体必须共享上下文、或彼此严重依赖的场景。多数编码任务正是如此。下面五种特征出现，直接砍团队：

•改动紧密耦合：五个文件共享状态，需要一个人同时攥在手里，不是一个团队。

•任务很简单：一个堆栈清晰的报错，一个智能体加一个测试就够，不需要一支队伍。

•输出无法低成本验证：十个没人审的 diff 是技术债，不是生产力。

•预算紧张：记住乘数效应。单智能体约 4×，智能体团队约 7×，多智能体系统约 15×。

•代码敏感：每多接一个供应商，代码就多过一道手。

我的经验法则：先从一个智能体+一个完善计划起步，只有当你能说出 "隔离、并行或独立审查" 里的具体某一条，才加第二个智能体。说不出理由，你基本不需要它。

五大 Harness 排名

一个 Harness 囊括模型外面的一切：工具、权限、上下文管理和子智能体机制。

同一模型在不同 Harness 上表现可以差很多，所以 Terminal-Bench 2.0 这类榜单评的是 "Harness+模型" 组合，不是模型本身。

以下是我参照 2026 年 10 月的每日多智能体工作情况，做出的个人排序：

1.Claude Code：编排工具最全（子智能体、团队、钩子、技能、工作流），成本文档也是所有供应商里最详尽的。

2.OpenAI Codex CLI：基准成绩最强（Terminal-Bench 2.0 的 82 分），codex exec 做无头扇出很顺手。

3.OpenCode：性价比最高，每个智能体独立计费，客户端免费。

4.GitHub Copilot CLI：/fleet、/delegate 就紧贴着你的 PR，这是一大优势。

5.Pi：轻量、透明、可脚本化、可嵌入，是自建编排器最好的地基。

另外两个值得留意：

• Antigravity CLI 架构很强，但刚从 Gemini CLI 强迁移过来，还在稳定期；
• Grok Build 发展很快，但 7 月的事件让它暂时不适合接客户项目。

想当好 "指挥者"，你要掌握这十项技能

编排看着是工具问题，其实是技能问题。工具一个下午，你能学会，技能需要几个月的 “打磨”。这正是 "会跑智能体的开发者" 和 "能主导智能体的开发者" 的分水岭。

1.分解：把目标拆成互相独立的子任务。练法：每个功能开工前写任务清单，标出能并行跑的项目。

2.写精准简报：每份委托都要有目标、范围、范围外清单、输出格式、终止条件。Anthropic 发现模糊简报会让员工重复劳动，这是清单里最重要的一条。

3.上下文工程：分清哪些放 CLAUDE.md/AGENTS.md、哪些放按需加载的技能、哪些根本不该进上下文。精简的上下文既省钱又更准确。

4.熟练 Git：分支、工作树、变基、冲突解决。组第一个并行团队前，先把 git worktree 学明白。

5.测试与验证：强测试套件、类型检查器、linter，能把 "智能体声称有效" 变成 "智能体证明有效"。

6.高效代码审查：你读的 diff 远比写得多，要能一眼看穿薄弱测试、隐蔽行为变更和安全问题。人工+第三方智能体双审最稳。

7.token 与成本认知：跑任务前能估 token，会读 /usage，会为每项任务挑最经济的模型。本文每张账单都是这门技能的练习。

8.安全与权限：决定哪些智能体能改文件、跑命令、碰网络，确保提示词和日志里不夹带敏感信息。最小权限同样适用于智能体。

9.Shell 与自动化：codex exec、claude -p、copilot -p、pi -p 这类无头模式，能把智能体变成构建脚本和 CI 流水线的 “积木”。

10.评估：得能判断多智能体是否真的比单体强，可以拿真实任务建小基准，按标准打分。没有评估，你就是在盲目花钱，而不是拿证据说话。

结尾：一套能带走的判断框架

最后把全文压成一个判断清单。下次你想 "要不要上多智能体、要不要买 API、要不要上本地 LLM"，按这个顺序走：

1.先估算 token：这任务该用哪个档位的模型，大概烧多少。

2.看并行价值：范围广、独立、结果可验证，这三个条件缺一个，就别上团队。

3.分难易路由：前沿模型管架构和疑难，中端管实现，小模型管读日志和跑测试。

4.先本地后云端：能本地跑的先本地，云端留给非高峰。

5.最后设上限：脚本加预算上限，跑完读 /usage 归因。

说明：本文每张账单都是我按一个 "中等规模代码库" 假设的 API 价格和 token 量估算的，不是真实用量；提示缓存通常会降低实际费用，订阅用户则是从套餐额度里扣。厂商价格变动很快，真要下单，以官方定价页为准。

学编排最快的方式，是从一个小而明确的计划开始，然后不断练习 "什么时候该把活交给谁"。

这也是我在做的第一件事：帮你迈出管理 10000 个智能体的第一步。