Auto reads each request — its task, its difficulty, what it needs — and sends it to the best model your plan allows. No more guessing. Watch it decide, live.
Claude Opus 4.6 
GPT-5.4 
Gemini 3 Pro 
DeepSeek V4 
Qwen 3.7 Plus Live · real routing engine · answers capped for the demo
The pipeline
Four stages, in order — cheap deterministic checks first, a learned classifier second, a scoring pass last. The same sequence you just watched run.
A small model reads the request and names the kind of work it is — one of fourteen task types — plus how demanding this particular instance is. It never names a model, which is why the shelf can change weekly without retraining anything.
Anything that cannot serve the request is removed outright: no tool support, wrong input modality, not enough context for the prompt, or not on your plan. Entitlement is applied here, so a locked model is never a candidate at all.
Survivors are ranked on four normalised axes, weighted by the preset you chose. Each task carries a capability floor and each plan a cost ceiling, so economy mode cannot under-serve hard work and quality mode cannot quietly overspend.
The top model answers. The next two are held as a fallback chain, so a provider error or a context overflow walks down the ranking instead of failing the request.
Entitlement
Entitlement is a hard filter, not a preference — a locked model never enters the pool, so no preset or weight can surface it. Here is how deep each plan reaches into the shelf right now.
Measured live against 310 routable models · updates as the shelf changes
Getting started
Two ways to pay for the models the router picks, and one place to control everything it's allowed to do.
Route on the ScholarXIV plan you already pay for. Nothing to set up — create an API key and start sending requests.
Add a Vercel AI Gateway key and you pay the provider directly. Our plan tiers stop limiting the pool — the router picks from everything your key can reach.
Named policies you assign per API key, so one account can run separate tiers of your own product through the same router.
Exact ids or wildcards like anthropic/*. A request can narrow this list but never reach outside it.
Quality, balanced or economy — the default weighting each key routes under, overridable per request.
A hard per-request spend cap, so a long prompt can never quietly buy a frontier answer.
Volume, estimated spend, routing latency, model mix and recent decisions — broken down per API key.
From the developer dashboard. The same key works across the Papers API, MCP and the router.
Stay on your subscription, or paste a gateway key — it is verified before it is stored, then encrypted.
Set the models, preset and cost ceiling it may use, then send your first request to /api/v1/router.
How it compares
The routing space is crowded. This is where ours differs by design — capability for capability, against the routers developers reach for today.
| ScholarXIV | OpenRouter | Not Diamond | RouteLLM | Fixed model | |
|---|---|---|---|---|---|
| Per-request model selection | ● | ● | ● | ● | · |
| Plan-aware candidate pool | ● | ◐ | · | · | · |
| Decide-only endpoint | ● | · | ● | ● | · |
| OpenAI-compatible execute | ● | ● | ◐ | ● | ● |
| Visible decision trace | ● | · | ◐ | ◐ | · |
| Per-request cost ceiling | ● | ◐ | · | · | · |
| Feedback-driven ranking | ● | ● | ● | ◐ | · |
| Self-host the engine | ◐ | · | · | ● | · |
● full ◐ partial · none
Published routers report real gains — RouteLLM cites up to 85% lower cost at ~95% GPT-4 quality, Cursor’s router frontier quality at ~60% lower cost. We haven’t run a head-to-head yet, so we aren’t claiming one.
Every routed request already logs its decision and its outcome. Those become our numbers.
The API
The same engine, over HTTP. Decide only and run the model yourself, or route and run in one OpenAI-compatible call. Pass your own model pool; we just make the choice.
Decide only. Returns a model and its fallbacks; you make the call yourself.
const r = await fetch('/api/v1/router', {method: 'POST',headers: { 'x-api-key': KEY },body: JSON.stringify({ prompt, preset: 'balanced' })});const { model, fallbacks, task } = await r.json();
Decide and run, OpenAI-compatible. Set model to "auto" and change nothing else.
const r = await fetch('/api/v1/router/chat/completions', {method: 'POST',headers: { 'x-api-key': KEY },body: JSON.stringify({ model: 'auto', messages })});// response.model is what actually answered
Score a decision. Turns estimated rankings into measured ones.
await fetch('/api/v1/router/feedback', {method: 'POST',headers: { 'x-api-key': KEY },body: JSON.stringify({ decision_id, feedback: 'positive' })});
Route on your subscription or your own AI Gateway key, set which models each API key may reach, and watch volume, spend and latency per key.
Auto is already the default for new chats. Open one and start typing — the router takes it from there.
