Weflayr/routing-corpus

Weflayr LLM Routing Corpus

1,177 multi-turn, tool-calling requests from 11 agent use cases, each answered by 18 LLMs, by 3 OpenAI models at several reasoning efforts, and by two commercial routers (OpenRouter's Auto Router and TypeSafe's Jev), with every answer judged against Claude Opus 5.5's answer to the same request by three LLM judges. It also holds the answers Weflayr's own router picks on every request, under 5-fold cross-validation.

We built it at Weflayr to train and evaluate LLM routers: given a request, which model answers it as well as a strong reference, for the lowest cost?

What is in it

Config	Rows	One row is
requests	1,177	a request, ready to send as an OpenAI Chat Completions call
model_answers	21,186	one of the 18 models' answer to a request, with its verdicts and cost
router_answers	14,124	the answer of one router setting (commercial or Weflayr's), with the model it picked
effort_answers	8,239	an OpenAI model's answer at a given reasoning effort

The 11 use cases

A use case is one agent: one system prompt and one tool set, shared by all its requests.

Source	Use cases	Requests	Origin
sopbench	bank, dmv, healthcare, hotel, library, online_market, university	808	SOPBench (MIT)
tau2	airline, retail, telecom	278	τ²-bench (MIT)
weflayr	database_search_agent	91	a production agent observed by Weflayr

Each request is one point of a conversation: the history up to an assistant turn, which the model must produce next (a reply or tool calls). Requests of the same conversation share a conversation_id. In the hotel use case, one tool description was corrected from the SOPBench original.

weflayr/database_search_agent is a data analyst assistant that answers employees' business questions, mostly in French, by querying a company's Looker instance through its MCP tools (schema discovery, then queries). Its requests are real production calls, with the company and people names anonymized.

The 18 models

Alibaba Qwen 3.8 27B, Flash and Max; Anthropic Claude Opus 5.5 and Sonnet 5.5; DeepSeek V4 Pro and V4.1 Flash; Google Gemini 3.1 Pro Preview, 3.8 Flash and 3.5 Flash Lite; Mistral Medium 3.5 and Small 2603; Moonshot Kimi K3; OpenAI GPT-6 Luna, GPT-6 Sol and GPT-6.1 Sol; xAI Grok 4.7; Z.ai GLM 5.3. Each was called once per request, at its provider's default reasoning effort.

How answers are scored

Claude Opus 5.5 is the reference. Three judges each compare every answer with Opus 5.5's answer to the same request, against the use case's own instructions (one check per instruction), with both answer orders:

Judge	Reasoning effort	Column
OpenAI GPT-6 Luna	high	verdict_gpt_6_luna
Anthropic Claude Haiku 5.5	high	verdict_claude_haiku_5_5
Google Gemini 3.8 Flash	low	verdict_gemini_3_8_flash

Each judge says whether the answer is better than Opus 5.5's, the same quality, or worse. Judges disagree on about a fifth of the answers, and a single judge tends to favor its own provider's answers (GPT-6 Luna rated OpenAI answers about 25 net points higher than the other two did), so combining them is up to you: a majority vote, one judge breaking the other two's ties, or any other rule.

Opus 5.5's own rows, and answers that failed or were cut off (status failed or incomplete), have no verdicts. Scoring better 1, same 0.5 and worse 0, with a failed answer at 0, a model whose mean score is above 0.5 beats Opus 5.5 on average.

Columns

requests

Column	Type	Description
request_id	string	unique id, <source>/<use case>/...
source	string	sopbench, tau2 or weflayr
use_case	string	the agent, e.g. tau2/airline
conversation_id	string	requests of one conversation share it
cross_validation_split_1 ... cross_validation_split_5	string	train or test: the request's role in each of the 5 cross-validation splits (see below)
messages	JSON string	OpenAI chat messages: system prompt, then the conversation
tools	JSON string	OpenAI tool definitions

model_answers and router_answers share these columns:

Column	Type	Description
request_id, use_case	string	the request answered
verdict_gpt_6_luna, verdict_claude_haiku_5_5, verdict_gemini_3_8_flash	string	each judge's verdict: better, same, worse, or null
status	string	ok, incomplete or failed
answer_content	string	the answer's text, null when the answer is only tool calls
answer_tool_calls	JSON string	the answer's tool calls, OpenAI format
cost_usd	float	at the provider's standard list price
judgment_gpt_6_luna	JSON string	GPT-6 Luna's check of each use case instruction, with its reason

model_answers adds model. router_answers adds router, routed_model (the model the router picked), routed_model_in_pool and reasoning_effort (the effort Jev or Weflayr's router picked, null for OpenRouter's Auto Router and for a model at its default effort). effort_answers adds model and reasoning_effort.

Commercial routers

Both were called through OpenRouter in October and November 2026, on every request.

router	Setting
openrouter/auto	OpenRouter's Auto Router over its whole catalog
openrouter/auto-pool	Auto Router limited to the 18 models above
openrouter/auto-pool-medium	limited to the 18 models, cost_tier medium
openrouter/auto-pool-high	same, cost_tier high
openrouter/auto-pool-xhigh	same, cost_tier xhigh
openrouter/auto-pool-max	same, cost_tier max
typesafe/jev-pool	TypeSafe's Jev router, limited to the 18 models, default cost tier
typesafe/jev-pool-low	same, cost tier low
typesafe/jev-pool-medium	same, cost tier medium
typesafe/jev-pool-high	same, cost tier high

Jev picks a model and its reasoning effort. Only 10 of the 18 models are in its own pool. Neither router learns from this dataset, so each is simply scored on all 1,177 requests.

Weflayr's router

router	Setting
weflayr/best-quality	the candidate with the highest quality score
weflayr/same-quality	the cheapest candidate whose quality score reaches the use case's threshold

Weflayr's router picks, for each request, one of 25 candidates: the 18 models at their default effort and the 7 reasoning efforts of effort_answers. Its rows copy the picked answer from model_answers or effort_answers. A candidate's quality score on a request is its expected verdict score (better 1, same 0.5, worse 0; Opus 5.5 is 0.5) on the 50 most similar train requests of the same use case, each weighing exp(-20 x cosine distance), under the judges' combined verdict: GPT-6 Luna and Claude Haiku 5.5's when they agree, Gemini 3.8 Flash's otherwise. Its cost is its mean bill over the use case's train requests.

The same quality threshold is set per use case, on its train requests (each scored from the use case's other train requests): the lowest quality score from which at least 80% of the answers are the same as or better than Opus 5.5's, averaged with 0.51 when the use case has fewer than 250 train requests, 0.5 when no quality score reaches 80%. When no candidate reaches it, the router picks the highest quality score.

Cross-validation

Weflayr's router is evaluated with 5-fold cross-validation, so every request is routed once by a router that never saw it:

1. Within each use case, the conversations are shuffled with numpy's default_rng(41) (seed 41) and dealt into 5 folds in turn. All requests of one conversation land in the same fold, so no conversation is split between train and test.
2. Split k (cross_validation_split_k) tests fold k and trains on the other 4 folds: the quality scores, costs and same quality thresholds all come from its train requests only.
3. Each request is test in exactly one split (231 to 240 requests per split), and its weflayr/* row is the pick made in that split.

Results

On all 1,177 requests, under the combined verdict above, with net quality = 200 x (mean score - 0.5) (0 is Opus 5.5's level, a failed answer scores 0) and the cost as a share of Opus 5.5's total. The 95% confidence interval comes from a paired bootstrap that resamples whole conversations (2,000 draws, seed 41).

router	Net quality (95% confidence interval)	Better / same / worse	Cost, % of Opus 5.5's
weflayr/best-quality	+19.7 (+15.5, +23.7)	37.0% / 45.6% / 17.3%	29.5%
weflayr/same-quality	+5.0 (+0.8, +9.2)	30.2% / 44.7% / 25.1%	10.9%
openrouter/auto	-23.7 (-28.2, -19.0)	23.4% / 29.4% / 47.1%	3.0%
openrouter/auto-pool	-18.7 (-22.7, -14.4)	20.1% / 41.2% / 38.7%	1.9%
openrouter/auto-pool-medium	-16.2 (-20.4, -12.1)	19.0% / 45.7% / 35.3%	27.4%
openrouter/auto-pool-high	-6.4 (-10.6, -2.6)	22.9% / 47.9% / 29.2%	34.7%
openrouter/auto-pool-xhigh	-2.3 (-6.2, +1.9)	24.1% / 49.5% / 26.4%	39.4%
openrouter/auto-pool-max	-4.5 (-8.7, -0.8)	22.5% / 50.5% / 27.0%	41.4%
typesafe/jev-pool	-14.2 (-18.1, -10.2)	19.9% / 46.0% / 34.1%	35.7%
typesafe/jev-pool-low	-14.6 (-18.9, -10.4)	22.7% / 40.0% / 37.3%	19.3%
typesafe/jev-pool-medium	-14.4 (-18.7, -10.4)	19.5% / 46.6% / 33.9%	36.0%
typesafe/jev-pool-high	-7.1 (-11.0, -3.5)	20.7% / 51.4% / 27.9%	37.2%

A weflayr/* row that picked Opus 5.5 copies Opus 5.5's own answer, which has no verdicts and scores 0.5.

Reasoning efforts

effort_answers holds three OpenAI models at reasoning efforts other than their default, on every request: GPT-6 Luna at none, high and xhigh, GPT-6 Sol at low and high, GPT-6.1 Sol at high and xhigh (it refuses none). These were called on OpenAI directly, while model_answers went through Weflayr's gateway.

How to use it

import json
from datasets import load_dataset

requests = load_dataset("Weflayr/routing-corpus", "requests", split="train")
answers = load_dataset("Weflayr/routing-corpus", "model_answers", split="train").to_pandas()

# Mean score per model under Claude Haiku's verdicts (0.5 = as good as Claude Opus 5.5)
score_by_verdict = {"better": 1.0, "same": 0.5, "worse": 0.0}
answers["score"] = answers["verdict_claude_haiku_5_5"].map(score_by_verdict).fillna(0.0)
answers.loc[answers["model"] == "anthropic/claude-opus-5.5", "score"] = 0.5
print(answers.groupby("model")[["score", "cost_usd"]].mean().sort_values("score"))

Send a request to any OpenAI-compatible endpoint:

from openai import OpenAI

request = requests[0]
response = OpenAI().chat.completions.create(
    model="gpt-6-luna",
    messages=json.loads(request["messages"]),
    tools=json.loads(request["tools"]) or None,
)

To train a router, run the 5 cross-validation splits: in split k, learn and tune on the requests where cross_validation_split_k == "train" and route those where it is "test". After the 5 splits every request has one pick; compare its mean score and cost with each single model's and with router_answers. Add effort_answers to route between reasoning efforts as well as models. Hold out whole use cases to measure how a router does on an agent it has never seen.

Limitations

• One answer per model and request: verdicts are noisy on single requests, and reliable as averages over a use case or more.
• The verdict is relative to Claude Opus 5.5's answer, not to a ground truth.
• Costs are list prices, without prompt caching discounts.

License

MIT. The sopbench and tau2 requests come from SOPBench and τ²-bench, both MIT.