Modellfusion i produktion: Inuti OrcaRouter Fusion och Routing DSL

Tre frontier-modeller parallellt, ett svar tillbaka. Anropa det på en rad — eller komponera din egen.

TL;DR. Claude Fable 5 togs bort. Svaret är inte en större modell — det är en panel: kör flera frontlinjemodeller parallellt och låt en domare returnera det starkaste svaret. OrcaRouter levererar detta på två sätt: inbyggda orcarouter/fusion routrar du anropar som vilken modell som helst, och en Routing DSL för att skapa din egen. Detta är fälthandboken för båda — med kopiera-och-klistra-recept, de fem skiljedomarna (inklusive synthesize, Mixture-of-Agents-fusionen), och hur du rullar ut det utan att satsa din SLA.

Del 1 — Anropa det på en rad: de inbyggda Fusion routers

Fable 5 lades ner och begränsades, så den är inte längre brett anropsbar. Fusion återskapar den nivån från modellerna du kan fortfarande anropa — en drop-in, OpenAI-kompatibel router som kör en panel av frontmodeller parallellt och returnerar det starkaste svaret. Tre kuraterade nivåer levereras i varje arbetsyta:

De tre Fusion-nivåerna (panelkomposition × kontextfönster)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Kontextfönster: 1 000 000

Bäst för: Fable-5 level Max intelligence

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Kontextfönster: 1 000 000

Bäst för: Fable-5 nivåbalanserad inferens

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Kontextfönster: 200,000

Bäst för: Fable-5 nivå snabb + billig inferens

(Kontextfönster = den minsta panelmedlemmens — den bindande begränsningen för en fan-out.)

Det här är inte marknadsföringssnäckor; de är förkompilerade DSL-routrar som hanteras centralt. Här är faktiska orcarouter/fusion-programmet, ordagrant:

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

Två designval värda att nämna:

Det breder bara ut sig på riktigt arbete. Den when: gate utlöser panelen för code, agent, tool-using, code-dense eller high-difficulty (difficulty >= 0.3) prompts; allt annat faller igenom till arbetsytans balanserade standard. Du betalar panelpriset exakt där det hjälper, inte på "hi."

Domaren levererar ett verkligt svar, ordagrant. best_of_n kör en LLM-domare (här, Opus 4.8 med best_answer_v1-mallen) som väljer den enda starkaste kandidaten och levererar den som den är — aldrig en utspädd blandning. Utdata är alltid en riktig modells svar.

Del 2 — Välj vs. Foga: best_of_n och synthesize-arbiter

Fusion routers väljer. Men OrcaRouter levererar också en fuse strategi — syntetisera, det Mixture-of-Agents mönster som lagts till i routingmotorn (service/dispatch_parallel/synthesize.go). Skillnaden är hela spelet:

Bilaga 2 — Select vs. 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 för äkta 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

Ärliga varningar:

- Fakturering är N+1 — varje ben fakturerar, plus aggregatorn som ett extra samtal.

- OpenAI-chattformat endast i V1 — aggregatorn avger en OpenAI-chattkomplettering; Claude/Gemini inbyggda klienter degraderas till serve-first-successful (ben fortfarande fakturerade).

Aggregatorn måste finnas i routerns auktoriserade kandidatuppsättning, annars försämras den.

När ska man använda vilket: best_of_n när en modells svar sannolikt helt rätt (kod, faktabaserade frågor) — du vill ha ett rent, verkligt svar. synthesize när svaren är komplementära (forskning, analys, långformat) och att slå samman styrkor överträffar varje enskilt alternativ.

Del 3 — Bygg din egen: Routing DSL-spelboken

Vill du inte ha den kuraterade panelen? Börja från "Claude Fable 5 Level" mallar i Routing DSL-redigeraren (de levereras i varje arbetsyta och speglar Fusion-routrarna), sedan specialisera. Sex kopiera-klistra-mönster:

1 — Leverera kod som faktiskt körs → sprid ut, låt testerna välj vinnaren:

- 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 är exekveringsgrundad — den tjänar den kandidat som klarar din testbädd, ingen domar-LLM behövs.

2 — Sluta betala för mycket för enkla promptar → svårighetsgate (Fusion-mönstret, dina modeller):

- 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 — Håll långa agentkörningar på spåren → eskalera endast när den vacklar:

- 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 — Gör ostabila utdata deterministiska → rösta, eskalera vid en splittring:

- 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 — Minska tail latency & leverantörsstörningar → tävla, servera den första svararen:

- 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 — Rulla ut utan att satsa på SLA → skugga (utvärdera tillsammans med live-trafik, logga vad den skulle välj + kostnadsdelta, servera live-valet) → canary % (dsl_canary_pct 5 → 25 → 100, kryptografiskt slumpmässig per förfrågan). Migrera vid uppmätt divergens, rulla tillbaka omedelbart.

Lathunden: fem arbitrar

Ekonomi & ärlighet

Svårighetsstyrd utbredning håller kostnaden platt (Illustrativt; kostnad = verklig tokenprismatematik) — blandad kostnad = easy_share × cheap + hard_share × panel:

En 70%-enkel arbetsbelastning kör hela panelen för en tredjedel av hela panelens faktura.