Routing DSL: stel een paneel van modellen samen dat denkt zoals Fable 5

Twee jaar lang was het draaiboek voor "meer intelligentie" "wacht op het volgende model." Wij denken dat dat de verkeerde eenheid van vooruitgang is. Het front is geen enkel controlepunt — het is een panel. Geef drie goede modellen hetzelfde moeilijke probleem, laat ze van mening verschillen, en arbitreer tussen de antwoorden, en het panel verslaat elk van zijn leden. Vaak verslaat het het volgende model op de prijslijst.

De Routing DSL is hoe je dat paneel bouwt. Het is een programmeerbare routeringsstrategie — YAML + CEL — die jouw OrcaRouter-eindpunt omzet in een inferentiegrafiek: routeer op moeilijkheidsgraad, routeer op taak, vertak naar meerdere modellen tegelijk, beoordeel of stem op hun uitvoer, val terug bij lage betrouwbaarheid, en stem het geheel af op kosten, latentie of kwaliteit. Je schrijft regels; de gateway compileert en voert ze uit op elke aanvraag in ongeveer 5 ms.

Dit bericht is de technische rondleiding: de grammatica, de variabelen waarop je kunt vertakken, de vier scheidsrechters, de cascade, en een complete productieregelset aan het einde.

Het resultaat eerst

Twee illustratieve benchmarks. (Cijfers zijn illustratief — ze zijn bedoeld om de vorm van het effect, niet om te citeren als officiële scores.)

Frontier vergelijking — een op moeilijkheid gerouteerd DSL-eindpunt vs. de solo frontier:

Fusiepanelen versus solomodellen — scoorde op 93 van 100 taken (van OpenRouter):

Drie dingen die het bekijken waard zijn:

Elk fusiepaneel verslaat elk van zijn eigen leden. Opus 4.8 + GPT-5.5 (~67,5%) overtreft zowel Opus solo (~58,5%) als GPT-5.5 solo (~60%) met 7–9 punten. Onenigheid is signaal; arbitrage oogst het.

Fusion bereikt het volgende niveau. Drie verschillende panelen kruisen Fable 5 solo (~65.5%) alleen de modellen gebruikend onder het.

Je hebt geen dure lidmaatschappen nodig. Opus + Opus self-fusion (~65.5%) evenaart Fable 5 met één model en een sampler. Een panel van goedkope modellen — Gemini 3 Flash + Kimi K2.6 + DeepSeek V4 Pro (~64.5%) — valt een haar onder Fable 5 tegen een fractie van de kosten per token. Dat is de hele stelling: koop intelligentie met topologie, niet met de volgende prijsklasse.

De Routing DSL is het stuurvlak waarmee u die topologie alleen kunt inzetten waar het loont — goedkope modellen voor de gemakkelijke 80%, een fusiepaneel voor de harde staart.

De grammatica in 30 seconden

Een regelset is versie, een lijst met regels, en een vereiste standaard. Regels worden geëvalueerdvan boven naar beneden; de eerste when: die waar is, wint. Geen when: betekent "altijd overeenkomen."

versie: 1

rules:
  - id: only_rule
    use: { model: "claude-sonnet-4-6" }
default:
  delegate: balanced

De when: is een CEL booleaanse expressie — gesandboxed, alleen RE2-regex, geen lussen, geen I/O, microseconde-evaluatie, met een enkele 5 ms deadline die wordt gedeeld over de hele regelset. De use: is de effect: waar het verzoek naartoe gaat en hoe het wordt afgestemd. Limieten zijn bewust klein (≤30 regels, ≤16 KiB bron, ≤200 tekens per when:) zodat een regelset controleerbaar blijft.

Primitief 1 — route op basis van moeilijkheid en taak

De distributeur classificeert elk verzoek voordat het wordt gerouteerd en stelt de functies bloot aan CEL. Je vertakt er direct op:

versie: 1

rules:
  - id: hard_reasoning
    when: difficulty > 0.8
    use:
      model: "claude-opus-4-8"
      reasoning_effort: "high"
      thinking_budget_tokens: 32000


  - id: code_path
    when: task_class == "code" && code_keyword_density > 0.5
    use: { model: "gpt-5.5" }


  - id: cheap_chat
    when: difficulty < 0.3
    use: { model: "gemini-3-flash" }


default:
  delegate: balanced

De variabelen die je kunt lezen in when: (afgekort — zie de volledige referentie in de docs):

Groepsvoorbeelden

Verzoekvorm

request.input_tokens, request.output_max_tokens, request.stream, request.vision, request.message_count, request.has_tools

Classificatie

task_class (chat/code/agent/vision/audio/rag/creative), difficulty (0.0–1.0), code_keyword_density, reasoning_cue_count, log_prompt_tokens, tool_count

Sessie 

agent_state.turn, agent_state.tools_used, agent_state.has_edited, agent_state.last_test_failed, agent_state.consecutive_errors, agent_state.models_tried

Context

headers["x-…"], user.group, token.name, time.hour, workspace.id
…plus six macros for the things regex-over-payload is good at: system_prompt_matches(re), user_message_matches(re), tool_definitions_include(name), tool_calls_present_any([…]), tool_results_from_any([…]), header_matches(name, re).

Elke bestemming kan per-gesprek knoppen, vertaald naar de native parameters van elke provider door de relay-adapter: reasoning_effort (laag/midden/hoog), thinking_budget_tokens (1024–64000), samples (1–16), temperature (0.0–2.0), plus door denylist beveiligde param_override / header_override. Dat is al voldoende om het moeilijkheidsgerouteerde eindpunt uit Tabel A te bouwen: goedkoop model voor de eenvoudige staart, Opus met een denkbudget voor de moeilijke.

Primitief 2 — uitwaaieren naar een paneel (fusie)

Dit is waar de benchmarkstijging vandaan komt. Een parallel: effect stuurt het verzoek naar 2–5 poten tegelijk, dan een arbiter bepaalt wat de klant daadwerkelijk ziet:

- id: hard_tail_panel
  when: difficulty > 0.7 && task_class == "agent"
  use:
    parallel:
      - { model: "anthropic/claude-opus-4-8", reasoning_effort: "high" }
      - { model: "openai/gpt-5.5", thinking_budget_tokens: 16000 }
      - { model: "google/gemini-3.1-pro", temperature: 0.3 }
    arbiter:
      strategy: best_of_n
      model: "anthropic/claude-sonnet-4-6"      # the judge
      template: judge_code
    max_latency_ms: 120000
    on_disagreement:                  # majority-only escape hatch
      model: "anthropic/claude-opus-4-8"
      reasoning_effort: "high"

Vier arbiterstrategieën, elk een ander antwoord op "wiens output wint?":

eerste — race de benen, serveer het eerste succes, annuleer de verliezers. Optimaliseert latentie (je krijgt de snelste van N).

meerderheid — gestructureerde stemming over de uitvoer van de benen, geen extra modelaanroep. Wanneer de benen splitsen zonder strikte meerderheid, stuurt de optionele on_disagreement:-tak een nieuwe, sterkere poging in plaats van een gelijkspel te dienen. Optimaliseert robuustheid op taken met een canoniek antwoord.

best_of_n — een LLM-beoordelaar leest alle kandidaten en rangschikt ze. Dit is de Opus + GPT-5.5 → beoordelaar configuratie uit Tabel B. Optimaliseert kwaliteit bij open-einde werk; valt terug op eerste succesvolle als de beoordelaar faalt.

tests_pass — execution-grounded: dien de kandidaat wiens patch er daadwerkelijk voor zorgt dat de testsuite slaagt. Geen beoordelaarsgok — het harnas beslist. Dit is de sterkste arbiter voor code/agent werk. De verifier bevindt zich buiten de gateway (aangesloten via een VerifierProvider); zonder aangesloten verifier degradeert het naar first-successful.

max_latency_ms (1000–600000, default 120000) beperkt de fan-out zodat één trage poot de reactie niet kan ophouden — achterblijvers worden verwijderd. Het nesten van parallel binnen parallel wordt afgewezen bij lint; het paneel is opzettelijk één niveau diep.

Beschikbaarheidsopmerking:de N-way fan-out runtime is gekoppeld aan de serverflagROUTING_DSL_ENSEMBLE_RUNTIMEterwijl per-leg facturatie is gehard op staging — daarom is fusionpreview, niet GA. Met de vlag uit, een parallel: regel bedient netjes zijn eerste leg, zodat u vandaag uw panels kunt ontwerpen en schaduwen en ze inschakelen wanneer fusion in uw regio arriveert.

Primitief 3 — fallbacks en confidence cascades

Fan-out betaalt N× vooraf. Een cascade betaalt extra alleen wanneer het eerste antwoord er verkeerd uitziet. Na het antwoord evalueert on_low_confidence: signalen en, als er een afgaat, herverzendt het naar een sterkere bestemming:

- id: agent_with_safety_net
  when: task_class == "agent"
  use:
    pool: "@pool:fast"
  on_low_confidence:
    signals: [patch_invalid, self_doubt, next_turn_test_failed]
    threshold: { low_logprob: -1.5 }
    use:
      model: "claude-opus-4-8"
      reasoning_effort: "high"

De signalen: patch_invalid (de diff faalt voor git apply --check), self_doubt (een set regexpatronen voor afzwakkende zinnen), low_logprob (gemiddelde token logprob onder drempelwaarde, als de provider dit blootstelt), en next_turn_test_failed (een cross-turn latch — de prompt van deze beurt draagt de vorm van de falende tests van de vorige beurt). Cascades zijn per ontwerp diepte-1. Koppel ze met agent_state.models_tried om te krijgen diversiteit bij herpoging — stuur de reparatie nooit naar het model dat zojuist faalde.

De knop afstemmen: kosten, latentie, kwaliteit

Dezelfde DSL drukt alle drie de doelstellingen uit; u kiest per regel:

Kosten — delegeer: goedkoopste, houd het goedkope model op de gemakkelijke staart, en reserveer fan-out voor moeilijkheidsgraad > 0,7. Tabel B's goedkope paneel (~64,5% ≈ Fable 5 solo) is het bewijs van bestaan: een fusie van kleine modellen kan een frontiermodel vervangen tegen een fractie van de kosten per token. Wees echter nuchter — fusie gebruikt het "betaal elk been" model: een 3-leg best_of_n paneel factureert drie kandidaten plus de rechter. De economie werkt omdat je (a) alleen fan-out toepast op de moeilijke minderheid van verzoeken en (b) fuseert goedkopere leden dan het frontiermodel dat je vervangt.

Latentie — arbiter: { strategy: first } plus een strakke max_latency_ms geeft je de snelste van N met een harde bovengrens.

Kwaliteit — best_of_n voor open-ended werk, tests_pass wanneer er een suite is om op te baseren. samples en thinking_budget_tokens leveren meer binnen een enkele leg.

Het gebruiken zonder prod te breken

Routeringswijzigingen zijn eng, dus de DSL wordt geleverd met de veiligheidsrails die een SRE verwacht:

Lint bij elke opslag — schema, CEL-typecontrole (elke when: moet evalueren tot bool), ref-resolutie, knob-bereiken, header/param-denylijsten. Fouten komen terug als {line, column, message, rule} en worden weergegeven als gutter chips in de editor.

Droge run — POST een synthetisch verzoek (task_class, difficulty, agent_state, …) en ontvang de overeenkomende regel, het opgeloste effect en de evaluatietijd voordat er iets wordt verzonden.

Schaduwmodus — gedurende 24 uur na de eerste opslag wordt de DSL geëvalueerd maar niet gebruikt; een schaduwlog registreert potentiële picks en de console toont een diff (percentage gewijzigde routes, verwachte dagelijkse kostdelta, per-regel vuurtellingen).

Canary — een 0–100 verkeersslider. Voer op van 5 → 25 → 50 → 100 terwijl je per slice-statistieken bekijkt; draai terug door naar 0 te schuiven.

Audit + rollback — elke opslag/rollback schrijft een auditrij in dezelfde transactie; gelijktijdige bewerkingen krijgen een 409 met de huidige versie, zodat je opnieuw probeert met een actuele status.

Testgevallen, trace replay en een AI-'leg deze regelset uit'-weergave ronden het af. Je vindt het in het dashboard onder routing → strategy → DSL.

Een complete regelset

Goedkoop op makkelijk, gemiddeld op medium, een beoordeeld fusiepaneel op de harde agentische staart, met een vertrouwenscascade eronder:

versie: 1

rules:
  - id: trivial
    when: difficulty < 0.3 && !has_tools
    use: { model: "gemini-3-flash" }


  - id: standard
    when: difficulty < 0.7
    use:
      model: "gpt-5.5"
    on_low_confidence:
      signals: [self_doubt, low_logprob]
      use: { model: "claude-opus-4-8", reasoning_effort: "high" }


  - id: hard_agent_panel
    when: difficulty >= 0.7 && task_class == "agent"
    use:
      parallel:
        - { model: "anthropic/claude-opus-4-8", reasoning_effort: "high" }
        - { model: "openai/gpt-5.5", thinking_budget_tokens: 16000 }
        - { model: "google/gemini-3.1-pro" }
      arbiter:
        strategy: tests_pass        # execution-grounded; judged fallback if no harness
      max_latency_ms: 180000
      on_disagreement:
        model: "claude-opus-4-8"
        reasoning_effort: "high"


default:
  delegate: balanced

Dat eindpunt is het eindpunt dat bovenaan Tabel A staat — niet omdat het een beter model heeft gevonden, maar omdat het het juiste model aan de juiste aanvraag besteedt en een paneel precies daar samenvoegt waar het paneel wint.

Begin met opstellen

De volgende sprong in mogelijkheden hoeft niet te wachten op het volgende controlepunt. Het is een grafiek die je vanmiddag kunt schrijven: route op moeilijkheidsgraad, vertakken op de harde staart, de uitvoer beoordelen of testen, in cascade gaan wanneer het vertrouwen daalt.

Documentatie: https://docs.orcarouter.ai/routing/routing-dsl

UI: routering → Router maken -> Routeringsstrategie → DSL (expert)

De frontier is een paneel. Bouw de jouwe.