Fusion de modèles en production : Au cœur d'OrcaRouter Fusion et du DSL de routage

Trois modèles de pointe en parallèle, une seule réponse en retour. Appelez-le en une ligne — ou composez le vôtre.

TL;DR. Claude Fable 5 a été retiré de la liste. La réponse n'est pas un modèle plus grand — c'est un panel : exécutez plusieurs modèles de pointe en parallèle et laissez un juge renvoyer la réponse la plus forte. OrcaRouter propose cela de deux manières : routeurs intégrés orcarouter/fusion que vous appelez comme n'importe quel modèle, et un Routing DSL pour composer le vôtre. C'est le guide de terrain pour les deux — avec des recettes prêtes à copier-coller, les cinq arbitres (dont synthesize, le fusionneur Mixture-of-Agents), et comment le déployer sans mettre votre SLA en jeu.

Partie 1 — Appelez-le en une ligne : les routeurs Fusion intégrés

Fable 5 a été interrompu et restreint, donc il n'est plus largement appelable. Fusion reconstruit ce niveau à partir des modèles que vous pouvez encore appeler — un routeur compatible OpenAI, prêt à l'emploi, qui exécute un panel de modèles de pointe en parallèle et renvoie la réponse la plus forte. Trois niveaux sélectionnés sont livrés dans chaque espace de travail :

Les trois niveaux Fusion (composition du panneau × fenêtre de contexte)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Fenêtre de contexte : 1,000,000

Idéal pour : Fable-5 niveau Max intelligence

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Fenêtre de contexte : 1,000,000

Idéal pour : inférence équilibrée de niveau Fable-5

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Fenêtre de contexte : 200 000

Idéal pour : inférence rapide et peu coûteuse de niveau Fable-5

Fenêtre de contexte = la plus petite dimension de l'élément du panneau — la contrainte limitante sur un fan-out.

Ce ne sont pas des leurres marketing ; ce sont des routeurs DSL précompilés gérés centralement. Voici le véritable programme orcarouter/fusion, textuellement :

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

Deux choix de conception qui méritent d'être soulignés :

Cela ne se déploie que sur un vrai travail. Le when: gate déclenche le panel pour les prompts de code, agent, outil, code-dense, ou haute difficulté (difficulty >= 0.3) ; tout le reste passe par le défaut équilibré de l'espace de travail. Vous payez le prix du panel exactement là où cela aide, pas sur "hi".

Le juge fournit une réponse réelle, textuellement. best_of_n exécute un juge LLM (ici, Opus 4.8 avec le template best_answer_v1) qui sélectionne le seul candidat le plus fort et le sert tel quel — jamais un mélange dilué. La sortie est toujours la réponse d'un modèle réel.

Partie 2 — Select vs. Fuse: best_of_n and the synthesize arbiter

Les routeurs Fusion sélectionnent. Mais OrcaRouter propose également une fuse stratégie — synthétiser, le Mixture-of-Agents modèle ajouté dans le moteur de routage (service/dispatch_parallel/synthesize.go). La différence est tout le jeu :

Exhibit 2 — Sélectionner vs. Fusionner

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

Recette pour une véritable fusion :

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

Mises en garde honnêtes :

- La facturation est N+1 — chaque segment est facturé, plus l'agrégateur comme appel supplémentaire.

- OpenAI chat-format uniquement dans V1 — l’agrégateur émet une complétion de chat OpenAI ; Claude/Gemini natifs clients dégradent en serve-first-successful (legs toujours facturés).

L'agrégateur doit être dans l'ensemble des candidats autorisés du routeur, sinon il se dégrade.

Quand utiliser lequel: best_of_n quand la réponse d'un modèle est probablement complètement correcte (code, Q&A factuelles) — vous voulez une réponse propre et réelle. synthesize quand les réponses sont complémentaires (recherche, analyse, long-form) et la fusion des forces bat toute réponse unique.

Partie 3 — Construisez votre propre : le manuel du DSL de routage

Vous ne voulez pas du panneau personnalisé ? Commencez par les "Claude Fable 5 Level" templates dans l'éditeur Routing DSL (ils sont fournis dans chaque espace de travail et reflètent les routeurs Fusion), puis spécialisez-vous. Six modèles copier-coller :

1 — Livrer du code qui fonctionne réellement → déployer, laisser les tests choisir le gagnant:

- 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 est ancré dans l'exécution — il sert le candidat qui réussit votre harnais, aucun juge LLM nécessaire.

2 — Arrêtez de payer trop cher pour des prompts faciles → porte de difficulté (le modèle Fusion, vos modèles) :

- 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 — Gardez les longues exécutions d'agent sur les rails → n'escaladez que lorsqu'elle vacille :

- 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 — Rendre les sorties instables déterministes → vote, escalade en cas de scission:

- 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 — Surmonter la latence de queue et les anomalies du fournisseur → course, servez le premier intervenant :

- 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 — Déployer sans risquer le SLA → shadow (évaluer en parallèle du trafic en direct, enregistrer ce qu'il choisirait choix + écart de coût, servir le choix en direct) → canary % (dsl_canary_pct 5 → 25 → 100, crypto-random par requête). Migrer en cas de divergence mesurée, annuler immédiatement.

L'antisèche : cinq arbitres

Économie et honnêteté

Le fan-out conditionné par la difficulté maintient la facture stable. (Illustratif ; coût = calcul du prix réel du jeton) — coût mixte = part_facile × bon_marché + part_difficile × panel :

Une charge de travail facile à 70% exécute le panneau complet pour un tiers de la facture de tous les panneaux.