AI Agent 开发中的模型调度策略：何时用便宜模型，何时用强模型

一个 Agent 跑一次任务，背后可能调用模型十几次。如果每次都用 Claude Opus，成本会让你心疼；但如果全用最便宜的模型，效果又会一塌糊涂。聪明的做法是：按任务类型选模型，把钱花在刀刃上。

为什么 Agent 的成本控制比普通调用更重要

普通的 LLM 调用是"一问一答"：用户发一条消息，模型回一条，结束。

但 Agent 不一样。一个真正的 Agent 任务会触发一系列的模型调用：

先理解任务、制定计划（planning）
依次执行每个步骤，可能调用工具、处理数据（execution）
每步执行后检查结果是否符合预期（reflection）
最后汇总输出（synthesis）

一次看似简单的"帮我分析这份合同里的风险条款"，背后可能是 15 次模型调用。

如果每次都用 Claude Opus 4（约 $15/M tokens），一个任务下来就烧几美元。对于高频场景，成本完全不可接受。

关键洞察：这 15 次调用并不是一样的。有些需要深度推理，有些只是在提取信息，有些甚至只是格式转换。不同步骤对模型能力的需求差异极大。

不同步骤需要什么样的模型

Planning 和 Reflection：需要强模型

这两个步骤决定任务的方向和质量，是整个 Agent 的"大脑"。

Planning 需要模型理解复杂意图、拆解多步骤任务、考虑边界情况。用弱模型做 planning，计划本身就会有缺陷，后续执行再完美也没用。

Reflection 需要模型判断执行结果是否正确、是否偏离目标、是否需要回滚。这里的判断失误会导致整个任务走歪。

推荐：anthropic/claude-opus-4 或 openai/gpt-4o

代码生成：Claude Sonnet 性价比最高

代码生成是个特殊的步骤。它需要足够的推理能力（写出正确逻辑），但不需要 Opus 级别的"战略思维"。

根据实际测试，Claude Sonnet 4 在代码任务上的表现接近 Claude Opus 4，但价格只有后者的五分之一。这是非常划算的替换。

信息提取和简单工具调用：用 mini/flash 级别

这类任务包括：

从文本中提取结构化字段（日期、金额、人名）
判断一段文本属于哪个分类
把工具返回的 JSON 转成自然语言描述
简单的问答（基于已有上下文回答明确问题）

这些任务对推理能力要求不高，用最便宜的模型完全够用。

推荐：openai/gpt-4o-mini 或 google/gemini-2.0-flash

代码示例：一个混合模型的 Agent 框架

下面是一个实际可用的 Python 示例，展示如何根据步骤类型动态选择模型。使用 TheRouter 的 API，只需一个 API Key 就能访问所有模型。

python 复制代码

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["THEROUTER_API_KEY"],
    base_url="https://api.therouter.ai/v1"
)

# 模型配置：按任务类型分配
MODEL_CONFIG = {
    "planning":    "anthropic/claude-opus-4",    # 强推理，做规划
    "reflection":  "anthropic/claude-opus-4",    # 强推理，做审查
    "code":        "anthropic/claude-sonnet-4",  # 代码能力强，性价比高
    "extract":     "openai/gpt-4o-mini",         # 信息提取，快速便宜
    "classify":    "google/gemini-2.0-flash",    # 分类判断，极速极省
    "summarize":   "openai/gpt-4o-mini",         # 摘要生成，无需强模型
}

def call_model(task_type: str, prompt: str, system: str = None) -> str:
    model = MODEL_CONFIG[task_type]
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": prompt})

    response = client.chat.completions.create(
        model=model,
        messages=messages,
        max_tokens=2048,
    )
    return response.choices[0].message.content


def run_agent(user_request: str) -> str:
    print(f"[planning] 使用 {MODEL_CONFIG['planning']}...")

    # Step 1: Planning --- 用强模型分析任务，制定执行计划
    plan_prompt = f"""
    用户请求：{user_request}

    请将这个任务拆解成具体的执行步骤，每个步骤标注类型：
    - code: 需要生成/修改代码
    - extract: 从文本中提取信息
    - classify: 判断分类
    - summarize: 生成摘要

    输出格式（JSON）：
    {{"steps": [{{"type": "code", "description": "...", "input": "..."}}]}}
    """
    plan_json = call_model("planning", plan_prompt)

    # 实际项目中这里会 parse JSON，这里用伪代码简化
    import json
    try:
        plan = json.loads(plan_json)
        steps = plan.get("steps", [])
    except:
        steps = [{"type": "summarize", "description": "回答用户问题", "input": user_request}]

    results = []
    for i, step in enumerate(steps):
        step_type = step.get("type", "summarize")
        step_input = step.get("input", step.get("description", ""))

        print(f"[step {i+1}] 类型={step_type}，使用 {MODEL_CONFIG.get(step_type, MODEL_CONFIG['summarize'])}...")

        result = call_model(
            task_type=step_type if step_type in MODEL_CONFIG else "summarize",
            prompt=step_input
        )
        results.append({"step": step.get("description"), "result": result})

    # Step 3: Reflection --- 用强模型审查执行结果
    print(f"[reflection] 使用 {MODEL_CONFIG['reflection']}...")
    reflection_prompt = f"""
    原始请求：{user_request}

    执行结果：
    {json.dumps(results, ensure_ascii=False, indent=2)}

    请审查上述执行结果：
    1. 是否完整回答了用户的请求？
    2. 是否有明显错误或遗漏？
    3. 输出最终的综合答案。
    """
    final_answer = call_model("reflection", reflection_prompt)
    return final_answer


# 运行示例
if __name__ == "__main__":
    result = run_agent("帮我写一个 Python 函数，从 JSON 数组中提取所有 email 字段，去重后排序")
    print("\n=== 最终结果 ===")
    print(result)

运行这个 Agent，你会在日志里看到不同步骤使用了不同的模型：

复制代码

[planning] 使用 anthropic/claude-opus-4...
[step 1] 类型=code，使用 anthropic/claude-sonnet-4...
[step 2] 类型=extract，使用 openai/gpt-4o-mini...
[reflection] 使用 anthropic/claude-opus-4...

成本对比：全强模型 vs 混合路由

以一个典型的文档分析 Agent 为例（处理一份 5 页的合同文档）：

步骤	Token 消耗（约）	全强模型（Opus）	混合路由
Planning	2,000	$0.030	$0.030（Opus）
文本提取 × 5	8,000	$0.120	$0.008（GPT-4o-mini）
分类判断 × 10	5,000	$0.075	$0.003（Gemini Flash）
代码生成 × 2	4,000	$0.060	$0.012（Sonnet）
Reflection	3,000	$0.045	$0.045（Opus）
合计	22,000	$0.330	$0.098

混合路由把成本降低了 70%，同时在关键步骤（planning/reflection）保持了最高质量。

对于高频场景，比如每天跑 1000 次这样的 Agent，节省的费用是：

全强模型： $330/天 \approx$ 10,000/月
混合路由： $98/天 \approx$ 3,000/月

省下来的 $7,000/月，对独立开发者或小团队来说非常可观。

为什么 TheRouter 让混合路由变得简单

混合路由最大的工程障碍，通常是需要维护多个 API 客户端：

python 复制代码

# 没有路由网关的痛苦：每个提供商都要单独配置
anthropic_client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
openai_client = openai.OpenAI(api_key=OPENAI_KEY)
google_client = google.generativeai.configure(api_key=GOOGLE_KEY)

# 每次调用都要选不同的客户端和不同的 API 格式

这带来了额外的复杂度：多个 API Key 要管理、多种 API 格式要适配、多个 SDK 要维护。

使用 TheRouter，只需一个客户端：

python 复制代码

# 使用 TheRouter：一个客户端，切换 model 参数即可
client = OpenAI(
    api_key=THEROUTER_API_KEY,
    base_url="https://api.therouter.ai/v1"
)

# Planning：强模型
plan = client.chat.completions.create(model="anthropic/claude-opus-4", ...)

# 提取：便宜模型
data = client.chat.completions.create(model="openai/gpt-4o-mini", ...)

# 代码：Sonnet
code = client.chat.completions.create(model="anthropic/claude-sonnet-4", ...)

同一个 client 对象，切换 model 参数就行。API 格式统一，不需要适配不同 SDK。

真实案例：法律文档审查 Agent

一个朋友在做合同风险审查的 SaaS 工具。最初全程用 Claude Opus，每份合同分析费用约 $0.50，用户量上来后成本急剧攀升。

改造方案：

文本分块和初步分类 ：改用 google/gemini-2.0-flash，速度更快，每份合同这部分成本从 $0.15 降到$ 0.01
具体条款的风险识别 ：保留 anthropic/claude-opus-4（这是核心价值，不能妥协）
标准条款说明生成 ：改用 openai/gpt-4o-mini，费用降低 90%
最终风险报告 ：保留 anthropic/claude-opus-4

改造后每份合同的分析成本从 $0.50 降到$ 0.18，降幅 64%，同时用户反馈质量没有下降（因为关键推理步骤没有妥协）。

小结：混合路由的设计原则

识别关键路径：哪些步骤的质量直接影响最终结果？这些用强模型，不省这点钱。
批量操作用弱模型：提取、分类、格式转换这类"体力活"，便宜模型完全够用。
代码生成是个例外：Sonnet 级别往往足够，不需要 Opus。
用一个网关统一管理：减少工程复杂度，避免维护多套 API 配置。
记录每步的 token 消耗：建立成本基线，才能持续优化。

混合路由不是"用便宜货凑合"，而是"把预算分配给真正需要的地方"。这是 Agent 工程从玩具走向产品的必经之路。