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 the test requests.

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 verdict, cost and tokens
router_answers	4,374	the answer of one router setting (commercial or Weflayr's), with the model it picked
effort_answers	8,848	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
partition	string	benchmark or test, split by conversation
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
finish_reason	string	as returned by the provider
cost_usd	float	at the provider's standard list price
input_tokens, output_tokens	int	as billed
judgment_gpt_6_luna	JSON string	GPT-6 Luna's check of each use case instruction, with its reason

model_answers adds model and latency_seconds. 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, reasoning_effort and reasoning_tokens.

Commercial routers

Both were called through OpenRouter in October 2026.

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

Jev picks a model and its reasoning effort. Only 10 of the 18 models are in its own pool. The settings on 203 requests ran on the requests that were test at the time: today's 198 test requests and 5 now in benchmark.

Weflayr's router

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

Weflayr's router picks, for each test 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 benchmark 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 benchmark requests.

The same quality threshold is set per use case, on its benchmark requests (each scored from the use case's other benchmark 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 benchmark requests, 0.5 when no quality score reaches 80%. When no candidate reaches it, the router picks the highest quality score.

Under that combined verdict, on the 198 test requests, with net quality = 200 x (mean score - 0.5) (0 is Opus 5.5's level):

router	Net quality	Cost, % of Opus 5.5's
weflayr/best-quality	+14.1	29.8%
weflayr/same-quality	+1.0	11.5%

Each picked Opus 5.5 once, a row with no verdicts that 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. The rows with reasoning_effort default are a control: each model at its default effort, called directly, on the same 203 requests as the commercial router settings, to compare with the same model in model_answers.

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, keep partition == "test" aside, learn and tune on benchmark, and compare on test the router's 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.