Jev Router or your own model router? Where requests go when Jev fails (TypeSafe AI)
The phrase "jev router" is used for several different things: OpenRouter's Jev Router (a chat endpoint that uses Jev to pick another model), LiteLLM's complexity router with Jev as its classifier, open-source routers that call Jev themselves, and an unrelated gateway at jev-router.com. Bing and DuckDuckGo suggest "jev router" when you type "jev r" or "jev routing" (checked 2 Oct 2026). This page compares what OpenRouter documents about its Jev Router with what six self-hosted routers do in their source code. The question is the same for all of them: where does a request go when Jev fails, is unsure, or gets a prompt longer than it can read?
OpenRouter does not document what Jev Router does when Jev fails. Of six self-hosted Jev routers read in source, one sends every Jev failure to its frontier model; five keep, re-score or stop.
The six are LiteLLM's complexity router and the five model routers with the most GitHub stars in a repository search for "jev model router" (313 results on 2 Oct 2026). They were chosen by stars, not sampled, so this is not a count of how Jev routers are usually built. All six are code-backed integrations. The pool ran none of them, and none is independently verified as operating.
Where a request goes when the Jev call fails
A router asks Jev which model should answer. The Jev call fails. What happens next?
- 1. A request arrivesThe router sends Jev the request, or a summary of it, plus the list of models it may choose from.
- 2. The Jev call failsAn HTTP error, a timeout, or an answer the router cannot use (for example a model name that is not on its list).
-
1fallback-frontier model0xNatoshi/jev-codex-router:
gpt-6-astraat medium effort ("Fail-open: any Jev error → astra @medium")1fallback-current modelgargpratyush/jev-router: the session stays on the model it already uses2fallback-local scorer or selectionLiteLLM (its heuristic scorer by default, or an operator-set tier or model); autojev (local selection by preference)1no-decision: no model chosenBillionsBobby/JevRouter returns "no decision"1fail-closed: nothing launchedagent-routerrunexits with an error and launches nothingOpenRouter Jev RouterNot documented in the four OpenRouter documents searched
OpenRouter's Jev Router: what is documented and what is not
Jev Router (typesafe/jev-router) is a chat-completions model on OpenRouter. You send a normal chat request; Jev judges it and OpenRouter forwards it to another model. It does not return Jev decisions. Documented OpenRouter docs read 2 Oct 2026, 05:15–05:16 UTC; prices and IDs from the 05:14 UTC route check
| Item | What OpenRouter says | Status |
|---|---|---|
| How it picks | Jev "reads the conversation and judges the task type, difficulty, and how much a stronger model would help. The router then chooses the cheapest candidate that meets that bar from a curated pool of models." | Documented |
| Which models | A curated pool chosen by OpenRouter. The pool is not listed. For the hardest requests "the router can pair the chosen model with an expert advisor". The response's model field names the model that answered. | Documented; pool members not listed |
| Your control | A jev-router plugin with an include list (models or allowed_models) and an exclude list (excluded_models), up to 1,024 patterns each. The lists "only narrow the router's pool". Unknown plugin keys are rejected with 400. | Documented |
| Edge cases that are documented | An include list that matches nothing "is ignored" and the whole pool is used (reported as list_fallback: "models_ignored"). Exclusions "are never ignored": if they remove every model, "the request fails with 404". Lists can also lower the tier (list_tier_cap) or remove the advisor (max_fallback: "deep"). | Documented |
| Seeing what happened | Send X-OpenRouter-Metadata: enabled. The response then lists resolved_models, "Models the router selected, in fallback order", and the list fields. | Documented |
| Jev error, timeout or malformed answer | Not stated in the Jev Router docs page, the model page and its FAQ, the model's llms.txt, or OpenRouter's full docs export (llms-full.txt, 4.16 MB, searched for Jev failure wording). | Not documented |
| "Fails rather than falls back on invalid Jev output" | Not found in any of those four documents. The claim comes from one third-party blog (seen 28 Sep). | Unverified |
| Long conversations | The router lists a 1,000,000-token context. Jev on OpenRouter lists 32,000. Which part of a long conversation Jev reads is not stated. | Not documented |
| Billing | Model page FAQ: "The pricing shown on this page for Jev Router is zero, so you are not charged for prompt or completion tokens." OpenRouter's models API shows -1 for prompt and completion. How the model that answers is billed is not stated on the pages searched. (The Auto Router page says "You pay the standard rate for whichever model is selected", but that page is about openrouter/auto, not Jev Router.) | Not documented for the routed model |
| Endpoints | Its /endpoints call lists no endpoint (unchanged since 28 Sep). | Documented; meaning not stated |
| Data handling of the routing step | Not covered on the Jev Router page. Labels for the Jev endpoint itself are on data handling by route. | Not documented |
For comparison: OpenRouter Auto (no Jev involved)
openrouter/auto uses "a fast, lightweight classifier" that assigns each prompt one of about 30 task types, then ranks models by spend for that task type within a cost tier. Its page states a fallback: "If classification or rankings are ever unavailable, the router degrades gracefully to a default model set — a request never fails because routing infrastructure hiccuped." The default set is not listed. Price: "You pay the standard rate for whichever model is selected. There is no additional fee for using the Auto Router." Documented 2 Oct 2026, 05:15 UTC
Six self-hosted routers: what each does when Jev fails or is unsure
Open a situation to highlight its column and read what the six do; opening one closes the others. Every cell comes from source at the commit shown. Documented Read 2 Oct 2026, 05:16–05:21 UTC. Timeouts are code defaults.
Jev errors or times outThe HTTP call fails or takes too long
One router sends the request to its frontier tier (0xNatoshi, after 4 s). One keeps the current model (gargpratyush, 3 s deadline). Two pick locally: LiteLLM uses its heuristic scorer by default after 3 s, autojev its own selection after 2 s or 8 s. Two choose no model: BillionsBobby returns "no decision" with a provider_error, and agent-router run exits without launching anything (fail-closed). Decide which of these your budget can live with before you launch.
Jev is unsureLow confidence in the chosen model or tier
Four of six act on confidence: gargpratyush below 0.3 makes no downgrade, BillionsBobby below 0.55 returns no decision, agent-router below 0.75 on consequential tasks asks you to pick, and autojev below 0.5 selects locally. LiteLLM only logs confidence, and 0xNatoshi logs it "without changing other valid choices". How to choose your own threshold: confidence thresholds.
Malformed answerThe answer names no tier, or one the router does not know
Five of six send a malformed answer down the same path as an error: LiteLLM to its fallback, gargpratyush to "keep current", BillionsBobby to "no decision", 0xNatoshi to Astra and autojev to local selection. agent-router's malformed-answer path was not traced.
Long promptMore text than Jev can read in one request
Four routers send the full current ask, task or last message with no length cut (LiteLLM, gargpratyush, BillionsBobby, agent-router). A very long ask can then fail at Jev and take the failure path. 0xNatoshi clips the ask to 400 characters; autojev sends no prompt text at all, only a token estimate and signals. Jev reads 32,000 tokens on OpenRouter; TypeSafe direct allows 64k per request with 32k for state plus the longest question.
| Router (commit) | Where the request goes on failure | Jev unsure | Error or timeout (timeout) | Malformed answer | What reaches Jev; long prompts |
|---|---|---|---|---|---|
LiteLLM complexity router, classifier_type: "jev" (8d28e8d)Code-backed integration in an AI gateway. One Jev Choice over five tiers or operator-defined tiers. Tests: not checkedChecked at LiteLLM 1.104.0 (tag commit 7964577, ): the Jev classifier's failure path is unchanged from 8d28e8d. The tag may predate 8d28e8d on the main branch; their order was not verified. LiteLLM still 1.104.0 on . Documented | fallback-configured tier or local scorerThe llm_v2 capable tier if set; else fallback_tier; else classifier_fallback, default heuristic (LiteLLM's local scorer), or default_model | no-thresholdConfidence is logged only | fallback-configured tier or local scorer after 3 sCircuit breaker on by default (30 s cooldown) | fallback-configured tier or local scorerMissing, unknown or empty tier, or schema error | Full current askPlus system text and earlier user turns up to a character budget. No cut to Jev's limit |
gargpratyush/jev-router (38da6b8)Code-backed integration: Claude Code proxy choosing haiku, sonnet, opus or fable. Tests: yes | fallback-current model: keeps the current modelNo change; never steps up into fable unless asked | fallback-current model: < 0.3, no downgradeUpgrades capped at sonnet, or the current tier if higher | fallback-current model: keep current1.5 s per attempt, 1 retry, 3 s deadline | fallback-current model: keep currentUnknown tier | Last user messageSystem reminders stripped; plus current model and a context-size estimate. No cut |
BillionsBobby/JevRouter (e11084c)Code-backed integration: routes to models, tools and subagents from capability manifests. Tests: yes | no-decisionNothing selected; the caller must choose | no-decision: < 0.55min_confidence default | no-decision15 s (TypeSafe) or 20 s (OpenRouter Decisions); provider_error attached | no-decisionUnknown capability, missing probabilities or bad confidence | Request, actor, contextNo cut |
0xNatoshi/jev-codex-router (8701ef7)Code-backed integration for Codex: tiers gpt-5.6-luna, gpt-5.6-sol, gpt-6-astra. Tests: yesA model router for Codex, kept here. Guards that check what a coding agent does are on coding agents. | fallback-frontier model: gpt-6-astra, medium effortThe router's frontier tier. Also Astra when no key is set | no-threshold: ignoredConfidence "is logged without changing other valid choices" | fallback-frontier model: Astra after 4 sAny exception | fallback-frontier model: AstraParsing raises; same branch | Clipped to 400 charactersLast user text, head and tail, plus bounded signals. The thread never reaches Jev |
nidhi-singh02/agent-router (fb24d06)Code-backed integration: command-line tool that picks the agent tool, model and effort. Tests: yes | fail-closed: run exits, nothing launched"TypeSafe could not select a route". effort: no change | held: < 0.75 and consequential, you pickAsks you to choose one of the top two | fail-closed: exit with errorSDK default timeout (not set in code) | not recorded: not traced | Task textNo cut. Refuses to send text that looks like a credential |
thinkany-ai/autojev (d5d5731)Code-backed integration: desktop gateway; preference balanced, cost, quality or speed. Tests: some | fallback-local selectionBy heuristic tier and preference (cost → cheapest capable; quality → strong tier) | fallback-local selection: < 0.5 | fallback-local selection2 s (balanced) or 8 s | fallback-local selectionInvalid candidate | No prompt textToken estimate, tool and vision flags, a local complexity score and the candidate list with costs |
- fail-closed or held (a person or the host's own prompt decides)
- fallback-<what> (named in the cell)
- no-decision: nothing returned; the caller must handle it
- not recorded, not applicable or no-threshold (the cell says which)
Colours follow the shared legend on when Jev fails (changed ; this page used its own colours before). The "What reaches Jev" column describes input, not a verdict, so it is uncoloured; the tally below uses the same colours (dashed white: no-threshold).
What decides, what you can override, and what it costs
| Router | What Jev is asked; candidates | Your override | Cost basis |
|---|---|---|---|
| LiteLLM | One Choice "tier" over five tiers (non-reasoning, simple, medium, complex, reasoning) or tiers you define; you set each tier's models | Operator configuration | The Jev call, priced from LiteLLM's model registry, plus the routed model |
| gargpratyush | One Choice "model" over the account's tiers plus three Scores | Phrases such as "use opus" or "switch to haiku" in the prompt | The Jev call plus the Claude model; no downgrade above 20,000 context tokens, to avoid rebuilding the cache |
| BillionsBobby | One Choice over capability manifests (optionally in two stages), such as model.claude-sonnet | Policy filters, permissions, requires_confirmation | One or two Jev calls per route |
| 0xNatoshi | A capability tier, thinking depth and a route lease; code forces Astra for some review and architecture cases | A kill-switch file sends everything to Astra without asking Jev; shadow mode serves Astra | The Jev call plus the routed model; leases reuse one decision to skip a paid Jev call |
| agent-router | Six questions (family, phase, complexity, creativity, consequence, cache value), then a ranker over account and model candidates | You choose when asked | The Jev call plus the launched agent; cost and quota rechecked before launch |
| autojev | One Choice over eligible model IDs | An explicit model request is kept | Estimated per request; models with unknown prices are used only as a fallback |
What the six rows add up to
Six routers read in source, one chip each
- Jev errors or times outwhere the request goes
- fallback-frontier model0xNatoshi
- fallback-current modelgargpratyush
- fallback-tier or local scorerLiteLLM
- fallback-local selectionautojev
- no-decisionBillionsBobby
- fail-closedagent-router
- Jev is unsuredoes the router use confidence?
- Gate 0.3: fallback-current modelgargpratyush
- Gate 0.55: no-decisionBillionsBobby
- Gate 0.75: heldagent-router
- Gate 0.5: fallback-local selectionautojev
- no-threshold: logged onlyLiteLLM
- no-threshold: logged only0xNatoshi
- What reaches Jevlength of the prompt text
- Full, no cutLiteLLM
- Full, no cutgargpratyush
- Full, no cutBillionsBobby
- Full, no cutagent-router
- 400 characters0xNatoshi
- No textautojev
- OpenRouter Jev Routerfor comparison
- On failurenot documented
- When unsurenot documented
- Long conversationsnot documented
How long each router waits for Jev before taking its failure path
Pick … if
| Pick | If | Watch out for |
|---|---|---|
| OpenRouter Jev Router | You already use OpenRouter, want no code, and can accept that OpenRouter chooses the pool | Failure, low-confidence and long-context behaviour are not documented; how the routed model is billed is not documented. Use excluded_models for models you must never pay for: an exclusion that empties the pool returns 404, it does not fall back |
| OpenRouter Auto | You want a stated fallback that never fails the request, and standard per-model pricing | No Jev involved; the default fallback set is not listed |
| LiteLLM complexity router with Jev | You run LiteLLM and want your own tier pools | Set fallback_tier or classifier_fallback: default_model if you need a known destination on failure. Confidence is not used, so add your own gate |
| A router that keeps the current model (gargpratyush) | Your sessions start on a model you are happy to pay for | A failure means no saving, not a surprise upgrade; a session that started on Opus stays on Opus |
| A router that returns "no decision" (BillionsBobby, agent-router) | You must never change models without knowing | Your code must handle the empty result |
| A router that falls back to its frontier tier (0xNatoshi) | Quality matters more than cost when Jev fails | Every Jev outage or timeout bills the frontier model. Check its timeout (4 s) and log each fallback |
| A router that sends no prompt text (autojev) | You do not want prompt text sent to TypeSafe | Jev judges from a local complexity score and signals, not from the request itself |
| Any of them, with long conversations | Your asks can be very long | Only 0xNatoshi clips (400 characters) and only autojev sends no text. The other four send the full ask, so a very long one can fail at Jev and take the failure path |
To compare the cost of a Jev call with your current routing model, use the cost per decision worksheet. Route prices, context and IDs for Jev itself are on where to use Jev.
Seven rules for routing with Jev, and which routers follow them
- Decide the failure destination before launch.BillionsBobbyagent-routergargpratyushLiteLLM: set it
A fixed default you can afford, "keep current", or an error to the caller. Write it in configuration, not in a code comment. The same rule for ticket queues is on support-ticket triage.
- Never let a failure pick your top tier without a log line and a counter.0xNatoshi: Astra on any error
One of the six routers read does this by design.
- Gate on confidence.gargpratyushBillionsBobbyagent-routerautojevLiteLLM, 0xNatoshi: logged only
Set the threshold from your own traffic (procedure).
- Cut or summarise long prompts before Jev sees them.0xNatoshi: 400 charsautojev: no textFour: no cut
Jev reads 32k tokens for state plus the longest question (64k per request) on TypeSafe direct, and 32k on OpenRouter.
- Keep the Jev timeout shorter than the routed call's latency budget.1.5–20 sagent-router: not set
The six use 1.5 s per attempt up to 20 s. Rate limits and retry advice: errors and rate limits.
- Exclude, do not only include.Jev Router
On OpenRouter Jev Router an include list that matches nothing is ignored; an exclusion is never ignored.
- Log which model answered.All
Jev Router's
modelfield and router metadata, or your router's own log, so failures show up in cost reports.
What a router sends to TypeSafe is personal data if your prompts are: see what data leaves your system, by route. The rules are a design reading of the source above, not a measured result.
A related pattern: check first, upgrade only on failure
OpenRouter's cookbook "Cut LLM Cost with a Jev-Verified Cascade" lets a cheap model draft an answer, asks Jev whether the draft is supported (accept at confidence 0.8 or more), and calls the frontier model only when the check fails. In the example code an unknown Jev label throws and nothing catches it, so a Jev failure reaches the caller as an error rather than a silent upgrade. Documented vendor example. Its 50-question result is OpenRouter's own claim. Reported
Is there a test of Jev as a router?
- B05, LiteLLM: 80 routing prompts written and labelled by the same author; grade C, with a conflict of interest because LiteLLM ships Jev as a router option. See benchmarks, row B05. Reported
- Speed and cost claims by MindStudio and OpenRouter are vendor claims (Reported). None of them measures what happens when the router is wrong or Jev fails.
- Lead, not read:
feD0s/jev-router-bench(created 1 Oct; an intent-routing experiment in Russian). Unverified
Routing videos, linked but not watched for this page: Cole Medin, routing at 10:42; Omar Kamal, 54-rule routing at 6:18; LangChain and TypeSafe, routing at 19:57; "Build a Real AI Model Router"; a video on OpenRouter and Jev routing; "Jev and Herdr … Route Models". More in the routing videos group.
Same name, different things
- OpenRouter Jev Router (
typesafe/jev-router): OpenRouter's chat endpoint that uses Jev to pick another model. It does not return Jev decisions. jev-router.com: an independent gateway for open models. It does not serve TypeSafe's Jev (checked 28 Sep).- Repositories named
jev-router: unrelated projects share the name, for examplegargpratyush/jev-router,prismhq/jev-router,rajdhakad9826/jev-router,dirien/jev-routerandForestMars/Jev-router. A repository name says nothing about OpenRouter.
How the six were chosen
LiteLLM's complexity router was named in the research plan in advance: LiteLLM, an AI gateway, offers Jev as a classifier for this router. The other five are the model routers with the most stars in a GitHub repository search for "jev model router" on 2 Oct 2026 (313 results; an index count, not adoption): gargpratyush/jev-router (518 stars), BillionsBobby/JevRouter (343), 0xNatoshi/jev-codex-router (276), nidhi-singh02/agent-router (100) and thinkany-ai/autojev (74). Two higher results were skipped: kerpopule/hermes-jev-skills (991 stars, a broader skill suite, not read for time) and angel291592/Intent-Router (intent compilation, not model choice). Each was pinned to one commit and read from source; nothing was installed or run and no Jev call was made. Routers found earlier and nine routing repositories created on 1–2 Oct stay leads.
What was not verified
- What OpenRouter's Jev Router does on a Jev error, timeout, malformed answer or over-long conversation, and how it bills the model that answers. Only OpenRouter can answer this.
- Whether "fails rather than falls back" is true, and which models are in Jev Router's pool.
- How any of the six routers behaves live: none was run.
- LiteLLM's published docs page for the Jev classifier (not located; its configuration field descriptions were read instead).
- agent-router's malformed-answer path.
- How many people use any of these routers.
Sources and check times (2 Oct 2026, UTC)
- OpenRouter (05:15–05:16): Jev Router docs; model page and FAQ and its llms.txt; Auto Router docs; router metadata; full docs export (searched, includes the cascade cookbook, 05:16); Jev Router endpoints and Jev 1.13 endpoints (05:14).
- LiteLLM at 8d28e8d:
jev_classifier.py,complexity_router.pyL2157–2294,config.py(05:16). - Recheck 6 Oct 2026, 05:19–05:29 UTC (R9-S100, R9-S101): LiteLLM tag v1.104.0 = 7964577;
jev_classifier.pydiffers only in comments;complexity_router.pyfailure block byte-identical (8d28e8d L2157–2295 = v1.104.0 L2121–2259). - Registry recheck 7 Oct 2026, 05:21 UTC (R10-S48): litellm 1.104.0 is still the latest PyPI release.
- gargpratyush/jev-router at 38da6b8:
src/router.mjs,policy.mjs,config.mjs,proxy.mjs(05:18). - BillionsBobby/JevRouter at e11084c:
src/router.ts,src/provider.ts(05:18). - 0xNatoshi/jev-codex-router at 8701ef7:
server/jev_server.pyL1–60, L563–578, L1892–1915;server/routing_policy.py(05:18). - nidhi-singh02/agent-router at fb24d06:
decision-engine.ts,typesafe-client.ts,fallback.ts,commands/run.tsL352–375,commands/effort.tsL258–270 (05:18). - thinkany-ai/autojev at d5d5731:
src-tauri/src/router.rsL240–300, L486–511, L640–760 (05:18). - Selection: GitHub repository search "jev model router", sorted by stars (05:18). Query wording: Bing and DuckDuckGo autocomplete (05:15).