Model Fusion in Productie: Binnen OrcaRouter Fusion en de Routing DSL

Drie grensverleggende modellen parallel, één antwoord terug. Roep het aan in één regel — of stel je eigen samen.

TL;DR. Claude Fable 5 werd gedelist. Het antwoord is niet een groter model — het is een panel: voer meerdere frontiermodellen parallel uit en laat een beoordelaar het sterkste antwoord teruggeven. OrcaRouter levert dit op twee manieren: ingebouwde orcarouter/fusion routers die u aanroept zoals elk model, en een Routing DSL om uw eigen te componeren. Dit is de veldgids voor beide — met copy-paste recepten, de vijf arbiters (waaronder synthesize, de Mixture-of-Agents fuse), en hoe u het uitrolt zonder uw SLA te verwedden.

Deel 1 — Noem het in één regel: de ingebouwde Fusion-routers

Fable 5 is stopgezet en beperkt, dus het is niet langer breed aanroepbaar. Fusion herbouwt dat niveau vanuit de modellen die jekunt nog aanroepen — een drop-in, OpenAI-compatibele router die een panel van frontier-modellen parallel laat draaien en het sterkste antwoord retourneert. Drie samengestelde tiers worden in elke werkruimte geleverd:

De drie Fusion-niveaus (paneelsamenstelling × contextvenster)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Contextvenster: 1.000.000

Beste voor: Fable-5 level Max intelligentie

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Contextvenster: 1.000.000

Geschikt voor: gebalanceerde inferentie op Fable-5-niveau

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Contextvenster: 200.000

Beste voor: Fable-5-niveau snel + goedkope inferentie

(Contextvenster = de kleinste paneelcomponent — de bindende beperking op een fan-out.)

Dit zijn geen marketing-slakken; het zijn voorgecompileerde DSL-routers centraal beheerd. Hier is de echte orcarouter/fusion-programma, letterlijk:

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

Twee ontwerpkeuzes die het vermelden waard zijn:

Het waaiert alleen uit op echt werk. De when: gate activeert het panel voor code, agent, tool-using, code-dense, of hoge-moeilijkheidsgraad (moeilijkheid >= 0.3) prompts; al het andere valt door naar de gebalanceerde standaard van de workspace. Je betaalt de panel-prijs precies waar het helpt, niet op 'hi'.

De rechter levert een echt antwoord, letterlijk. best_of_n voert een LLM-beoordeling uit (hier Opus 4.8 met de best_answer_v1 template) die kiest de enige sterkste kandidaat en serveert het zoals het is — nooit een verdunde samenvoeging. De output is altijd het antwoord van een echt model.

Deel 2 — Select vs. Fuse: best_of_n en de synthesize arbiter

De Fusion routers selecteren. Maar OrcaRouter levert ook een fuse strategie — synthetiseren, de Mixture-of-Agents patroon toegevoegd aan de routing engine (service/dispatch_parallel/synthesize.go). Het verschil is het hele spel:

Bijlage 2 — Select versus Fuse

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

Recept voor echte fusie:

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

Eerlijke kanttekeningen:

- Facturering is N+1 — elke etappe factureert, plus de aggregator als een extra gesprek.

- OpenAI chat-formaat alleen in V1 — de aggregator genereert een OpenAI chat completion; Claude/Gemini native cliënten degraderen naar serve-first-successful (etappes worden nog steeds gefactureerd).

De aggregator moet in de geautoriseerde kandidaatset van de router staan, anders degradeert hij.

Wanneer gebruik je welke: best_of_n wanneer het antwoord van één model waarschijnlijk volledig juist (code, feitelijke Q&A) — je wilt een helder, echt antwoord. synthetiseer wanneer antwoorden complementair (onderzoek, analyse, lange vorm) en het samenvoegen van sterke punten wint het van elke individuele benadering.

Deel 3 — Bouw je eigen: het Routing DSL-speelboek

Wil je het samengestelde paneel niet? Begin dan met de "Claude Fable 5 Level" sjablonen in de Routing DSL editor (ze worden in elke werkruimte meegeleverd en spiegelen de Fusion-routers), specialiseer dan. Zes kopieer-plakpatronen:

1 — Lever code die daadwerkelijk draait → spreid uit, laat de testen kies de winnaar:

- 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 is uitvoeringsgebaseerd — het dient de kandidaat die jouw harness doorstaat, geen judge LLM nodig.

2 — Stop met te veel betalen voor eenvoudige prompts → difficulty gate (het Fusionpatroon, uw modellen):

- 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 — Houd lange agentruns op de rails → escaleer alleen wanneer het wiebelt:

- 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 — Maak flaky outputs deterministisch → stem, escaleer bij een splitsing:

- 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 — Overwin staartlatentie en providerstoringen → race, bedien de eerste responder:

- 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 — Uitrollen zonder de SLA op het spel te zetten → shadow (evalueren naast live verkeer, log wat het zou kiezen + kostenverschil, lever de live keuze) → canary % (dsl_canary_pct 5 → 25 → 100, crypto-random per verzoek). Migreer op basis van gemeten afwijking, rol onmiddellijk terug.

Het spiekbriefje: vijf arbiters

Economie en eerlijkheid

Moeilijkheidsgestuurde uitwaaiering houdt de rekening constant (Illustratief; kosten = echte token-prijsberekening) — gemengde kosten = easy_share × cheap + hard_share × panel:

Een 70%-makkelijk werklast voert het volledige paneel uit voor een derde van de rekening voor alle panelen.