Routing DSL: komponera en panel av modeller som tänker som Fable 5

I två år har spelboken för "mer intelligens" varit "vänta på nästa modell." Vi tycker att det är fel enhet för framsteg. Gränsen är inte en enda kontrollpunkt — det är en panel. Ge tre bra modeller samma svåra problem, låt dem vara oense, och avgör mellan svaren, så slår panelen vilken som helst av dess medlemmar. Ofta slår den nästa modell högre upp i prislistan.

Din Routing DSL är hur du bygger den panelen. Det är en programmerbar routningsstrategi — YAML + CEL — som förvandlar din OrcaRouter-slutpunkt till en inferensgraf: routa efter svårighetsgrad, routa efter uppgift, sprid ut till flera modeller samtidigt, bedöm eller rösta om deras utdata, fall tillbaka när konfidensen är låg, och anpassa allt för kostnad, latens eller kvalitet. Du skriver regler; gatewayen kompilerar och kör dem på varje förfrågan på cirka 5 ms.

Det här inlägget är den tekniska guiden: grammatiken, variablerna du kan förgrena dig på, de fyra domarna, kaskaden och en fullständig produktionsregeluppsättning i slutet.

Resultatet först

Två illustrativa riktmärken. (Siffrorna är illustrativa — de är avsedda att visa den form av effekten, inte att citeras som officiella poäng.)

Frontier-jämförelse — en svårighetsroutad DSL-slutpunkt vs. den ensamma frontieren:

Fusion-paneler vs. solo-modeller — poängsatta på 93 av 100 uppgifter (från OpenRouter):

Tre saker värda att stirra på:

Varje fusionspanel slår var och en av sina egna medlemmar. Opus 4.8 + GPT-5.5 (~67,5%) slår både Opus solo (~58,5%) och GPT-5.5 solo (~60%) med 7–9 poäng. Oenighet är signal; skiljedom skördar den.

Fusion når nästa nivå. Tre olika paneler korsar Fable 5 solo (~65.5%) med endast modellerna under det.

Du behöver inga dyra medlemskap.Opus + Opus självfusions (~65,5%) matchar Fable 5 med en modell och en sampler. En panel av billiga modeller — Gemini 3 Flash + Kimi K2.6 + DeepSeek V4 Pro (~64,5%) — hamnar en hårsmån under Fable 5 till en bråkdel av kostnaden per token. Det är hela tesen: köp intelligens med topologi, inte med nästa prisnivå.

Routing DSL är kontrollytan som låter dig spendera den topologin bara där det lönar sig — billiga modeller på de lätta 80%, en fusionspanel på den svåra svansen.

Grammatiken på 30 sekunder

Ett regelset är version, en lista med regler och ett obligatoriskt standardvärde. Regler utvärderas uppifrån och ner; den första when: som är sann vinner. Nej when: betyder "matchar alltid".

version: 1

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

Villkoret when: är ett CEL booleskt uttryck — sandlådeisolerat, endast RE2-regex, inga loopar, ingen I/O, utvärdering på mikrosekunder, med en gemensam deadline på 5 ms för hela regeluppsättningen. Användningen use: är den effekt: där begäran går och hur den ställs in. Gränserna är medvetet små (≤30 regler, ≤16 KiB källkod, ≤200 tecken per when:) så att en regeluppsättning förblir granskningsbar.

Primitive 1 — rut efter svårighet och uppgift

Distributören klassificerar varje begäran före routning och exponerar funktionerna för CEL. Du grenar direkt på dem:

version: 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

Variablerna du kan läsa in när: (förkortat — se fullständig referens i dokumentationen):

Gruppexempel

Förfrågningsform

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

Klassificering

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

Session 

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

Sammanhang

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).

Vilken destination som helst kan bära per-anropsreglage, översatt till varje leverantörs inbyggda parametrar av reläadaptern: reasoning_effort (låg/medel/hög), thinking_budget_tokens (1024–64000), samples (1–16), temperature (0.0–2.0), plus denylist-skyddat param_override / header_override. Det är redan tillräckligt för att bygga den svårighetsroutade slutpunkten från Tabell A: billig modell på den enkla delen, Opus med en tankebudget på den svåra.

Primitiv 2 — sprid ut till en panel (fusion)

Det är härifrån benchmarklyftet kommer. En parallell: effekt skickar begäran till 2–5 ben samtidigt, sedan en arbiter bestämmer vad klienten faktiskt ser:

- 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"

Fyra skiljedomsstrategier, var och en ett annat svar på "vems output vinner?":

första — tävla med benen, servera den första framgången, avbryt förlorarna. Optimerar latens (du får den snabbaste av N).

majoritet — strukturerad röstning över benens utdata, inget extra modellanrop. När benen delar sig utan strikt majoritet, skickar den valbara on_disagreement: grenen en ny, starkare försök istället för att ge en tie-break. Optimerar robusthet på uppgifter med ett kanoniskt svar.

best_of_n — en LLM-domare läser alla kandidater och rangordnar dem. Detta är konfigurationen Opus + GPT-5.5 → judge från Tabell B. Optimerar kvalitet på öppna uppgifter; faller tillbaka till första lyckade om domaren felar.

tests_pass — execution-grounded: utse kandidaten vars patch faktiskt får testsviten att gå igenom. Ingen domare gissar — testselen bestämmer. Detta är den starkaste domaren för kod/agent-arbete. Verifieraren finns utanför gatewayn (kopplad via en VerifierProvider); om ingen är kopplad, degraderas den till första lyckade.

max_latency_ms (1000–600000, standard 120000) begränsar utbredningen så att en långsam gren inte kan fördröja svaret — eftersläntrare kasseras. Kapsling av parallel i parallel avvisas vid lint; panelen är avsiktligt endast en nivå djup.

Tillgänglighetsanteckning: N-way fan-out-körtiden är portad bakom serverflaggan ROUTING_DSL_ENSEMBLE_RUNTIME medan per-leg fakturering är hårdgjord på staging — det är därför fusion är förhandsversion, inte GA. Med flaggan av, en parallel: regel hanterar rent sitt första ben, så du kan skapa och skugga dina paneler idag och slå på dem när fusion landar i din region.

Primitiv 3 — fallbacks och konfidenskaskader

Fan-out använder N× i förskott. En kaskad använder extra endast när det första svaret ser felaktigt ut. Efter svaret utvärderar on_low_confidence: signaler och, om en löser ut, skickar den om till en starkare destination:

- 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"

patch_invalid (diffen misslyckas vid git apply --check), self_doubt (ett regex-set för försiktighetsfraser), low_logprob (genomsnittlig token-logprob under tröskelvärdet, där leverantören exponerar det), och next_turn_test_failed (en tvärvändningslåsning — denna vändnings prompt bär formen av förra vändningens misslyckade tester). Cascades är djup-1 av design. Para ihop dem med agent_state.models_tried för att få mångfald vid återförsök — skicka aldrig reparationen till modellen som just misslyckades.

Justera ratten: kostnad, latens, kvalitet

Samma DSL uttrycker alla tre målen; du väljer per regel:

Kostnad — delegera: billigaste, behåll den billiga modellen på den lätta svansen, och reservera utvidgning för svårighet > 0.7. Tabell Bs billiga panel (~64.5% ≈ Fable 5 solo) är existensbeviset: en fusion av små modeller kan ersätta en frontmodell till en bråkdel av kostnaden per token. Var klarsynt, dock — fusionen använder "fakturera varje ben" modell: en 3-leg best_of_n-panel fakturerar tre kandidater plus domaren. Ekonomin fungerar för att du (a) endast utökar på den svåra minoriteten av förfrågningar och (b) fusionerar billigare medlemmar än den frontmodell du ersätter.

Latens — arbiter: { strategy: first } plus en snäv max_latency_ms ger dig den snabbaste av N med en hård tak.

Kvalitet — best_of_n för öppet arbete, tests_pass när det finns en testsvit att basera sig på. samples och thinking_budget_tokens köper mer inom en enda omgång.

Att driva den utan att bryta produktionen

Routingförändringar är skrämmande, så DSL levereras med de säkerhetsräcken som en SRE förväntar sig:

Lint vid varje sparande — schema, CEL-typkontroll (varje when: måste utvärderas till bool), referensupplösning, knob-områden, header/param denylists. Fel kommer tillbaka som {rad, kolumn, meddelande, regel} och renderas som gutter-chips i redigeraren.

Torrkörning — POST en syntetisk begäran (task_class, difficulty, agent_state, …) och få tillbaka den matchade regeln, den lösta effekten och utvärderingstiden innan något skickas iväg.

Skuggläge — under 24 timmar efter första sparandet är DSL utvärderas men används inte; en skugglogg registrerar potentiella val och konsolen visar en differens (procent ändrade rutter, beräknad daglig kostnadsförändring, per-regel antal utlösningar).

Canary — ett 0–100 trafikreglage. Rampa 5 → 25 → 50 → 100 med övervakning av mätvärden per segment; rulla tillbaka genom att dra till 0.

Granskning + återställning — varje spara/återställning skriver en revisionsrad i samma transaktion; samtidiga redigeringar får en 409 med den aktuella versionen så att du försöker igen mot färskt tillstånd.

Testfall, spårningsuppspelning och en AI-vy "förklara denna regeluppsättning" avrundar det. Du hittar det i instrumentpanelen under routning → strategi → DSL.

Ett komplett regelverk

Billigt på enkelt, medel på medium, en bedömd fusionspanel på den hårda agentiska svansen, med en förtroendekaskad under:

version: 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

Den slutpunkten är den som ligger högst upp i Tabell A — inte för att den hittade en bättre modell, utan för att den lägger rätt modell på rätt förfrågan och sammanfogar en panel exakt där panelen vinner.

Börja komponera

Nästa kapacitetshopp behöver inte vänta på nästa kontrollpunkt. Det är en graf du kan skriva i eftermiddag: väg efter svårighetsgrad, bred ut på den hårda svansen, bedöm eller testa resultaten, kaskadera när förtroendet sjunker.

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

UI: routning → Skapa router -> Routningsstrategi → DSL (expert)

Fronten är en panel. Bygg din egen.