Fusione di modelli in produzione: All'interno di OrcaRouter Fusion e del Routing DSL

Tre modelli frontier in parallelo, una risposta indietro. Chiamalo in una riga — o componi il tuo.

TL;DR. Claude Fable 5 è stato ritirato. La risposta non è un modello più grande — è un pannello: esegui diversi modelli di frontiera in parallelo e lascia che un giudice restituisca la risposta più forte. OrcaRouter offre questo in due modi: router integrati orcarouter/fusion routers che chiami come qualsiasi modello, e un Routing DSL per comporre il tuo. Questa è la guida pratica per entrambi — con ricette copia-e-incolla, i cinque arbitri (incluso synthesize, la fusione Mixture-of-Agents), e come implementarlo senza mettere a rischio il tuo SLA.

Parte 1 — Chiamalo in una riga: i router Fusion integrati

Fable 5 è stato interrotto e limitato, quindi non è più ampiamente richiamabile. Fusion ricostruisce quel livello dai modelli che tu puoi ancora chiamare — un router drop-in compatibile con OpenAI che esegue un pannello di modelli all'avanguardia in parallelo e restituisce la risposta più forte. Tre tier curati vengono forniti in ogni workspace:

I tre livelli di Fusion (composizione del pannello × finestra di contesto)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Finestra di contesto: 1.000.000

Ideale per: livello Fable-5, intelligenza massima

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Finestra di contesto: 1.000.000

Ideale per: inferenza bilanciata di livello Fable-5

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Finestra di contesto: 200.000

Ideale per: inferenza veloce ed economica di livello Fable-5

Finestra di contesto = la più piccola tra i membri del pannello — il vincolo vincolante su un fan-out.

Questi non sono slug di marketing; sono router DSL precompilati gestiti centralmente. Ecco il effettivo programma orcarouter/fusion, testuale:

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

Due scelte progettuali che vale la pena sottolineare:

Si attiva solo per lavoro reale. Il gate when: attiva il pannello per prompt di codice, agente, uso di strumenti, densi di codice o ad alta difficoltà (difficoltà >= 0.3); tutto il resto ricade nel default bilanciato del workspace. Paghi il prezzo del pannello esattamente dove serve, non per "ciao".

Il giudice fornisce una risposta reale, testualmente. best_of_n esegue un giudice LLM (qui, Opus 4.8 con il template best_answer_v1) che seleziona il singolo candidato più forte e lo fornisce così com'è — mai una fusione diluita. L'output è sempre la risposta di un modello reale.

Parte 2 — Select vs. Fuse: best_of_n e il synthesize arbiter

I router Fusion selezionano. Ma OrcaRouter offre anche una fuse strategia — synthesize, il Mixture-of-Agents pattern aggiunto nel motore di routing (service/dispatch_parallel/synthesize.go). La differenza è l'intero gioco:

Allegato 2 — Selezione vs. Fusione

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

Ricetta per la vera fusione:

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

Avvertenze oneste:

- La fatturazione è N+1 — ogni gamba viene fatturata, più l'aggregatore come chiamata extra.

- formato chat OpenAI solo in V1 — l'aggregatore emette un completamento chat OpenAI; Claude/Gemini nativo client degradano a serve-first-successful (segmenti ancora fatturati).

L'aggregatore deve essere nell'insieme dei candidati autorizzato del router, altrimenti degrada.

Quando usare quale: best_of_n quando è probabile che la risposta di un modello sia completamente giusta (codice, Q&A fattuale) — vuoi una risposta pulita e vera. synthesize quando le risposte sono complementari (ricerca, analisi, forma lunga) e unire i punti di forza supera ogni singola risposta.

Parte 3 — Crea il tuo: il playbook del Routing DSL

Non vuoi il pannello curato? Parti dai modelli "Claude Fable 5 Level" nell'editor Routing DSL (sono inclusi in ogni workspace e rispecchiano i router Fusion), poi specializza. Sei modelli copia-incolla:

1 — Codice che viene effettivamente eseguito → distribuisci, lascia che i test scelgano il vincitore:

- 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 è basato sull'esecuzione — serve il candidato che supera il tuo harness, nessun giudice LLM necessario.

2 — Smetti di pagare troppo per semplici prompt → cancello della difficoltà (il pattern Fusion, i tuoi modelli):

- 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 — Mantieni le lunghe esecuzioni dell'agente sui binari → escalare solo quando vacilla:

- 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 — Rendere deterministici gli output flaky → votare, escalare su uno split:

- 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 — Supera la latenza di coda e i blip del provider → gareggia, servi il primo rispondente:

- 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 — Rilascia senza scommettere lo SLA → ombra (valuta insieme al traffico live, registra cosa esso potrebbe scegliere + delta di costo, servire la scelta live) → canarino % (dsl_canary_pct 5 → 25 → 100, crypto-random per richiesta). Migra in base alla divergenza misurata, ripristina istantaneamente.

Il cheat-sheet: cinque arbitri

Economia e onestà

Il fan-out controllato dalla difficoltà mantiene la bolletta piatta (Illustrativo; costo = calcolo reale del prezzo del token) — costo combinato = easy_share × cheap + hard_share × panel:

Un carico di lavoro facile al 70% esegue l'intero pannello per un terzo del costo dell'intero pannello.