Modellfusion in der Produktion: Einblick in OrcaRouter Fusion und die Routing-DSL

Drei Grenzmodelle parallel, eine Antwort zurück. Rufen Sie es in einer Zeile auf — oder erstellen Sie Ihre eigene.

TL;DR. Claude Fable 5 wurde delisted. Die Antwort ist kein größeres Modell – es ist ein Panel: mehrere führende Modelle parallel laufen lassen und durch einen Schiedsrichter die stärkste Antwort zurückgeben lassen. OrcaRouter bietet dies auf zwei Arten an: integrierte orcarouter/fusion Router die Sie wie jedes Modell aufrufen, und eine Routing DSL um eigene zu erstellen. Dies ist der Feldführer für beide – mit Kopier-Rezepten, den fünf Schiedsrichtern (inklusive synthesize, dem Mixture-of-Agents Fuse), und wie man es ausrollt, ohne die SLA zu gefährden.

Teil 1 — Nennen Sie es in einer Zeile: die integrierten Fusion-Router

Fable 5 wurde eingestellt und eingeschränkt, sodass es nicht mehr breit aufrufbar ist. Fusion baut diese Ebene aus den Modellen, die Sie können noch aufrufen — ein Drop-in, OpenAI-kompatibler Router, der ein Panel von Frontiermodellen parallel ausführt und die stärkste Antwort zurückgibt. Drei kuratierte Stufen werden in jedem Arbeitsbereich mitgeliefert:

Die drei Fusion-Stufen (Panel-Zusammensetzung × Kontextfenster)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Kontextfenster: 1.000.000

Am besten für: Fable-5 level Max intelligence

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Kontextfenster: 1.000.000

Am besten für: ausgewogene Inferenz auf Fable-5-Niveau

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Kontextfenster: 200.000

Am besten geeignet für: Fable-5-Niveau schnelle + günstige Inferenz

(Kontextfenster = das kleinste Panel-Mitglied — die bindende Einschränkung bei einem Fan-Out.)

Dies sind keine Marketing-Schlagworte; es sind vorkompilierte DSL-Router, zentral verwaltet. Hier ist das eigentliche orcarouter/fusion-Programm, wortwörtlich:

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

Zwei erwähnenswerte Designentscheidungen:

Es fächert nur bei echter Arbeit aus. Das when: gate feuert das Panel für Code-, Agent-, Tool-Using-, Code-dichte- oder hochschwierige (Schwierigkeit >= 0.3) Prompts; alles andere fällt auf den ausgeglichenen Standard des Workspaces zurück. Sie zahlen den Panel-Preis genau dort, wo er hilft, nicht bei "hi."

Der Richter liefert eine echte Antwort, wortgetreu. best_of_n führt einen LLM-Richter (hier Opus 4.8 mit der best_answer_v1-Vorlage) aus, der den einzelnen stärksten Kandidaten auswählt und ihn unverändert ausliefert – niemals eine verwässerte Mischung. Die Ausgabe ist immer die Antwort eines echten Modells.

Teil 2 — Auswählen vs. Verschmelzen: best_of_n und der synthesize-Arbiter

Die Fusion routers wählen. Aber OrcaRouter liefert auch eine fuse Strategie — synthetisieren, die Mixture-of-Agents Muster, das in der Routing-Engine hinzugefügt wurde (service/dispatch_parallel/synthesize.go). Der Unterschied ist das ganze Spiel:

Anlage 2 — Auswählen vs. Verschmelzen

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

Rezept für echte 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

Ehrliche Vorbehalte:

- Rechnung ist N+1 — jeder Bein wird abgerechnet, plus der Aggregator als zusätzlicher Anruf.

- OpenAI-Chat-Format nur in V1 — der Aggregator gibt eine OpenAI-Chat-Vervollständigung aus; Claude/Gemini nativ Clients degradieren zu serve-first-successful (Legs werden weiterhin berechnet).

Der Aggregator muss in der autorisierten Kandidatenliste des Routers sein, sonst verschlechtert er sich.

Wann man was verwendet: best_of_n wenn die Antwort eines Modells wahrscheinlich vollständig richtig ist (Code, faktenbasierte Fragen & Antworten) — man möchte eine saubere, echte Antwort. Synthesize wenn Antworten komplementär sind (Forschung, Analyse, Langform) und die Kombination der Stärken übertrifft jede einzelne Herangehensweise.

Teil 3 — Eigenbau: Das Routing-DSL-Playbook

Möchten Sie das kuratierte Panel nicht? Beginnen Sie mit dem "Claude Fable 5 Level" Vorlagen im Routing DSL Editor (diese sind in jedem Arbeitsbereich enthalten und spiegeln die Fusion Router), dann spezialisieren Sie sich. Sechs Kopier-Einfügen-Muster:

1 — Code ausliefern, der tatsächlich läuft → ausbreiten, lass die Tests den Gewinner wählen:

- 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 ist ausführungsbasiert – es dient dem Kandidaten, der Ihr Testsystem besteht, kein Beurteilungs-LLM erforderlich.

2 — Hör auf, für einfache Prompts zu viel zu bezahlen → Schwierigkeitsstufe (das Fusion-Muster, deine Modelle):

- 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 — Lange Agentenläufe auf Kurs halten → Nur eskalieren, wenn es wackelt:

- 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 — Flaky Ausgaben deterministisch machen → abstimmen, eskalieren bei einer Aufteilung:

- 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 — Reduzieren Sie Tail-Latenz und Provider-Ausfälle → Rennen, bedienen Sie den Ersthelfer:

- 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 — Ausrollen, ohne die SLA zu riskieren → shadow (neben dem Live-Traffic bewerten, protokollieren, was es würde auswählen + Kostendifferenz, die Live-Auswahl bedienen) → canary % (dsl_canary_pct 5 → 25 → 100, kryptografisch zufällig pro Anfrage). Migration bei gemessener Abweichung, sofortiger Rollback.

Der Spickzettel: fünf Schiedsrichter

Wirtschaft & Ehrlichkeit

Schwierigkeitsgesteuerter Fan-Out hält die Rechnung flach (Veranschaulichung; Kosten = echte Token-Preis-Mathematik) — gemischte Kosten = einfacher_Anteil × billig + schwieriger_Anteil × Panel:

Eine zu 70% einfache Arbeitslast betreibt das gesamte Panel für ein Drittel der Gesamtpanel-Rechnung.