> ## Documentation Index
> Fetch the complete documentation index at: https://benchgen.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# BenchGen Router Lite
> How to send requests through BenchGen Router Lite, an OpenRouter-style single endpoint that picks the model for you.
**BenchGen Router Lite** is a single model endpoint that picks a different underlying model per query instead of always answering with the same one. On [Router Fidelity Benchmark](https://benchgen.com/benchmarks/platform/router-fidelity-benchmark) it scored **82.6%**, more accurate than always calling its own strongest pool member, at **roughly 3.1x lower cost**. See it live on its [model page](https://benchgen.com/models/benchgen/benchgen-router-lite).
This page covers how to call it. For the complete story, the dataset, training, and full benchmark breakdown, see [BenchGen Router Lite](/docs/guides/router-head/benchgen-router-lite) in Guides.
***
## How it works
Every query gets embedded by a frozen backbone (`Qwen/Qwen3-1.7B`), a small trained head (10,245 parameters, a linear classifier) scores each pool member against that embedding, and the top-scoring member is called for real. Its reply, unedited, is what comes back to you. The router itself never generates a single word of the answer.
The pool it currently routes between (see the [model's own card](https://benchgen.com/models/benchgen/benchgen-router-lite) for the live list, the models behind each slot can be swapped over time):
| Role | Slot | Mode |
| --------------- | ---------------------------------------- | ------------------------------------- |
| Frontier | `frontier_a`, `frontier_b`, `frontier_c` | Reasoning / Direct |
| Mid-tier | `open_mid` | Direct, deliberately the weakest slot |
| Cheap reasoning | `open_cheap_reasoning` | Reasoning |
Unlike a fine-tuned model or a merged LoRA adapter, this pool is fixed at training time. The head can only choose among the agents it was trained against, it doesn't discover or add models on its own.
***
## Usage
Calling it is identical to calling any other BenchGen model, only the model name changes: point at the same gateway, authenticate with an [inference API token](/docs/inference/api-token), and set `model` to `benchgen-router-lite`. The endpoint is OpenAI-compatible, so any client that speaks the chat completions format works, the OpenAI SDK included.
```bash cURL theme={null}
curl https://gateway.benchgen.com/v1/chat/completions \
-H "Authorization: Bearer sk-..." \
-H "Content-Type: application/json" \
-d '{
"model": "benchgen-router-lite",
"messages": [
{"role": "user", "content": "Explain quantum entanglement in simple terms"}
]
}'
```
```python Python theme={null}
from openai import OpenAI
client = OpenAI(
api_key="sk-...",
base_url="https://gateway.benchgen.com/v1",
)
completion = client.chat.completions.create(
model="benchgen-router-lite",
messages=[
{"role": "user", "content": "Explain quantum entanglement in simple terms"}
],
)
print(completion.choices[0].message.content)
```
```javascript Node theme={null}
import OpenAI from "openai";
const client = new OpenAI({
apiKey: "sk-...",
baseURL: "https://gateway.benchgen.com/v1",
});
const completion = await client.chat.completions.create({
model: "benchgen-router-lite",
messages: [
{ role: "user", content: "Explain quantum entanglement in simple terms" },
],
});
console.log(completion.choices[0].message.content);
```
### What comes back
A normal chat completion, shaped exactly like a response from any other model on the gateway:
```json theme={null}
{
"id": "chatcmpl-2bdc138652bb4263a6dffbc8",
"object": "chat.completion",
"model": "benchgen-router-lite",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Quantum entanglement is when two particles become linked so that..."
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 14,
"completion_tokens": 58,
"total_tokens": 72
}
}
```
The `content` is one pool member's real, complete answer, the router adds no summarization, reformatting, or extra generation step on top of it. Note that `model` reports back `benchgen-router-lite` itself, not the pool member that actually answered. To see **which** pool member handled a given batch of queries, run it as a model under evaluation against a benchmark: [Router Fidelity Benchmark](https://benchgen.com/benchmarks/platform/router-fidelity-benchmark)'s results page adds a routing report specifically for this, which pool member (and the real underlying model it resolved to) answered each question, plus the overall routing distribution. For a single call, the request also shows up in [Monitor Model Usage](/docs/eval/monitor-model-usage) like any other.
***
## Cost
You pay the standard rate for whichever pool member actually answers, tracked the same way as calling that model directly, visible in [Monitor Model Usage](/docs/eval/monitor-model-usage). There's no separate fee for the routing step itself. On the 46-question benchmark run above, the router averaged **\$0.000622 per task** against **\$0.001932** for calling its own strongest pool member (`frontier_a`) directly for every question, at higher accuracy, not lower.
## Build your own
The same mechanism, a router head trained with sep-CMA-ES against your own measured reward data, is available to train yourself from the **Train** tab, pick **Head** as the training method. The full walkthrough, with real logs and screenshots, is in [BenchGen Router Lite](/docs/guides/router-head/benchgen-router-lite#2-train-the-router-head) in Guides.
The dataset, training, and complete benchmark story behind this model.
Start a training run of your own.
The live model card: pool, status, API keys, and usage.