What is the Auto Router?

A model name you define (for example cognocient-auto). When a request uses it, Cognocient classifies the request as simple, medium, complex or reasoning, and forwards it to the model you assigned to that tier. Your code never changes per call.

Does classification add latency or cost?

No. The classifier is a deterministic heuristic that runs inside the proxy — it makes no LLM call, so it adds no provider cost and effectively no latency. The same request always routes the same way.

How do I see why a request was routed where it was?

Every routed response carries x-cog-auto-router (the tier), x-cog-auto-model (the model used) and x-cog-auto-reason (the signals that decided it). You can also test any prompt from the Auto Router page without sending it to a provider.

Can I force a request onto the strongest model?

Yes. Send X-Cost-Priority: high and the request is pinned to the Complex tier, bypassing classification.

How are savings calculated?

For each routed call, Cognocient compares the actual cost with what the same tokens would have cost on the most expensive model in your router, and records the difference. The Auto Router page totals it over 30 days.

Which plans include it?

The Auto Router is available on Growth and above.

How does the Cognocient Auto Router work?

Send one model name and let Cognocient route each request to the right-sized model by complexity. A deterministic classifier with zero added latency, per-request explanations, and measured savings.

The Auto Router lets you send one model name and have Cognocient pick the right-sized model for each request. Easy requests go to a cheap, fast model; hard ones go to your strongest model. You configure the mapping once in Auto Router (sidebar → Control).

Set it up

Open Auto Router, choose the model name your callers will send (default cognocient-auto), and assign a model to each tier:

Tier	Typical requests	Example model
Simple	Short lookups, classification, formatting	`claude-haiku-4-5`
Medium	Summaries, drafting, long context, light tool use	`claude-sonnet-4-6`
Complex	Code, debugging, multi-part analysis	`claude-opus-4-6`
Reasoning (optional)	Proofs, math, step-by-step logic	`o3` — falls back to Complex if unset

Send the router's name as model:

from openai import OpenAI
 
client = OpenAI(base_url="https://api.cognocient.com/v1", api_key="<your proxy key>")
 
resp = client.chat.completions.create(
    model="cognocient-auto",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

Tiers can mix providers — Haiku for Simple and GPT for Complex works, as long as each model has a provider key in Settings.

How requests are classified

The classifier scores each request from signals in the conversation. It is deterministic and runs inside the proxy — no extra LLM call.

Signal	Effect
Context length (~200 / 1,000 / 4,000+ tokens)	Raises the score
Code blocks or stack traces	Raises the score
Big-task wording (refactor, architect, design a schema/system, security review…)	Strongly raises the score — enough alone for Complex
Analytical wording (analyze, debug, implement, evaluate, trade-offs…)	Raises the score — enough alone for Medium
Multi-part request (3+ questions or numbered items)	Raises the score
Long conversation (10+ messages)	Raises the score
Tools available / mid tool-use loop	Raises the score
Structured output requested (`response_format`)	Raises the score
Strong reasoning cues (prove, derive, theorem, differential equation…)	One is enough → Reasoning
Lighter reasoning cues (step by step, solve, probability, math notation…)	Need to stack — two → Reasoning
Short factual phrasing ("What is…", "Translate…")	Lowers the score and suppresses reasoning cues (a definition is not a proof)
`reasoning_effort` set above low	→ Reasoning

Low scores route to Simple, mid scores to Medium, high scores to Complex.

Keyword overrides

Add rules like contains "contract" → Reasoning to force a tier whenever the conversation (system prompt included) contains the text. The first match wins and overrides the classifier — useful for workloads where you know difficulty regardless of phrasing.

See why a request was routed

Every auto-routed response includes:

Header	Meaning
`x-cog-auto-router`	The tier chosen
`x-cog-auto-model`	The real model used
`x-cog-auto-reason`	The signals that decided it
`x-cog-routed`	`true`

The Try it panel on the Auto Router page classifies any prompt using your current (even unsaved) settings without calling a provider or billing anything.

Pin a request to the strongest model

Send X-Cost-Priority: high and the request goes to the Complex tier regardless of classification.

Savings

For each routed call Cognocient records the tier and the estimated saving versus sending the same tokens to the most expensive model in your router. The Auto Router page shows the 30-day total and a per-tier breakdown. Because it is measured against your own strongest model, it reflects what you would otherwise have paid.

How it fits with everything else

Budgets and caching see the real model, not the router name — budget estimates and cache keys use the model that actually serves the request. Content guardrails run first, before routing, so classification sees already-redacted text.
Routing Rules do not apply to auto-routed requests (choosing the router is the routing decision). Requests to real model names still go through your rules as before.
Streaming and tool calls work normally on every tier.
Failover still applies to the chosen model if you have provider failover enabled.

What it doesn't do (yet)

The classifier is heuristic, not learned: it can misjudge an unusually phrased request, which is why every decision is explainable and overridable. There is also no mid-task escalation — each request is classified independently.