s1d1-router — a one-pass "System 1" router for LLM requests

One small encoder, one forward pass over the first user message alone, three outputs:

output	type	range
complexity_score	regression	0.01 – 1.00 (tier anchors: trivial 0.01, low 0.25, medium 0.50, high 0.75; the judge's scale had a fifth anchor, expert at 1.00, too rare to learn: see Limitations)
task	19 classes	information_seeking, reasoning, planning, editing, summarization, extraction, classification, translation, coding_debugging, math, data_analysis, writing, role_playing, advice_seeking, brainstorming, completion, action_execution, chat, other
needs_tools	binary	the answer needs fresh/external information, the user's files or systems, or code/actions

Use it in front of a pool of models: send the easy, tool-free requests to a small or local model and keep the expensive one for what needs it.

Base model	jhu-clsp/mmBERT-base (ModernBERT architecture, 22 layers, hidden 768)
Parameters	307 M (110 M outside the embedding matrix)
Input	text, trained with up to 1,024 tokens (the base accepts 8,192)
Head	standard ModernBertForSequenceClassification, 21 outputs (1 + 19 + 1), mean pooling
Languages	138 languages in the training data (English 61.1 %); coverage inherited from mmBERT
Training data	98,033 prompts labelled by an LLM judge (see below)
Training cost	about 3.0 h on one Apple M4 Max (PyTorch MPS), 3 epochs, no cloud
License	Apache-2.0 (see LICENSE and NOTICE; the base model is MIT)

Variants

The models, trained on six sources, are available in four sizes and three formats. They are grouped in the s1d1-router collection.

tier	PyTorch fp16	MLX 8-bit (Apple Silicon)	ONNX int8 (CPU)
Full (mmBERT-base)	this repository · 649 MB	s1d1-router-6src-full-mlx-8bit · 362 MB	s1d1-router-6src-full-onnx-int8 · 345 MB
Compact (32k vocabulary)	s1d1-router-6src-compact · 308 MB	s1d1-router-6src-compact-mlx-8bit · 181 MB	s1d1-router-6src-compact-onnx-int8 · 175 MB
Small (mmBERT-small)	s1d1-router-6src-small · 146 MB	s1d1-router-6src-small-mlx-8bit · 95 MB	s1d1-router-6src-small-onnx-int8 · 92 MB
Tiny (mmBERT-small, 6 layers)	s1d1-router-6src-tiny · 85 MB	s1d1-router-6src-tiny-mlx-8bit · 62 MB	s1d1-router-6src-tiny-onnx-int8 · 61 MB

Each repository card gives its validation measures, its agreement with the full model and its latency.

Quick start

Python ≥ 3.10, transformers ≥ 5 (checked with 5.19) and torch.

import torch
from transformers import AutoModelForSequenceClassification, AutoTokenizer

repo = "scombat/s1d1-router"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForSequenceClassification.from_pretrained(repo).eval()

TASKS = model.config.task_names  # 19 names, in output order 1..19
batch = tok(["Quelle est la capitale de l'Australie ?"], truncation=True, max_length=1024,
            padding=True, return_tensors="pt")
with torch.no_grad():
    out = model(**batch).logits[0]

complexity = float((0.5 + 0.25 * out[0]).clamp(0.01, 1.0))   # 0.01 .. 1.00
task = TASKS[int(out[1:20].argmax())]
needs_tools = bool(torch.sigmoid(out[20]) >= 0.5)

examples/usage.py is the same thing as a script, and s1d1_router.py wraps it: Router(repo, device="mps") takes a Hub id or a local folder, picks the backend (PyTorch, MLX or ONNX Runtime, from variant.json), applies vocab_map.npy for the pruned-vocabulary variants and returns complexity_score, complexity_tier (trivial / low / medium / high), task, needs_tools, needs_tools_probability and prompt_tokens. On a CPU it loads the weights in float32.

Do not read this model through pipeline("text-classification") with its defaults, nor through Text Embeddings Inference: both apply one softmax over the 21 outputs, but output 0 is a regression and output 20 is a binary logit. config.json declares problem_type: regression, so the pipeline returns the raw outputs when asked for all of them: pipeline("text-classification", model=repo, top_k=None) gives 21 {label, score} pairs named by id2label (complexity, task:<name>, needs_tools; checked with transformers 5.19), to decode as above. The text-embeddings-inference tag is added by the Hub for this architecture; TEI's scores are a softmax over the 21 outputs and are wrong for this model. Hence inference: false.

Expected output on the three prompts of examples/usage.py:

prompt	complexity	task	needs_tools
Quelle est la capitale de l'Australie ?	0.01 (trivial)	information_seeking	false
Write a Python function that merges overlapping intervals and explain its complexity.	0.33 (low)	coding_debugging	false
Search the web for today's EUR/USD rate and put it in my spreadsheet.	0.20 (low)	action_execution	true

How to use the outputs

A deliberately simple policy (thresholds are yours to set on your own traffic):

if needs_tools or complexity >= 0.75:      route_to = "frontier"
elif complexity >= 0.50:                   route_to = "mid"
else:                                      route_to = "small/local"

Two other uses: choosing the reasoning effort or thinking budget of a single model per request; triaging a queue (cheap batch endpoint for trivial/low, interactive endpoint for the rest).

Why this design

• Encoder, not decoder. At equal size, controlled comparisons favour bidirectional encoders for classification and regression (Ettin), published routers (RouteLLM, Hybrid LLM, NVIDIA's prompt classifier) use encoders of 100–400 M parameters, and an encoder costs about 4× less to train and is faster at batch size 1.
• Why mmBERT-base. It is the only candidate that covers all the languages of our data with a native ForSequenceClassification class, an MIT license and 8k context. In a pilot (30,000 training prompts, 2 epochs) it beat the encoder of laya-multilingual (itself mmBERT-base with a decision head) on every validation metric, by 1–2 points. One seed: read it as "not worse and probably slightly better".
• A standard model, a custom loss. The published model has no custom code: the loss lives in the training script (train.py here, a port of the project's pipeline/05_train.py) — squared error on the complexity (rows whose complexity is null are masked), cross-entropy on the task, binary cross-entropy on needs_tools, summed with no coefficient (complexity is expressed in tier units so its scale matches the cross-entropies).
• Trained on the prompt alone. The router never sees the answer, a system prompt or the conversation history. It reads the first user message.

Training data and labels

98,033 / 4,914 / 10,000 prompts (train / validation / test) from six public sources (WildChat, lmsys-chat-1m, UltraChat, Aya, Magpie, OASST2), drawn by source × language × length cell, with a second wave oversampling high complexity and rare tasks. The dataset is not published.

source	train	validation	test
WildChat	26,070	1,293	2,000
lmsys-chat-1m	21,102	1,079	1,667
UltraChat	17,771	866	1,333
Aya	13,879	690	3,200
Magpie	13,295	705	1,000
OASST2	5,916	281	800

Labels come from an LLM judge, not from humans: google/gemma-4-31B-it with a 512-token reasoning budget and a fixed rubric (v7), temperature 0. Rubric agreement with a Claude Opus reference on an 85-item bench: 76 % (complexity, QWK 0.87), 88 % (task), 96 % (needs_tools). A human read of 200 labelled prompts corrected 11.5 % of them (mostly low that should be trivial); about 3.4 % of labels change between two passes. Every number below measures agreement with this judge. The rubric (v7, byte for byte) and the exact request sent to the judge (messages, JSON schema, reasoning budget, model revision) are in judge/, so you can label your own traffic the same way.

Test hygiene: training and validation prompts at estimated Jaccard ≥ 0.8 of a test prompt (character 5-shingles, MinHash) were removed, near-duplicate groups are never split across train and validation, and groups of more than 20 rows go to train only. Template families that still cross the sets (300 test rows) are listed in test_template_family_keys.txt; test results are reported on the full test set and without those rows.

Results

Validation, 4,914 prompts (complexity on the 4,850 non-null rows), after 3 epochs. "Weighted" restores the natural distribution of the pool with the rebalance_weight column (factors computed on the training set; the model is trained without them). Chance level for task is 5.3 %, majority class (information_seeking) 31.1 %.

	unweighted	weighted
Complexity MAE	0.073	0.071
Complexity Spearman	0.750	0.710
Complexity QWK (rounded to the nearest tier)	0.766	0.719
Task accuracy / macro-F1	0.856 / 0.785	0.858 / 0.775
needs_tools F1 / AUROC (5.1 % positives in validation)	0.646 / 0.965	0.650 / 0.967

Test, 10,000 prompts, evaluated once (more multilingual than train: English 39.7 % vs 61.1 %):

	full test (10,000)	without the 300 template-family rows (9,700)
Complexity MAE / Spearman / QWK	0.070 / 0.708 / 0.710	0.071 / 0.701 / 0.694
Task accuracy / macro-F1	0.858 / 0.761	0.855 / 0.760
needs_tools F1 / AUROC (4.0 % positives in test)	0.647 / 0.954	0.621 / 0.949

Complexity confusion matrix, full test, on the 9,894 rows with a judge complexity (106 test rows are null and are excluded from every complexity metric; rows: judge tier, columns: predicted tier):

judge \ predicted	trivial	low	medium	high	expert
trivial (718)	395	312	11	0	0
low (6,450)	115	5,804	528	2	1
medium (2,506)	5	744	1,674	83	0
high (217)	0	9	68	140	0
expert (3)	0	1	1	1	0

Recall per tier: trivial 55 %, low 90 %, medium 67 %, high 65 %, expert 0 %. Almost every error is one tier off (30 rows are two tiers or more away).

Task F1 per class, full test (support in parentheses):

class	F1	class	F1
information_seeking (3,483)	0.90	role_playing (130)	0.89
writing (1,582)	0.90	advice_seeking (297)	0.77
completion (735)	0.82	brainstorming (257)	0.70
coding_debugging (682)	0.90	reasoning (205)	0.65
extraction (598)	0.83	chat (166)	0.61
math (415)	0.92	other (138)	0.50
summarization (401)	0.86	planning (87)	0.62
editing (397)	0.84	data_analysis (28)	0.56
classification (249)	0.87	action_execution (18)	0.38
translation (132)	0.93

Per language, full test (pipeline/09_per_language.py in the project, same weights and metrics as above, computed once). Pooled, the 3,973 English prompts give MAE 0.073 / QWK 0.71 / task accuracy 0.87 / needs_tools F1 0.70, the 6,027 non-English prompts MAE 0.068 / QWK 0.70 / task accuracy 0.85 / needs_tools F1 0.60 (AUROC 0.94). The table lists the languages with at least 100 test rows (51 of 78, sorted by test rows) and pools the 27 others. Read it with care: one seed, and outside English every line rests on 100 to 355 prompts, so about ±0.07 to ±0.09 on an accuracy at n = 100 and more on a QWK or on an F1 with a handful of positives. Read the QWK with the share of low next to it: where the judge put about 80 % or more of a language's prompts in low (Japanese, Dutch, Irish, Bengali, Malagasy, Turkish, Finnish, Thai) the kappa hangs on a handful of rows and is low although the MAE is the best of the table. Read the task accuracy with the majority-class share next to it: for most Aya languages a constant predictor already gets 0.5–0.85. needs_tools has 0 to 18 positives per language outside English; for several languages the F1 at 0.5 is 0 while the AUROC is above 0.9 (the few positives rank above the negatives but under the threshold). 247 of the 300 template-family rows are English, 28 Chinese, 18 Punjabi; without them English QWK is 0.69, Chinese 0.75, Punjabi 0.59. The lat and tgl rows (WildChat) are mostly language-detector errors (English, Chinese or Uzbek prompts).

language	test rows	train rows	complexity QWK (share of low)	complexity MAE	task accuracy (majority class)	needs_tools F1 (positives)	needs_tools AUROC
all (78 languages)	10,000	98,033	0.71 (0.65)	0.070	0.86 (0.35)	0.65 (405)	0.95
English (eng)	3,973	59,872	0.71 (0.61)	0.073	0.87 (0.29)	0.70 (177)	0.97
Spanish (spa)	355	3,570	0.73 (0.65)	0.070	0.79 (0.33)	0.74 (9)	0.99
Chinese (zho)	294	6,492	0.81 (0.43)	0.075	0.87 (0.36)	0.50 (10)	0.97
Russian (rus)	230	4,213	0.64 (0.65)	0.073	0.81 (0.29)	0.67 (9)	0.95
German (deu)	167	1,531	0.80 (0.55)	0.069	0.83 (0.26)	0.62 (5)	0.99
French (fra)	157	1,777	0.63 (0.61)	0.072	0.81 (0.25)	0.33 (1)	1.00
Portuguese (por)	139	2,411	0.65 (0.69)	0.071	0.86 (0.29)	0.50 (3)	0.99
Japanese (jpn)	130	932	0.45 (0.85)	0.051	0.90 (0.44)	1.00 (1)	1.00
Arabic (ara)	128	1,047	0.67 (0.69)	0.069	0.92 (0.34)	— (0)	—
Italian (ita)	124	1,055	0.67 (0.63)	0.078	0.78 (0.26)	0.55 (7)	0.92
Thai (tha)	120	255	0.49 (0.81)	0.058	0.81 (0.28)	0.00 (1)	0.99
Vietnamese (vie)	115	721	0.57 (0.74)	0.066	0.92 (0.36)	0.86 (4)	0.98
Polish (pol)	114	476	0.62 (0.53)	0.093	0.89 (0.28)	0.83 (7)	0.99
Ukrainian (ukr)	113	241	0.72 (0.51)	0.081	0.74 (0.38)	0.78 (18)	0.94
Dutch (nld)	110	360	0.36 (0.87)	0.066	0.88 (0.38)	1.00 (3)	1.00
Turkish (tur)	110	642	0.42 (0.85)	0.056	0.88 (0.37)	0.84 (10)	0.97
Basque (eus)	108	165	0.60 (0.64)	0.081	0.86 (0.61)	0.40 (3)	0.97
Latin (lat)	106	319	0.54 (0.65)	0.089	0.85 (0.32)	0.55 (4)	0.98
Hungarian (hun)	104	159	0.62 (0.55)	0.091	0.80 (0.28)	0.86 (7)	0.99
Greek (ell)	103	148	0.66 (0.79)	0.050	0.95 (0.56)	— (0)	—
Finnish (fin)	103	142	0.40 (0.84)	0.055	0.83 (0.54)	1.00 (1)	1.00
Swedish (swe)	103	185	0.52 (0.82)	0.056	0.91 (0.73)	1.00 (1)	1.00
Danish (dan)	102	167	0.58 (0.53)	0.088	0.75 (0.26)	0.75 (11)	0.97
Indonesian (ind)	102	293	0.78 (0.59)	0.064	0.92 (0.29)	0.50 (6)	0.95
Korean (kor)	102	285	0.68 (0.62)	0.081	0.83 (0.30)	0.50 (6)	0.97
Malay (msa)	102	506	0.80 (0.83)	0.042	0.96 (0.47)	0.67 (2)	0.95
Norwegian (nor)	102	53	0.82 (0.61)	0.071	0.81 (0.25)	0.92 (7)	1.00
Persian (fas)	101	295	0.69 (0.58)	0.082	0.92 (0.29)	0.71 (10)	0.88
Romanian (ron)	101	60	0.67 (0.69)	0.066	0.86 (0.37)	0.80 (5)	0.98
Shona (sna)	101	140	0.48 (0.74)	0.074	0.79 (0.43)	0.40 (2)	0.82
Somali (som)	101	477	0.62 (0.57)	0.078	0.93 (0.81)	0.00 (5)	0.89
Yoruba (yor)	101	511	0.75 (0.44)	0.062	0.63 (0.26)	0.40 (3)	0.97
Amharic (amh)	100	106	0.50 (0.73)	0.071	0.88 (0.62)	0.44 (4)	0.98
Bengali (ben)	100	157	0.37 (0.86)	0.050	0.85 (0.34)	— (0)	—
Irish (gle)	100	123	0.39 (0.94)	0.048	0.88 (0.55)	0.44 (5)	0.94
Gujarati (guj)	100	368	0.69 (0.79)	0.047	0.88 (0.57)	0.00 (1)	0.92
Hausa (hau)	100	334	0.64 (0.73)	0.061	0.93 (0.41)	0.00 (7)	0.82
Hindi (hin)	100	86	0.63 (0.84)	0.050	0.93 (0.44)	0.67 (2)	0.98
Igbo (ibo)	100	120	0.53 (0.78)	0.072	0.68 (0.38)	0.00 (4)	0.98
Kyrgyz (kir)	100	475	0.57 (0.64)	0.074	0.91 (0.74)	0.00 (3)	0.54
Malayalam (mal)	100	173	0.68 (0.74)	0.050	0.87 (0.54)	0.22 (6)	0.73
Marathi (mar)	100	286	0.71 (0.75)	0.059	0.88 (0.74)	0.00 (3)	0.96
Malagasy (mlg)	100	457	0.31 (0.79)	0.058	0.85 (0.46)	— (0)	—
Nepali (nep)	100	352	0.62 (0.74)	0.068	0.92 (0.62)	— (0)	—
Punjabi (pan)	100	474	0.81 (0.60)	0.053	0.88 (0.65)	0.00 (3)	0.96
Sinhala (sin)	100	471	0.53 (0.74)	0.070	0.94 (0.85)	0.00 (6)	0.65
Tamil (tam)	100	463	0.54 (0.73)	0.076	0.91 (0.68)	1.00 (1)	1.00
Telugu (tel)	100	464	0.62 (0.72)	0.067	0.89 (0.56)	1.00 (4)	1.00
Tagalog (tgl)	100	133	0.57 (0.58)	0.092	0.83 (0.35)	0.77 (6)	0.96
Wolof (wol)	100	273	0.54 (0.79)	0.062	0.87 (0.49)	0.00 (1)	0.91
Zulu (zul)	100	157	0.77 (0.54)	0.069	0.70 (0.51)	0.40 (3)	0.72
other (27 languages)	79	1,550	0.70 (0.66)	0.064	0.77 (0.29)	0.57 (8)	0.96

Pilot (30,000 training prompts, 2 epochs, validation, for orientation only): QWK 0.72, task accuracy 0.82, macro-F1 0.72, needs_tools F1 0.62 / AUROC 0.95. Rebalancing weights in the loss changed nothing measurable in the pilot, so the released model is trained without them.

Latency (Apple M4 Max, batch 1, 200 prompts after warm-up): PyTorch fp16 on MPS (Router(repo, device="mps")) p50 10.1 ms (p95 39 ms); MLX 8-bit p50 4.5 ms; ONNX int8 on CPU p50 10.9 ms. Smaller variants: see Variants.

Limitations (read before relying on it)

• Labels are model judgments. The router learns the judge's idea of complexity, with its noise (11.5 % of the 200 prompts we re-read were corrected). It is not a measure of how hard a prompt is for your model.
• trivial is hard to separate from low (recall 50 % in validation, 55 % in test) and expert is not learnable: 81 examples in train + validation, 3 in test, never predicted on test. s1d1_router.py therefore reports four tiers and labels every score above 0.625 high; the score itself still runs up to 1.00.
• Rare tasks are unreliable: data_analysis (531 train rows), action_execution (357), other (1,367), planning, role_playing. Their F1 moves a lot between runs.
• needs_tools has 4.9 % positives in train (5.1 % in validation, 4.0 % in test); the 0.5 threshold is not tuned. Calibrate it on your own data.
• Test is more multilingual than training. The per-language table above rests on about 100 test prompts per language outside English, one seed, no confidence interval; the language labels of WildChat, lmsys and Magpie come from automatic detectors and are partly wrong on short prompts.
• Complexity is not cost. We did not measure the quality or price of any model behind the router. The routing policy above is an example, not a validated one.
• One seed per configuration, no confidence intervals. Differences of about 0.01 are within what we would expect from noise.
• Single turn only. No system prompt, no history. Prompts longer than 1,024 tokens are truncated (3.8 % of train, 4.0 % of test).
• Template-heavy data. Some of the training prompts are web-scraped templates (e.g. a Chinese slide-deck template) with very homogeneous labels.
• Raw prompts. The data was not moderated; sexual, hateful and jailbreak prompts are labelled by intent.

Use it with LiteLLM's Auto Router

LiteLLM's auto router sends each request to the model of a tier (SIMPLE, MEDIUM, COMPLEX, REASONING, or your own set of 2 to 8 tiers) and asks a classifier for that tier. integrations/litellm/serve_litellm.py is such a classifier: an OpenAI-compatible endpoint that answers the tier from the complexity score, in a few milliseconds and without an LLM call. You choose which scores go to which tier.

GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/scombat/s1d1-router && cd s1d1-router   # code only
S1D1_TIERS="SIMPLE=0.5,MEDIUM=0.6,COMPLEX=0.9,REASONING=1.0" \
  integrations/litellm/serve_litellm.sh scombat/s1d1-router-6src-small-onnx-int8 --host 0.0.0.0 --port 8788

The launcher needs uv and fetches the packages of the variant's backend on the first start. Then, in the LiteLLM UI: add an OpenAI-compatible model s1d1-classifier with API base http://HOST:8788/v1, create an auto router, pick LLM Classifier with model s1d1-classifier in its advanced options, set the timeout to 1000 ms, and put your models in the tiers. Clients call the auto router by its name.

Tested end to end on LiteLLM v1.103.2 through its Admin UI, with the standard tiers and with a five-tier custom set; the request format was checked unchanged in v1.106.0. Full walkthrough, config.yaml form, llama-swap setup and known pitfalls: tutorials/02-litellm.md.

Use it in your stack

s1d1_router.py loads any repository of the Variants table (Hub id or local folder; PyTorch, MLX or ONNX backend) and decodes the outputs; integrations/ turns them into a model and a reasoning effort with a YAML policy (policy.example.yaml, with profiles for Claude Code, Codex and generic harnesses), a small HTTP server, a launcher for Claude Code / Codex, and LiteLLM integrations. integrations/serve_variant.sh MODEL and integrations/litellm/serve_litellm.sh MODEL start a server for any variant without installing anything (they need uv). Tutorials: tutorials/ (HTTP, LiteLLM, Claude Code, Codex, n8n, OpenClaw). Each page says what was checked against the tool's documentation and what is untested.

Fine-tune it for your own routes

Three levels, from cheapest:

1. Re-use as-is and set your own thresholds on complexity_score / needs_tools, using a few hundred of your own labelled requests.
2. Continue training with the same 21 outputs on your labels: train.py in this repository reads a parquet file (prompt, complexity_score nullable, task, needs_tools, optional weight), starts from these weights (or from mmBERT with --base jhu-clsp/mmBERT-base) and applies the loss above with the recipe of the published model. To label your own traffic with the same judge, the rubric and the exact request are in judge/.

   python train.py --train my_prompts.parquet --validation my_validation.parquet --out my-router --device mps
   

3. Your own classes: keep the encoder and replace the head.

   model = AutoModelForSequenceClassification.from_pretrained("scombat/s1d1-router", num_labels=N, ignore_mismatched_sizes=True,
                                                              problem_type="single_label_classification")  # the config says regression
   

   then train with any standard classification loop (Trainer works).

A full fine-tune of this size ran at about 27 prompts/s on a laptop-class Apple GPU (3 epochs on 98k prompts ≈ 3.0 h).

Estimated upside (a best-case estimate, not a measurement)

Question: what is the most you could save by not sending every request to a frontier model at maximum reasoning effort? Upper bound on the share of requests that are even candidates for a smaller model:

• In the naturally-sampled part of our data (wave 1, 27,871 train prompts), 69% of prompts are trivial or low and 96% need no tools. Those are the candidates.
• If a request costs C_big on the frontier model with extended reasoning and C_small on a local/small model, the best-case saving is share_routable × (1 − C_small / C_big). With a local model at a marginal cost close to zero this is bounded by the routable share itself (about 69% of the spend if costs per request were equal, more if extended reasoning is expensive on easy prompts, because easy prompts then cost as much as hard ones).
• What this ignores: that the small model must actually answer those prompts well (not measured), requests that the router misplaces (trivial recall is 50 % in validation), your own traffic mix (ours is a public-data mix), the cost of running the local model, and latency. Treat it as the ceiling, not as the expected value.

Intended use

Routing, triage and effort selection for LLM requests; analysis of prompt mixes. Not for: moderation or safety decisions, grading users, or any decision that must be right on a single input.

License

Apache-2.0. The base model, mmBERT-base, is MIT-licensed; its notice is kept in NOTICE. The license requires you to keep LICENSE and NOTICE when you redistribute the weights or a derivative; it does not require attribution when you merely use the model in a product or behind an API. If you use it in published work or a product, we would appreciate a mention and the citation below (a request, not a condition).

Citation and related work

@misc{s1d1_router_2026,
  title  = {s1d1-router: a one-pass multilingual router for LLM requests},
  author = {scombat},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/scombat/s1d1-router}}
}

Related: laya-multilingual and THX-01 (also built on mmBERT-base), NVIDIA prompt-task-and-complexity-classifier.

References:

• mmBERT: A Modern Multilingual Encoder with Annealed Language Learning (arXiv:2509.06888)
• Smarter, Better, Faster, Longer: A Modern Bidirectional Encoder for Fast, Memory Efficient, and Long Context Finetuning and Inference (ModernBERT, arXiv:2412.13663)
• Seq vs Seq: An Open Suite of Paired Encoders and Decoders (Ettin, arXiv:2507.11412)
• EuroBERT: Scaling Multilingual Encoders for European Languages (arXiv:2503.05500)
• Unsupervised Cross-lingual Representation Learning at Scale (XLM-R, arXiv:1911.02116)
• RouteLLM: Learning to Route LLMs with Preference Data (arXiv:2406.18665)
• Hybrid LLM: Cost-Efficient and Quality-Aware Query Routing (arXiv:2404.14618)
• Arch-Router: Aligning LLM Routing with Human Preferences (arXiv:2506.16655)
• FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance (arXiv:2305.05176)
• ThinkSwitcher: When to Think Hard, When to Think Fast (arXiv:2505.14183)
• Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena (arXiv:2306.05685)
• Model Cards for Model Reporting (arXiv:1810.03993)