<!-- title: Claude Code多模型路由：智能调度降本80% -->

# Claude Code多模型路由实战：Opus规划+Sonnet编码+Haiku执行

> **适用人群**：已掌握Claude Code基础操作的开发者，希望在实际项目中通过智能模型路由策略降低80%成本而不牺牲代码质量。
>
> **学习目标**：理解Opus/Sonnet/Haiku三模型的能力边界与定价差异，掌握opusplan内置路由、subagent模型覆写、第三方路由器三种方案，并能根据任务特征构建自己的混合调度策略。

## 一、为什么需要多模型路由

Claude Code默认使用Sonnet模型——它在速度、成本和能力之间取得了最佳平衡。但一个真实的开发会话中，并非所有操作都需要同等推理能力：

| 操作类型 | 推理需求 | 占会话Token比例 |
|----------|----------|-----------------|
| 架构设计与技术决策 | 极高 | ~10% |
| 核心业务逻辑编写 | 高 | ~25% |
| 测试用例生成 | 中 | ~20% |
| 代码格式化/JSDoc/注释 | 低 | ~15% |
| 文件搜索/Grep/目录遍历 | 极低 | ~30% |

一组来自社区的真实数据：在连续一周的Claude Code使用中，**85%的Token消耗发生在不需要Opus级推理能力的操作上**。如果全部使用Opus，你正在为搜索文件和添加注释的操作支付5倍溢价。

## 二、三模型能力画像与基准数据

### 2.1 模型规格一览

当前Claude家族的三个主力模型：

| 维度 | Opus 4.7 | Sonnet 4.6 | Haiku 4.5 |
|------|----------|------------|-----------|
| 定位 | 旗舰推理 | 日常全能 | 高速执行 |
| 上下文窗口 | 1M tokens | 1M tokens | 1M tokens |
| 输入价格 ($/MTok) | $5.00 | $3.00 | $0.80 |
| 输出价格 ($/MTok) | $25.00 | $15.00 | $4.00 |
| 首Token延迟 (TTFT) | ~3.2s | ~1.4s | ~0.5s |
| 输出速度 (Tok/s) | ~45 | ~80 | ~150 |

### 2.2 编码基准实测

SWE-bench Verified是衡量AI模型解决真实GitHub Issue能力的金标准，包含500个人工验证的真实软件工程问题：

| 基准 | Opus 4.7 | Opus 4.6 | Sonnet 4.6 | Haiku 4.5 |
|------|----------|----------|------------|-----------|
| SWE-bench Verified | 87.6% | 80.8% | 79.6% | 62.4% |
| HumanEval+ | 96.8% | 95.2% | 94.8% | 89.1% |
| LiveCodeBench | 78.3% | 73.5% | 72.1% | 58.7% |
| Aider Polyglot | 82.1% | 79.4% | 77.8% | 63.2% |

**关键洞察**：Opus与Sonnet在编码基准上的差距仅约1-2个百分点，但价格差距高达67%。对于绝大多数编码任务，Sonnet是性价比之王。Opus的价值体现在需要深度推理的复杂架构决策上。

### 2.3 模型性格差异

三个模型不仅是"快慢贵便宜"的区别，它们有本质不同的"思维方式"：

- **Opus**：深思熟虑型。喜欢全局考量，给出建议前会把所有角度想一遍。擅长发现隐蔽的边界条件和安全隐患。
- **Sonnet**：执行力型。理解需求快速精准，直接给解决方案，不绕弯子。适合日常编码的主战模型。
- **Haiku**：反应速度型。对简单指令的响应极快，但在复杂推理场景下是弱项。批处理重复性任务的最佳选择。

## 三、方案一：opusplan——内置混合路由

### 3.1 opusplan是什么

`opusplan`是Claude Code内置的模型别名，它实现了一种**自动化的两阶段路由**：

```
Plan Mode（规划阶段）→ 自动使用 Opus
Execution Mode（执行阶段）→ 自动切换到 Sonnet
```

这是Anthropic官方推荐的"甜点"方案——用Opus的大脑做规划，用Sonnet的效率做执行。

### 3.2 启用方式

三种方式，按优先级排列：

**方式一：会话内命令**

```bash
# 在Claude Code对话中直接输入
/model opusplan
```

**方式二：启动参数**

```bash
claude --model opusplan
```

**方式三：配置文件持久化**

在项目的`.claude/settings.json`中设置：

```json
{
  "model": "opusplan"
}
```

或在全局配置`~/.claude/settings.json`中设置，对所有项目生效。

### 3.3 opusplan工作流程


![图表1](images/claude-code-tutorial-r3-0012-mermaid-0.png)

> *图表 1*


### 3.4 实际效果对比

在一个中型React项目重构任务中（12个组件迁移到Server Components）：

| 指标 | 全程Opus | 全程Sonnet | opusplan |
|------|----------|------------|----------|
| 总Token消耗 | 285K | 268K | 271K |
| 总成本 | $5.12 | $2.85 | $3.21 |
| 规划质量 | 优秀 | 良好 | 优秀 |
| 代码质量 | 优秀 | 良好 | 良好+ |
| 犀利发现Bug数 | 4 | 2 | 4 |

opusplan以Sonnet 1.13倍的成本获得了与全程Opus相当的规划质量。关键的4个隐蔽Bug全部在Plan阶段被Opus发现。

## 四、方案二：Subagent模型覆写

### 4.1 逐Agent指定模型

opusplan是粗粒度的"规划/执行"二分法。更精细的控制是在每个subagent（子代理）级别指定模型。

Claude Code的Task工具支持`model`参数，可以为每个子代理单独选择模型：

```json
{
  "subagent_type": "general-purpose",
  "model": "haiku",
  "description": "批量添加JSDoc注释",
  "prompt": "为src/目录下所有TypeScript文件添加JSDoc注释..."
}
```

### 4.2 模型选择的优先级链

当Claude Code需要决定使用哪个模型时，遵循以下优先级：


![图表2](images/claude-code-tutorial-r3-0012-mermaid-1.png)

> *图表 2*


### 4.3 实战：三层路由架构

在`.claude/subagents/`目录下创建专门的子代理配置文件，实现精细化的模型路由：

**探索型代理（用Haiku）—— `.claude/subagents/explore.md`**

```markdown
---
model: haiku
description: 快速代码探索与搜索
tools:
  - Glob
  - Grep
  - Read
---

你是一个代码探索代理。你的任务是快速搜索代码库，
找到相关文件和代码位置。不需要修改任何文件。
保持输出简洁，直接返回搜索结果。
```

**编码型代理（用Sonnet）—— `.claude/subagents/coder.md`**

```markdown
---
model: sonnet
description: 通用编码实现
---

你是一个编码代理。根据提供的规格说明编写代码。
遵循项目现有的代码风格和模式。
确保代码通过项目的所有lint检查。
```

**架构型代理（用Opus）—— `.claude/subagents/architect.md`**

```markdown
---
model: opus
description: 架构设计与技术决策
---

你是一个架构师代理。负责分析复杂的技术决策、
评估不同方案的trade-off、发现潜在的架构风险。
输出结构化的分析报告，包含明确的建议。
```

### 4.4 在Skill中调用三层路由

创建一个Skill来编排这三层路由：

```markdown
---
name: smart-refactor
description: 智能重构工作流
---

## 工作流

1. 首先启动architect代理（Opus），分析重构范围和方案
2. 然后启动explore代理（Haiku），搜索所有受影响文件
3. 最后启动coder代理（Sonnet），按计划执行重构

请按顺序执行以下步骤：

### Step 1: 架构分析
使用architect子代理分析当前请求的技术影响。

### Step 2: 影响范围搜索
使用explore子代理搜索所有需要修改的文件。

### Step 3: 执行重构
根据前两步的结果，使用coder子代理执行代码修改。
```

### 4.5 成本计算

以一个实际重构任务为例（重构15个文件的API层）：

| 阶段 | 模型 | Token消耗 | 成本 |
|------|------|-----------|------|
| 架构分析 | Opus | 12K input + 3K output | $0.14 |
| 范围搜索 | Haiku | 45K input + 5K output | $0.06 |
| 代码实现 | Sonnet | 120K input + 30K output | $0.81 |
| 测试生成 | Haiku | 60K input + 15K output | $0.12 |
| **总计** | **混合** | **290K** | **$1.13** |

对比全程使用Opus：290K tokens → $5.65。**三层路由节省了80%的成本**。

## 五、方案三：第三方路由器

### 5.1 claude-router

社区项目`claude-router`（github.com/0xrdan/claude-router）提供了更智能的自动路由：

**安装：**

```bash
# 作为Claude Code Skill安装
claude skill add https://github.com/0xrdan/claude-router
```

**核心路由逻辑：**


![图表3](images/claude-code-tutorial-r3-0012-mermaid-2.png)

> *图表 3*


### 5.2 自定义路由规则

在项目的`.claude/settings.json`中配置路由规则：

```json
{
  "routing": {
    "rules": [
      {
        "condition": "task_type == 'architecture'",
        "model": "opus"
      },
      {
        "condition": "task_type == 'search' && context_length < 50000",
        "model": "haiku"
      },
      {
        "condition": "default",
        "model": "sonnet"
      }
    ],
    "fallback": "sonnet"
  }
}
```

### 5.3 三种方案对比

| 维度 | opusplan | Subagent覆写 | 第三方路由器 |
|------|----------|-------------|-------------|
| 配置复杂度 | 极低 | 中 | 高 |
| 粒度 | 粗（规划/执行） | 细（逐Agent） | 最细（自动判断） |
| 成本节省 | ~37% | ~80% | ~75-85% |
| 代码质量 | 高 | 高 | 依赖路由准确性 |
| 维护成本 | 零 | 低 | 中 |
| 推荐场景 | 日常开发 | 结构化项目 | 大型团队 |

## 六、完整实战案例：从零搭建混合路由

### 6.1 项目背景

假设我们要为一个Next.js项目实现混合路由策略。项目包含：
- 50+ API路由
- 30+ React组件
- 20+ 数据库模型
- 完整的测试套件

### 6.2 Step 1：创建目录结构

```bash
mkdir -p .claude/subagents
```

### 6.3 Step 2：配置默认模型

编辑`.claude/settings.json`：

```json
{
  "model": "opusplan",
  "permissions": {
    "allow": [
      "Bash(npm test:*)",
      "Bash(npm run lint:*)",
      "Read",
      "Glob",
      "Grep"
    ]
  }
}
```

### 6.4 Step 3：创建子代理配置

**文件：`.claude/subagents/code-explorer.md`**

```markdown
---
model: haiku
description: 高速代码探索
allowedTools:
  - Glob
  - Grep
  - Read
---

快速搜索代码库，定位文件和代码段。
只读取和搜索，不修改任何文件。
输出格式：文件路径 + 行号 + 关键代码片段。
```

**文件：`.claude/subagents/test-generator.md`**

```markdown
---
model: haiku
description: 测试用例生成器
allowedTools:
  - Read
  - Write
  - Bash(npx jest:*)
---

根据提供的函数签名和实现，生成完整的单元测试。
遵循项目现有的测试模式和mock策略。
覆盖率目标：80%以上。
```

**文件：`.claude/subagents/code-reviewer.md`**

```markdown
---
model: opus
description: 深度代码审查
allowedTools:
  - Read
  - Grep
  - Glob
---

进行深度代码审查，关注以下维度：
1. 安全漏洞（OWASP Top 10）
2. 性能瓶颈
3. 架构一致性
4. 边界条件处理
5. 错误处理的完整性

输出结构化审查报告，按严重程度分级。
```

### 6.5 Step 4：创建路由编排Skill

**文件：`.claude/skills/smart-dev.md`**

```markdown
---
name: smart-dev
description: 智能混合模型开发工作流
---

# 智能开发工作流

根据任务类型自动选择最优模型组合。

## 工作流步骤

1. **需求分析**（Opus）：
   使用code-reviewer子代理理解需求和现有架构
   输出：技术方案文档

2. **代码定位**（Haiku）：
   使用code-explorer子代理快速搜索所有受影响文件
   输出：文件清单和修改范围

3. **代码实现**（Sonnet，通过opusplan自动路由）：
   根据方案和范围直接执行编码
   输出：修改后的文件

4. **测试生成**（Haiku）：
   使用test-generator子代理为新代码生成测试
   输出：测试文件

5. **质量审查**（Opus）：
   使用code-reviewer子代理审查最终代码
   输出：审查报告和改进建议
```

### 6.6 Step 5：验证路由是否生效

启动Claude Code并运行：

```bash
claude --model opusplan
```

在会话中观察模型切换行为：

```
> /smart-dev 为用户模块添加双因素认证功能

[Plan Mode - 使用Opus]
分析现有认证架构...
发现3个需要修改的核心文件...
识别出2个潜在安全风险...

[Execution Mode - 切换到Sonnet]
正在修改 src/auth/two-factor.ts...
正在修改 src/api/auth-routes.ts...
正在更新 src/middleware/auth.ts...

[Subagent - Haiku]
搜索所有使用auth middleware的文件...找到12个

[Subagent - Haiku]
生成测试文件...coverage: 87.3%

[Subagent - Opus]
审查报告：
  - CRITICAL: 时间窗口验证存在竞态条件
  - WARNING: backup codes未加密存储
  - INFO: 建议添加rate limiting
```

### 6.7 Token消耗追踪

使用`/cost`命令查看实时成本：

```
Session Cost Breakdown:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Opus (规划+审查):    $0.42  (18%)
Sonnet (编码):        $1.24  (54%)  
Haiku (搜索+测试):    $0.15  (7%)
Infrastructure:       $0.47  (21%)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Total:                $2.28

vs 全程Opus:          $7.85
节省:                  71%
```

## 七、任务-模型匹配决策树

根据任务特征选择最优模型的决策流程：


![图表4](images/claude-code-tutorial-r3-0012-mermaid-3.png)

> *图表 4*

## 八、常见问题与踩坑

### 8.1 Subagent模型覆写不生效

**问题**：在subagent frontmatter中设置了`model: haiku`，但实际仍使用主会话模型。

**原因**：存在已知Bug——Agent工具调用的`model`参数记录在请求日志中但未实际改变模型选择（参见GitHub Issue #54448）。

**解决方案**：

```bash
# 使用环境变量方式强制覆写
export CLAUDE_CODE_SUBAGENT_MODEL=haiku
claude
```

或在`.claude/settings.json`中设置：

```json
{
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}
```

### 8.2 opusplan在Auto-Accept模式下行为异常

**问题**：启用opusplan后切换到Auto-Accept模式，所有操作都使用Sonnet。

**原因**：Auto-Accept模式本质上是跳过Plan阶段的确认步骤，因此opusplan直接进入执行阶段使用Sonnet。这是设计行为而非Bug。

**解决方案**：需要Opus推理的场景，显式使用`/model opus`而非依赖opusplan的自动路由。

### 8.3 Haiku生成测试质量不足

**问题**：使用Haiku生成的测试用例过于简单，覆盖率虚高但实际测试价值低。

**解决方案**：采用"Haiku生成+Sonnet审查"的两阶段策略：

```markdown
## 测试工作流

1. 使用Haiku快速生成测试骨架和基础用例
2. 使用Sonnet审查测试质量，补充边界条件和异常场景
```

### 8.4 模型切换时的上下文丢失

**问题**：在opusplan模式下从Plan切换到Execution时，部分上下文信息丢失。

**解决方案**：在Plan阶段结束时确保Opus输出完整的结构化计划文档：

```
请将分析结果以以下格式输出：
## 架构决策
- 决策1: ...
- 决策2: ...
## 修改文件清单
- file1.ts: [修改说明]
## 注意事项
- 注意1: ...
```

这样即使模型切换，结构化的文本上下文也能被Sonnet完整接收。

## 九、进阶：基于Claude Code SDK的路由服务

对于需要编程化控制的场景，可以使用Claude Code SDK构建自定义路由服务：

```typescript
import { ClaudeCode } from '@anthropic-ai/claude-code';

// 任务分类器：根据任务特征选择模型
function selectModel(task: string, contextSize: number): string {
  // 大上下文 + 复杂任务 → Opus
  if (contextSize > 100_000 && isComplex(task)) return 'opus';
  // 搜索/格式化/批量操作 → Haiku
  if (isSimpleOrBatch(task)) return 'haiku';
  // 默认 → Sonnet
  return 'sonnet';
}

// 路由执行器
async function routedExecute(task: string) {
  const model = selectModel(task, estimateContextSize(task));
  
  const result = await ClaudeCode.create({
    model,
    prompt: task,
    options: {
      maxTurns: model === 'haiku' ? 5 : 20,
      allowedTools: model === 'haiku' 
        ? ['Read', 'Glob', 'Grep'] 
        : undefined
    }
  });
  
  return result;
}
```

这种方案适合CI/CD流水线和批量自动化场景，将路由逻辑从配置文件升级为可编程控制。

## 十、总结：模型路由策略速查表

| 场景 | 推荐模型 | 理由 |
|------|----------|------|
| 架构设计/技术选型 | Opus | 需要深度推理和全局视角 |
| 安全审计/代码审查 | Opus | 发现隐蔽漏洞需要最强推理 |
| 日常功能开发 | Sonnet | 性价比最优的编码模型 |
| Bug修复 | Sonnet | 理解代码+精准修改 |
| 代码重构 | Sonnet | 模式识别+批量修改 |
| 文件搜索/代码定位 | Haiku | 不需推理，速度优先 |
| 批量添加注释/JSDoc | Haiku | 机械性任务，成本敏感 |
| 测试用例生成 | Haiku→Sonnet审查 | 生成用Haiku，审查用Sonnet |
| 文档生成 | Haiku | 格式化任务，不需深度推理 |
| 通用开发（不想选模型） | opusplan | 自动路由，零配置 |

**核心原则**：推理密集型任务用Opus，编码密集型任务用Sonnet，吞吐密集型任务用Haiku。大多数开发者80%的时间应该使用Sonnet或opusplan。

## 延伸阅读

- [Anthropic Advisor Strategy: Cut Claude API Costs by Up to 85%](https://mindwiredai.com/2026/04/13/claude-api-advisor-strategy-cost-reduction/) — Anthropic官方推荐的Advisor策略详解
- [Claude Code Model Configuration Docs](https://code.claude.com/docs/en/model-config) — 官方模型配置文档，包含opusplan完整说明
- [claude-router: Intelligent Model Orchestration](https://github.com/0xrdan/claude-router) — 社区开源路由器项目

## 参考来源

1. [Model configuration - Claude Code Docs](https://code.claude.com/docs/en/model-config) — Anthropic官方模型配置文档，opusplan别名说明
2. [How to Cut Claude Code Costs by 80% with Hybrid Model Routing](https://ofox.ai/blog/claude-code-hybrid-routing-pattern-2026/) — 混合路由模式的实战案例与成本数据
3. [Claude Code 的模型选择：Opus/Sonnet/Haiku 怎么选？](https://zhuanlan.zhihu.com/p/2016267296633550608) — 知乎中文实测对比，含具体Token成本计算
4. [Claude Benchmarks 2026: Every Score for Opus, Sonnet & Haiku](https://www.morphllm.com/claude-benchmarks) — 三模型全基准数据汇总
5. [Anthropic Claude API Pricing 2026](https://www.aipricing.guru/anthropic-pricing/) — 最新API定价数据

---

*训练营适用性评估*：本教程适合AI编程进阶训练营（Day 3-4），学员需具备Claude Code基础使用经验。建议教学时长2-3小时，包含1小时讲解 + 1小时动手配置三层路由 + 30分钟成本对比讨论。前置条件：已完成Claude Code入门安装和基础操作练习。

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)
