Fusão de modelos em produção: Por dentro do OrcaRouter Fusion e do Routing DSL

Três modelos de fronteira em paralelo, uma resposta de volta. Chame-o em uma linha — ou componha a sua própria.

TL;DR. Claude Fable 5 foi removido. A resposta não é um modelo maior — é um painel: execute vários modelos de fronteira em paralelo e deixe um juiz retornar a resposta mais forte. O OrcaRouter oferece isso de duas maneiras: roteadores integrados orcarouter/fusion que você chama como qualquer modelo, e uma Routing DSL para compor as suas próprias. Este é o guia de campo para ambos — com receitas de copiar-e-colar, os cinco árbitros (incluindo synthesize, o Mixture-of-Agents fuse), e como implementá-lo sem apostar o seu SLA.

Parte 1 — Chame-o em uma linha: os roteadores Fusion integrados

Fable 5 foi descontinuada e restrita, então não é mais amplamente chamável. Fusion reconstrói esse nível a partir dos modelos que você pode ainda chamar — um roteador drop-in, compatível com OpenAI, que executa um painel de modelos de fronteira em paralelo e retorna a resposta mais forte. Três níveis selecionados são enviados em cada espaço de trabalho:

Os três níveis do Fusion (composição do painel × janela de contexto)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Janela de contexto: 1.000.000

Melhor para: nível Fable-5 inteligência máxima

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Janela de contexto: 1.000.000

Melhor para: inferência balanceada de nível Fable-5

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Janela de Contexto: 200,000

Melhor para: inferência rápida e barata de nível Fable-5

(Context window = o menor membro do painel — a restrição vinculante em um fan-out.)

Estes não são slugs de marketing; são roteadores DSL pré-compilados gerenciados centralmente. Aqui está o real programa orcarouter/fusion, na íntegra:

version: 1
rules:
  - id: hard_panel
    when: task_class == "code" || task_class == "agent" || code_keyword_density >= 0.3 || has_tools || difficulty >= 0.3
    use:
      parallel:
        - { model: "anthropic/claude-opus-4.8" }
        - { model: "openai/gpt-5.5" }
        - { model: "google/gemini-3.1-pro-preview" }
      arbiter:
        strategy: best_of_n
        model: "anthropic/claude-opus-4.8"
        template: best_answer_v1
      max_latency_ms: 120000
default:
  delegate: balanced

Duas opções de design que merecem ser destacadas:

Isso só se ativa em trabalho real. A when: gate dispara o painel para prompts de código, agente, uso de ferramentas, denso em código ou alta dificuldade (dificuldade >= 0.3); todo o resto passa para o padrão balanced do workspace. Você paga o preço do painel exatamente onde ele ajuda, não em "oi".

O juiz fornece uma resposta real, literalmente. best_of_n executa um juiz LLM (aqui, Opus 4.8 com o template best_answer_v1) que seleciona o único candidato mais forte e o serve como está — nunca uma fusão diluída. A saída é sempre a resposta de um modelo real.

Parte 2 — Seleção vs. Fusão: best_of_n e o árbitro synthesize

Os roteadores Fusion selecionam. Mas o OrcaRouter também oferece uma fuse estratégia — synthesize, o Mixture-of-Agents padrão adicionado ao mecanismo de roteamento (service/dispatch_parallel/synthesize.go). A diferença é o jogo todo:

Exibição 2 — Selecionar vs. Fundir

best_of_n (SELECT)                         synthesize (FUSE)
 ┌─ Opus 4.8  ─┐                            ┌─ Opus 4.8  ─┐
 ├─ GPT-5.5   ─┼─► judge picks leg k        ├─ GPT-5.5   ─┼─► aggregator LLM writes
 └─ Gemini    ─┘   └─► serve leg k verbatim └─ Gemini    ─┘   ONE new fused answer
   output = a real model's answer             output = a new answer better than any leg

Receita para verdadeira fusão:

use:
  parallel:
    - { model: "anthropic/claude-opus-4.8" }
    - { model: "openai/gpt-5.5" }
    - { model: "google/gemini-3.1-pro-preview" }
  arbiter:
    strategy: synthesize
    model: "anthropic/claude-opus-4.8"   # aggregator: fuses candidates into one new answer
    template: synthesize_v1

Ressalvas honestas:

- A cobrança é N+1 — cada etapa cobra, mais o agregador como uma chamada extra.

- Formato de chat OpenAI apenas na V1 — o agregador emite uma resposta de chat OpenAI; Claude/Gemini nativo clientes degradam para serve-first-successful (pernas ainda cobradas).

O agregador deve estar no conjunto de candidatos autorizados do roteador, ou degrada.

Quando usar qual: best_of_n quando a resposta de um modelo é provavelmente totalmente correta (código, perguntas e respostas factuais) — você quer uma resposta limpa e real. synthesize quando as respostas são complementares (pesquisa, análise, texto longo) e a combinação de pontos fortes supera qualquer resposta individual.

Parte 3 — Construa o seu próprio: o playbook do Routing DSL

Não quer o painel curado? Comece pelos modelos "Claude Fable 5 Level" no editor Routing DSL (eles vêm em todos os workspaces e espelham os roteadores Fusion), depois especialize-se. Seis padrões de copiar e colar:

1 — Envie código que realmente é executado → espalhe, deixe os testes escolherem o vencedor:

- id: hard_code
  when: task_class == "code" && difficulty > 0.6
  use:
    parallel:
      - { model: "anthropic/claude-opus-4.8", thinking_budget_tokens: 16000 }
      - { model: "openai/gpt-5.5", reasoning_effort: high }
      - { model: "google/gemini-3.1-pro-preview" }
    arbiter: { strategy: tests_pass }

tests_pass é baseado em execução — ele serve o candidato que passa pelo seu harness, sem necessidade de juiz LLM.

2 — Pare de pagar demais por prompts fáceis → portão de dificuldade (o padrão Fusion, seus modelos):

- id: easy
  when: difficulty < 0.3
  use: { delegate: cheapest }
- id: hard
  when: difficulty >= 0.3
  use:
    parallel:
      - { model: "anthropic/claude-opus-4.8" }
      - { model: "openai/gpt-5.5" }
    arbiter: { strategy: best_of_n, model: "anthropic/claude-opus-4.8", template: best_answer_v1 }

3 — Mantenha execuções longas do agente nos trilhos → escale apenas quando oscilar:

- id: agent
  when: task_class == "agent" && agent_state.consecutive_errors == 0
  use: { model: "anthropic/claude-sonnet-4.6", affinity_ttl: "5m" }
  on_low_confidence:
    signals: [next_turn_test_failed, self_doubt]
    use: { model: "anthropic/claude-opus-4.8", thinking_budget_tokens: 24000 }

4 — Torne saídas instáveis determinísticas → vote, escale em uma divisão:

- id: extract
  when: task_class == "rag"
  use:
    parallel:
      - { model: "anthropic/claude-opus-4.8" }
      - { model: "openai/gpt-5.5" }
      - { model: "google/gemini-3.1-pro-preview" }
    arbiter: { strategy: majority }
    on_disagreement: { model: "anthropic/claude-opus-4.8", thinking_budget_tokens: 32000 }

5 — Supere a latência de cauda e as oscilações do provedor → corra, sirva o primeiro respondedor:

- id: race
  when: request.stream == true && difficulty < 0.5
  use:
    parallel:
      - { model: "google/gemini-3.5-flash" }
      - { model: "minimax/minimax-m2.7" }
      - { model: "z-ai/glm-5.1" }
    arbiter: { strategy: first }

6 — Implantar sem arriscar o SLA → sombra (avaliar junto com o tráfego ao vivo, registrar o que ele faria escolher + delta de custo, servir a escolha ao vivo) → canário % (dsl_canary_pct 5 → 25 → 100, cripto-aleatório por requisição). Migrar com base na divergência medida, reverter instantaneamente.

A folha de cola: cinco árbitros

Economia e honestidade

Fan-out com controle de dificuldade mantém a conta fixa (Ilustrativo; custo = matemática real do preço do token) — custo combinado = easy_share × cheap + hard_share × panel:

Uma carga de trabalho 70%-fácil executa o painel completo por um terço da conta total do painel.