Fusión de modelos en producción: dentro de OrcaRouter Fusion y el DSL de enrutamiento

Tres modelos frontera en paralelo, una respuesta de vuelta. Llámalo en una línea — o compón el tuyo propio.

En resumen. Claude Fable 5 fue retirado. La respuesta no es un modelo más grande — es un panel: ejecutar varios modelos de frontera en paralelo y dejar que un juez devuelva la respuesta más fuerte. OrcaRouter ofrece esto de dos maneras: integrados orcarouter/fusion routers que llamas como cualquier modelo, y un Routing DSL para componer el tuyo propio. Esta es la guía de campo para ambos — con recetas listas para copiar y pegar, los cinco árbitros (incluyendo synthesize, la fusión Mixture-of-Agents), y cómo implementarlo sin apostar tu SLA.

Parte 1 — Llámalo en una línea: los routers Fusion integrados

Fable 5 fue descontinuada y restringida, por lo que ya no se puede llamar ampliamente. Fusion reconstruye ese nivel a partir de los modelos que tú puedes seguir llamando — un router de reemplazo compatible con OpenAI que ejecuta un panel de modelos fronterizos en paralelo y devuelve la respuesta más fuerte. Tres niveles seleccionados se envían en cada espacio de trabajo:

Los tres niveles de Fusion (composición del panel × ventana de contexto)

orcarouter/fusion

Claude Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro

Ventana de contexto: 1,000,000

Mejor para: nivel Fable-5 inteligencia máxima

orcarouter/fusion-mini

Claude Opus 4.8 + GPT-5.5

Ventana de contexto: 1,000,000

Mejor para: inferencia equilibrada de nivel Fable-5

orcarouter/fusion-flash

Gemini 3.5 Flash + MiniMax M2.7 + GLM 5.1

Ventana de contexto: 200,000

Mejor para: inferencia rápida y barata de nivel Fable-5

(Ventana de contexto = la del miembro de panel más pequeño — la restricción vinculante en una expansión de salida.)

Estos no son cebos de marketing; son routers DSL precompilados gestionados centralmente. Aquí está el real programa orcarouter/fusion, textualmente:

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

Dos decisiones de diseño que vale la pena destacar:

Solo se distribuye en trabajo real. La puerta when: activa el panel para indicaciones de código, agente, uso de herramientas, código denso o alta dificultad (dificultad >= 0.3); todo lo demás pasa al valor predeterminado equilibrado del espacio de trabajo. Pagas el precio del panel exactamente donde ayuda, no en 'hola'.

El juez proporciona una respuesta real, textualmente. best_of_n ejecuta un juez LLM (aquí, Opus 4.8 con la plantilla best_answer_v1) que selecciona el candidato más fuerte y lo sirve tal cual — nunca una fusión diluida. La salida es siempre la respuesta de un modelo real.

Parte 2 — Seleccionar vs. Fusionar: best_of_n y el árbitro synthesize

Los routers Fusion seleccionan. Pero OrcaRouter también incluye una fuse estrategia — synthesize, el Mixture-of-Agents patrón añadido en el motor de enrutamiento (service/dispatch_parallel/synthesize.go). La diferencia es todo el juego:

Anexo 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

Receta para la verdadera fusión:

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

Advertencias honestas:

- La facturación es N+1 — cada tramo factura, más el agregador como una llamada extra.

- Formato de chat OpenAI solo en V1 — el agregador emite una finalización de chat de OpenAI; Claude/Gemini nativos clientes se degradan a serve-first-successful (tramos aún facturados).

El agregador debe estar en el conjunto de candidatos autorizados del enrutador, o se degrada.

Cuándo usar cada uno: best_of_n cuando es probable que la respuesta de un modelo sea completamente correcta (código, Q&A factual) — quieres una respuesta limpia y real. synthesize cuando las respuestas son complementarias (investigación, análisis, formato extenso) y la combinación de fortalezas supera cualquier enfoque individual.

Parte 3 — Construye tu propio: el manual de Routing DSL

¿No quieres el panel seleccionado? Empieza desde las plantillas "Claude Fable 5 Level" en el editor de Routing DSL (vienen incluidas en cada espacio de trabajo y reflejan los routers Fusion), luego especializa. Seis patrones de copiar y pegar:

1 — Envía código que realmente funciona → despliega, deja que las pruebas elijan al ganador:

- 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á basado en la ejecución — sirve al candidato que pasa tu arnés, no se necesita un juez LLM.

2 — Deja de pagar de más por prompts fáciles → puerta de dificultad (el patrón Fusion, tus modelos):

- 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 — Mantén las ejecuciones largas del agente encarriladas → escalar solo cuando se tambalea:

- 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 — Hacer que las salidas inestables sean deterministas → votar, escalar en una división:

- 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 — Reduzca la latencia de cola y los fallos del proveedor → compita, sirva al primer respondedor:

- 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 — Desplegar sin apostar el SLA → sombra (evaluar junto al tráfico en vivo, registrar lo que él haría elegir + delta de costo, servir la elección en vivo) → canary % (dsl_canary_pct 5 → 25 → 100, cripto-aleatorio por solicitud). Migrar según divergencia medida, revertir instantáneamente.

La guía rápida: cinco árbitros

Economía y honestidad

El fan-out controlado por dificultad mantiene la factura plana (Ilustrativo; costo = matemática real del precio de token) — costo combinado = easy_share × cheap + hard_share × panel:

Una carga de trabajo fácil al 70% ejecuta el panel completo por un tercio de la factura de todos los paneles.