前言

在当今 AI 生态中，没有任何一个大模型能够完美解决所有问题。代码生成需要 Claude 3 Opus，逻辑推理需要 DeepSeek V3，创意写作需要 GPT-4o，本地推理需要 Llama 3，不同场景对模型的需求千差万别。

OpenClaw 作为一个可扩展的 AI 代理平台，设计了一套灵活的多模型混合调度机制，允许用户根据场景动态选择最合适的模型，同时保证系统的稳定性和经济性。本文将深入解析这套机制的设计思路和实现原理。

一、为什么需要多模型混合调度？

1.1 不存在银弹：每个模型都有擅长领域

模型类别	优势场景	劣势
Claude 3 Opus	复杂代码、长文档理解、深度推理	成本较高
GPT-4o	多模态、创意写作、工具调用	API 敏感，国内访问不便
DeepSeek V3/V2.5	代码生成、逻辑推理	上下文窗口限制
Doubao Kimi K2	超长上下文、检索增强	中文优化
Llama 3 / Mistral	本地部署、隐私敏感场景	推理能力有限
Gemini	多模态理解、谷歌生态集成	区域限制

OpenClaw 的设计哲学是：把正确的任务交给正确的模型，而不是强迫用户绑定到某一家厂商。

1.2 成本优化：快慢模型搭配使用

不是所有请求都需要顶级模型：

• 简单查询：使用轻量模型快速响应，降低成本
• 复杂推理：使用重量级模型保证质量
• 流式输出：支持增量响应，提升用户体验

1.3 高可用：故障自动转移

当某个模型提供商服务不可用时，OpenClaw 可以自动切换到备用模型，保证服务不中断。

二、OpenClaw 模型抽象层设计

2.1 统一模型接口

OpenClaw 对所有模型进行了抽象，定义了统一的 ModelProvider 接口：

`typescript interface ModelProvider { // 模型名称 name: string;

// 支持的功能 capabilities: { streaming: boolean; functionCall: boolean; vision: boolean; };

// 核心推理方法 complete(params: CompletionParams): Promise;

// 流式推理 completeStreaming(params: CompletionParams): AsyncIterable;

// 计算 token 数量 countTokens(text: string): Promise; } `

所有模型提供商都实现了这个统一接口，调度层不需要关心具体实现细节。

2.2 模型注册机制

OpenClaw 使用依赖注入方式进行模型注册：

`typescript // 在 config.ts 中注册模型 registerModel('deepseek', new DeepSeekProvider({ apiKey: process.env.DEEPSEEK_API_KEY, baseURL: process.env.DEEPSEEK_BASE_URL, defaultModel: 'deepseek-chat' }));

registerModel('qianfan-deepseek', new QianfanProvider({ ak: process.env.QIANFAN_AK, sk: process.env.QIANFAN_SK, defaultModel: 'deepseek-v3' }));

registerModel('doubao', new DoubaoProvider({ apiKey: process.env.DOUBAO_API_KEY, endpoint: process.env.DOUBAO_ENDPOINT, }));

registerModel('claude', new AnthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY, })); `

这种设计使得添加新模型非常简单，只需要实现接口并注册即可。

2.3 模型元数据管理

每个模型都包含丰富的元数据：

`yaml modelMetadata:

id: deepseek-chat provider: deepseek contextWindow: 64000 maxOutput: 4096 costPer1kTokens: input: 0.001 output: 0.002 capabilities: streaming: true functionCall: true vision: false preferredFor: ['code', 'reasoning'] `

这些元数据在调度决策时会被使用。

三、核心调度算法

3.1 选择策略：四种调度模式

OpenClaw 支持四种调度模式：

模式一：显式指定模型

用户或技能可以直接指定使用哪个模型：

typescript // 在请求中指定模型 const response = await openclaw.complete({ messages: [...], model: 'claude-3-opus' });

这种方式优先级最高，适用于对质量有明确要求的场景。

模式二：基于任务类型自动选择

根据任务类型自动匹配最适合的模型：

typescript // 任务类型到模型的映射 const taskTypeMapping = { 'code': ['deepseek-v3', 'claude-3-opus', 'gpt-4o'], 'reasoning': ['deepseek-v3', 'claude-3-opus'], 'chat': ['doubao', 'gpt-3.5-turbo'], 'vision': ['gpt-4o', 'gemini-pro-vision'], 'long-context': ['kimi-k2', 'claude-3-sonnet'], };

调度器会按优先级尝试第一个可用的模型。

模式三：基于代价最小化选择

在满足质量要求的前提下，选择最便宜的可用模型：

代价 = 价格权重 × 价格 + 延迟权重 × 延迟 + 负载权重 × 当前负载

调度器选择代价最小的模型。这种模式适用于批量处理场景，最大化成本效益。

模式四：故障转移模式

按优先级列表依次尝试，直到成功：

typescript const fallbackOrder = ['deepseek-v3', 'doubao', 'claude-sonnet']; for (const modelId of fallbackOrder) { try { return await tryModel(modelId, params); } catch (err) { // 记录错误，继续下一个 logger.warn(Model failed, trying next...); } }

这种模式保证高可用性。

3.2 负载均衡

OpenClaw 会跟踪每个模型提供商的当前负载和失败率：

`typescript class LoadBalancer { private modelHealth: Map<string, { lastFailure: number; failureCount: number; isHealthy: boolean; }>;

// 基于熔断模式 shouldTry(modelId: string): boolean { const health = this.modelHealth.get(modelId); if (!health) return true;

// 如果连续失败超过阈值，熔断一段时间
if (health.failureCount > 3 && 
    Date.now() - health.lastFailure < 60000) {
  return false;
}

return true;
}

recordSuccess(modelId: string) { // 重置失败计数 const health = this.modelHealth.get(modelId); if (health) { health.failureCount = 0; health.isHealthy = true; } }

recordFailure(modelId: string) { // 更新失败统计 let health = this.modelHealth.get(modelId); if (!health) { health = { lastFailure: 0, failureCount: 0, isHealthy: true }; this.modelHealth.set(modelId, health); } health.lastFailure = Date.now(); health.failureCount++; } } `

熔断器模式防止系统被故障模型拖垮。

3.3 并发控制和排队

为了避免超过 API 速率限制，OpenClaw 实现了并发控制：

`typescript class ConcurrencyLimiter { private concurrentRequests: number = 0; private queue: Deferred[] = [];

async acquire(): Promise { if (this.concurrentRequests < this.maxConcurrency) { this.concurrentRequests++; return; } // 排队等待 const deferred = new Deferred(); this.queue.push(deferred); await deferred.promise; this.concurrentRequests++; }

release(): void { this.concurrentRequests--; if (this.queue.length > 0) { const next = this.queue.shift(); next.resolve(); } } } `

每个模型提供商可以独立配置并发限制。

四、会话级模型覆盖

OpenClaw 支持在会话级别覆盖模型，这是一个非常灵活的特性：

4.1 会话级别模型指定

用户可以在会话开始时指定模型：

``n/openclaw set-model deepseek-v3 `

之后所有请求都会使用这个模型，直到重新设置。

4.2 单次请求覆盖

技能也可以在单次请求中覆盖模型：

ypescript // coding-agent 总是使用强大的代码模型 const result = await agent.complete({ messages: codePrompt, model: 'claude-3-opus', // 强制使用 Opus 保证代码质量 });

4.3 配置文件默认模型

在 config.json 中可以设置全局默认模型：

json { model: { defaultModel: deepseek-v3, fallbackModel: doubao, overrides: { coding-agent: claude-3-opus, summarize: kimi-k2, weather: doubao } } }

不同技能可以使用不同的默认模型。

五、实践：如何配置多模型调度

5.1 最小化配置（单模型）

如果你只有一个 API 密钥，配置非常简单：

json { model: { defaultProvider: deepseek, defaultModel: deepseek-chat, providers: { deepseek: { apiKey: YOUR_API_KEY, baseURL: https://api.deepseek.com/v1 } } } }

5.2 生产环境配置（多模型+故障转移）

推荐的生产配置：

json { model: { defaultModel: deepseek-v3, fallbackOrder: [deepseek-v3, doubao-kimi, claude-3-sonnet], enableAutoFallback: true, providers: { deepseek: { apiKey: YOUR_DEEPSEEK_KEY, maxConcurrency: 5 }, doubao: { apiKey: YOUR_DOUBAO_KEY, endpoint: YOUR_ENDPOINT, maxConcurrency: 10 }, anthropic: { apiKey: YOUR_ANTHROPIC_KEY, maxConcurrency: 3 } }, skillOverrides: { coding-agent: claude-3-opus, summarize: doubao-kimi-k2, weather: doubao } } }

5.3 成本优化配置

如果你主要关心成本：

json { model: { schedulingStrategy: cost-optimized, maxCostPerRequest: 0.05, preferCheaper: true, providers: { local-llama: { baseURL: http://localhost:8000/v1, costPer1kInput: 0, costPer1kOutput: 0 }, deepseek: { apiKey: ..., costPer1kInput: 0.001, costPer1kOutput: 0.002 } } } }

本地模型优先，实在处理不了再回落到 API 模型。

六、流式输出处理

多模型调度的一个挑战是统一流式输出接口。OpenClaw 对不同厂商的流式输出格式进行了归一化处理：

​
` ypescript // OpenClaw 统一流式输出格式 interface StreamingChunk { text: string; // 增量文本 done: boolean; // 是否结束 usage?: { // token 使用量（最后一块） promptTokens: number; completionTokens: number; totalTokens: number; }; toolCall?: ToolCall; // 工具调用信息 }

// 不同厂商转换示例 class OpenAICompatibleAdapter implements ModelProvider { async *completeStreaming(params: CompletionParams): AsyncIterable { const response = await this.openai.chat.completions.create({ ...params, stream: true, });

for await (const chunk of response) {
  yield {
    text: chunk.choices[0]?.delta?.content || '',
    done: chunk.choices[0]?.finish_reason === 'stop',
  };
}

} }

class AnthropicAdapter implements ModelProvider { async *completeStreaming(params: CompletionParams): AsyncIterable { const response = await this.anthropic.messages.create({ ...params, stream: true, });

for await (const event of response) {
  if (event.type === 'content_block_delta') {
    yield {
      text: event.delta.text,
      done: false,
    };
  } else if (event.type === 'message_stop') {
    yield {
      text: '',
      done: true,
      usage: event.message.usage,
    };
  }
}

} } `

​

不管底层厂商是什么格式，上层都以统一方式处理流式输出。

七、token 使用量统计和成本追踪

OpenClaw 会自动统计每个模型的 token 使用量和产生的成本：

​
` ypescript class TokenTracker { private usageByModel: Map<string, { promptTokens: number; completionTokens: number; cost: number; }>;

recordUsage(modelId: string, promptTokens: number, completionTokens: number) { const meta = this.getModelMetadata(modelId); const cost = promptTokens * meta.costPer1kInput / 1000 + completionTokens * meta.costPer1kOutput / 1000;

// 更新统计
const usage = this.usageByModel.get(modelId) || 
  { promptTokens: 0, completionTokens: 0, cost: 0 };
usage.promptTokens += promptTokens;
usage.completionTokens += completionTokens;
usage.cost += cost;
this.usageByModel.set(modelId, usage);

}

getStats() { return Object.fromEntries(this.usageByModel); } } `

你可以随时运行 /status 查看：

``n📊 Model Usage Statistics:

deepseek-v3: Input tokens: 125,432 Output tokens: 48,921 Estimated cost: .22

claude-3-opus: Input tokens: 36,120 Output tokens: 12,450 Estimated cost: .15

Total estimated cost: .37 `

​

方便你掌控成本。

八、最佳实践和经验总结

8.1 推荐组合

根据经验，推荐这样的配置：

• 默认聊天/日常任务：Doubao Kimi K2（性价比高，中文好）
• 代码生成/复杂任务：Claude 3 Opus 或 DeepSeek V3
• 超长上下文处理：Kimi K2（128k+）
• 本地隐私任务：Llama 3 70B（本地部署）
• 故障转移：Always have at least one backup

8.2 成本控制技巧

1. 设置并发限制：避免意外爆发大量请求
2. 使用技能级覆盖：只有复杂任务用贵的模型
3. 定期检查用量：运行 /status 随时掌握
4. 优先用本地模型：对于可预测的简单任务，本地推理免费

8.3 高可用配置

至少配置两个模型提供商：

• 主模型：性能/价格比最好的
• 备用模型：当主模型不可用时自动切换

九、未来演进方向

OpenClaw 的多模型调度还在持续进化：

1. 智能路由：基于内容复杂度自动选择合适模型
2. 模型拼接：将任务分解，不同阶段用不同模型
3. 动态定价：根据厂商实时价格自动选择最划算的
4. 负载感知路由：根据当前延迟自动选择最快响应的模型

总结

OpenClaw 的多模型混合调度机制设计体现了其核心设计哲学：不绑定用户到单一厂商，把正确的任务交给正确的模型。通过统一抽象层、灵活的调度策略、熔断负载均衡、成本追踪等机制，OpenClaw 让多模型管理变得简单而高效。