BenchGen Router Lite

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

This page covers how to call it. For the complete story, the dataset, training, and full benchmark breakdown, see 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.

Diagram of one query moving through BenchGen Router Lite: the frozen backbone embeds it, the router head picks one pool member, and only that model's real reply is returned — One query moving through BenchGen Router Lite: the frozen backbone embeds it, the head picks one pool member, and only that model's real reply comes back

The pool it currently routes between (see the model’s own card 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, 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.

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"}
    ]
  }'

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)

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:

{
  "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’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 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. 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 in Guides.