TypeSafe Jev Router picks model, reasoning and cache per request – what the 237-task result really means

Updated October 9, 2026. typesafe/jev-router is a hosted model router on OpenRouter. It is not the model that writes the final response. Instead, it uses TypeSafe’s Jev decision model to choose a generative model and a reasoning-effort level for the request. OpenRouter lists a 1,000,000-token context window, multimodal input and a September 25, 2026 release date for the router. ¹²

The more unusual part is how it treats an ongoing conversation. OpenRouter says Jev Router tries to keep a model that is already working, can change reasoning effort without necessarily changing the model, and switches models only when the estimated gain outweighs the cost, taking into account the cached conversation that a switch may throw away. ³⁴

Jev Router is a practical option for applications that want automatic model and reasoning selection without building their own routing policy. Its strongest public performance result is still a platform-reported launch benchmark, so production adoption should be preceded by workload-specific evaluation.

Jev Router at a glance

Field	checked Oct. 8, 2026
OpenRouter model ID	typesafe/jev-router
Provider	TypeSafe / OpenRouter
Product type	hosted Jev-powered model + reasoning router
Released	September 25, 2026
Context advertised by OpenRouter	up to 1,000,000 tokens; serving-model dependent
Input modalities	text, images, files/PDFs, audio, video
Output	text
Jev itself	text-input decision model, not a chat LLM
Router listing price	$0 prompt / $0 completion on the model page
Switching policy	cache-aware; OpenRouter says expected gain must justify switch cost
ZDR	OpenRouter says the Jev step operates under ZDR and zdr: true works
Launch benchmark	237/423 tasks vs 130/423 for OpenRouter Auto Router; platform-reported

Sources: ¹³³

Jev Router is not Jev 1.13 with a chat endpoint

That distinction matters. TypeSafe’s direct Jev product is a System One decision model. Its public API evaluates a state against typed questions and returns bounded answers with probabilities. The three documented primitives are Choice, Score and Noul. It does not generate prose, code or chat responses. ⁵

Jev Router wraps that decision capability around a conventional generation workflow. OpenRouter exposes a normal model-like identifier, typesafe/jev-router; the router makes a model-selection decision, then the selected downstream model produces the text response. ¹²

TypeSafe itself lists model routing as a natural Jev use case: classify intent or domain, estimate difficulty or risk, and escalate a request when a more capable model is justified. ⁶

What does the hosted router score?

OpenRouter’s launch description says Jev reads the conversation text before a turn and scores factors including task difficulty, required precision, whether a larger model or more reasoning would help, whether a cheaper model is sufficient, and whether the task has changed. ³

The policy then adds session economics. A simplified interpretation of the published behavior is:

1. Evaluate the new turn.
2. Keep the current model if it remains a good fit.
3. Increase or decrease reasoning effort without switching when possible.
4. Switch models only when the expected quality gain is greater than the switching cost, including lost cached context. ³

That fourth step is what makes the router more than a basic intent classifier. Long agent sessions may contain large repeated prefixes: system instructions, tools, repository context and earlier turns. Prompt caching can reduce the cost of repeatedly processing that prefix, and OpenRouter separately documents sticky provider routing to improve cache reuse. ⁷

Jev Router: current controls, limits and actual billing

Updated October 8, 2026. OpenRouter’s current Jev Router specification distinguishes target-model selection, reasoning effort, and a separate cost policy. Plain typesafe/jev-router needs no plugin; optional routing controls work as follows:

{
  "model":"typesafe/jev-router",
  "plugins":[{"id":"jev-router","cost_tier":"low","models":["anthropic/*","google/*"],"excluded_models":["anthropic/claude-opus*"]}],
  "reasoning":{"effort":"low"},
  "messages":[{"role":"user","content":"Review this patch."}]
}

• cost_tier (low, medium, high) is a cost/capability preference, not a spending cap and not reasoning effort. reasoning.effort is only a hint.
• models / allowed_models are not strict allowlists: unmatched inclusions are ignored. excluded_models exclusions are enforced; an empty eligible set returns HTTP 404. Unsupported reasoning controls (reasoning.max_tokens, reasoning.mode: "pro") and invalid plugin fields yield HTTP 400.
• The response model is the selected serving model. Enable X-OpenRouter-Metadata: enabled and inspect openrouter_metadata.pipeline, resolved_models, candidates, reason and advisor_model. estimated_cost is not final billing. Some agent tasks can involve an expert advisor.
• Context: The advertised 1,000,000 tokens is only a maximum. The chosen downstream model determines the actual context window; no universal 1M guarantee exists. Model-page FAQ
• Pricing: Jev Router has no fixed fee of its own. Each request is billed at the selected generative model’s rate. Illustration, not a guaranteed Jev route: 1M input at $0.50/M plus 100,000 output at $2.00/M costs $0.70 before extras.
• Privacy and region: OpenRouter says Jev itself uses ZDR; separately verify the serving provider. The router supports only the global data region, not HIPAA workspaces. ZDR does not mean EU-only processing.

OpenRouter’s October 2, 2026 router benchmarks are further platform-run tests, not independent reproduction of the 237-vs-130 launch task result.

Jev Router vs OpenRouter Auto Router

OpenRouter’s updated openrouter/auto uses a different signal. The August 2026 design is informed by more than 55 trillion tokens of weekly spend, according to OpenRouter. It classifies requests, looks at how the community allocates spend for similar task types over the trailing seven days, and selects from a cost tier. ⁸

Jev Router instead evaluates the current request with Jev and explicitly includes difficulty, reasoning effort and cache-aware switching in the published policy. ³

Dimension	Jev Router	OpenRouter Auto Router
ID	typesafe/jev-router	openrouter/auto
Main routing signal	Jev evaluation of the current conversation turn	task category + aggregate OpenRouter spend patterns
Cost control	part of Jev/cache trade-off	explicit cost_tier
Reasoning effort	explicitly selected according to launch description	not described as the central public routing signal
Multi-turn behavior	tries to retain a working model; effort can change separately	retains model while it remains a leading candidate
Cache treatment	switch decision explicitly includes lost-cache cost	sticky routing/session behavior exists, but selection logic differs
Launch comparison	237/423 tasks vs 130/423 for Auto Router	comparator in OpenRouter’s launch claim

Sources: ⁸³

The 237 vs 130 result: useful, but label it correctly

OpenRouter reports that Jev Router solved 237 of 423 tasks across four agent benchmarks, compared with 130 of 423 for its Auto Router. Those counts correspond to roughly 56.0% vs 30.7%, an absolute difference of 25.3 percentage points and a relative increase of 82.3% in tasks solved over the Auto Router count. The percentages here are our calculations from OpenRouter’s published counts. ⁹³

The same launch post says Jev Router had a faster median time to first token than every other router OpenRouter tested across five agent benchmarks. ³

What is missing, as of this research date, is a fully reproducible public Jev Router evaluation package that exposes all 423 tasks, candidate model pools, reasoning settings, prices, route decisions and raw results. The defensible description is therefore OpenRouter-reported launch benchmark, not independently reproduced performance.

Independent research on Jev gives useful caution signals

None of the independent studies below is a direct Jev Router benchmark. They test the decision model underneath the routing concept, which makes them relevant to failure analysis but not a substitute for evaluating the hosted router.

Rao and Callison-Burch compared Jev with three flash-tier LLM judges on nine panels from seven benchmarks. Jev was dramatically cheaper and faster in their aggregate measurements, but the judges often made correlated mistakes. Replaying confidence-based cascades therefore produced limited quality gains over the best single judge in their setup. ¹⁰

Sun and Xu studied the semantics of option labels. In 1,200 workflow decisions, changing how rubrics were attached to semantically loaded option names could substantially alter predictions. Their hosted-model experiment showed the same qualitative problem: type-valid output remained guaranteed while semantic accuracy could degrade. ¹⁰

The JevOut preprint attacks a different axis. It adds short, natural-looking context while keeping the correct answer unchanged and reports that many initially correct Jev decisions can be pushed toward a chosen wrong option. For routing and authorization-like workflows, this is a reminder that structured output is not an injection defense. ¹¹

The practical conclusion is not that Jev routing is unusable. It is that router accuracy should be measured on the exact prompt distribution that will reach production, including adversarial or noisy context where relevant.

Why does the router accept images if Jev is text-only?

TypeSafe documents Jev 1.13 as text-only. OpenRouter simultaneously advertises Jev Router as accepting text, images, files such as PDFs, audio and video. ¹⁵

OpenRouter’s launch explanation provides the missing layer: Jev reads the conversation text for the routing decision, while attachments are not sent to Jev. The downstream model can still receive the multimodal material. ³

The context limits also refer to different layers:

• Direct Jev 1.13: TypeSafe documents a 64K total request budget and a 32K limit for state plus the longest question. ⁵
• Jev Router: OpenRouter lists a 1,000,000-token context window. ¹

So the 1M figure should not be presented as the context window of the Jev classifier itself.

Privacy: ZDR and geographic restrictions

OpenRouter identifies Jev’s decision step as ZDR, but that does not automatically cover the selected response provider. The current Jev Router documentation allows the global data region only, with no HIPAA workspace support. See the updated controls and limitations section above.

Is Jev Router really free?

OpenRouter now states there is no fixed price for Jev Router itself; each request is billed at the selected generative model’s rate. Do not mistake a free-looking router listing for unlimited free inference. See the actual-cost example and metadata guidance above.

OpenRouter API example

OpenRouter exposes the TypeSafe entries through its unified OpenAI-compatible API. ²¹²

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

response = client.chat.completions.create(
    model="typesafe/jev-router",
    messages=[
        {
            "role": "user",
            "content": "Explain why KV-cache continuity matters in a long coding-agent session."
        }
    ],
)

print(response.choices[0].message.content)

For evaluation, log the raw response as well. OpenRouter says Jev Router includes routing metadata explaining its choice, and its UI exposes signals such as task, difficulty, precision and larger-model benefit. The launch material does not provide a stable public JSON contract for every extra metadata field, so production code should not invent or hard-code field names that are not in the API reference. ³

Failure behavior matters

OpenRouter says a Jev timeout or invalid Jev output causes the request to fail instead of silently falling back to a different router. ³

That is a meaningful operational choice. It makes routing failure visible, but it also means Jev Router can add a new availability dependency. High-availability applications should implement their own explicit policy (for example, retry once and then send the request to a pinned known-good model) rather than assuming the router will always degrade gracefully.

What Jev Router means for Mac users

typesafe/jev-router is a cloud endpoint. It is not an MLX checkpoint and it does not run the selected frontier model on Apple Silicon. A MacBook or Mac mini only needs to run the client, agent or development environment that calls OpenRouter.

That changes the performance variables. Unified memory and GPU bandwidth are not the main constraints; network latency, provider selection, prompt length, caching, chosen model and reasoning effort are.

For an Apple-silicon workflow, the useful decision is therefore whether to keep model choice explicit for predictability and local control, or let a cloud routing layer optimize across models dynamically.

Jev Router vs a multi-model system such as Pareto

A router and a blended system should not be grouped together simply because both hide model complexity behind one ID. Jev Router chooses an execution route. Pareto 26.9, by contrast, is presented as a blended system in which multiple LLM outputs contribute to a synthesized answer. The existing Pareto 26.9 source check explains that distinction in more detail.

A pinned model is the third architecture. It sacrifices automatic optimization but improves reproducibility and capability certainty. The existing GPT-6 Sol vs Luna comparison is useful context for why model tier and reasoning-effort choices can materially change cost.

Who should test Jev Router?

The router is most interesting when a workload has:

• a broad distribution of easy and hard requests,
• long multi-turn sessions where prompt-cache continuity has value,
• permission to use multiple model families,
• meaningful reasoning-effort trade-offs,
• and enough observability to audit routing mistakes.

A fixed route may be more appropriate when the application needs a deterministic model family, has narrow compliance allowlists, or faces very high consequences from under-routing. The independent Jev studies also argue against treating a typed decision interface as semantic correctness by construction. ¹⁰¹⁰¹¹

A better way to evaluate the router

A useful evaluation should mirror your traffic rather than use a handful of showcase prompts:

1. Sample 100–500 real, anonymized tasks from the workload.
2. Define pass/fail or graded success criteria before running models.
3. Compare typesafe/jev-router, openrouter/auto and one or two pinned baselines.
4. Store route, reasoning setting, tokens, cache metrics, TTFT, total latency, cost and task outcome.
5. Analyze multi-turn tasks separately, because cache-aware switching is one of Jev Router’s core claims.
6. Label failure modes: underpowered model, unnecessary expensive model, wrong effort, capability mismatch or router failure.
7. Re-run after meaningful router or candidate-model changes.

That produces an answer OpenRouter’s global benchmark cannot provide: whether the router improves your quality-cost-latency frontier.

Production adoption needs workload-specific evaluation

Jev Router is more technically interesting than a generic “auto” alias. OpenRouter combines a fast Jev decision layer with model selection, reasoning-effort control, session stickiness and cache-aware switching behind a single endpoint. The public 1M-context and multimodal interface makes it easy to trial. ¹³

The evidence is still asymmetric. OpenRouter’s 237 vs 130 task count is a strong launch claim, but it remains platform-reported, while independent research on Jev documents robustness limits around labels and surrounding context. ³¹⁰¹¹

The right production question is therefore not “Is Jev Router universally better?” It is: On my traffic, how often does it choose the right model and effort, what does that route actually cost after caching, and how stable is the decision over long sessions? Measure those three before replacing a pinned model policy.

Methodology

Research performed September 26, 2026. Core product specifications were checked against OpenRouter and TypeSafe primary sources. Router benchmark numbers are labeled as platform-reported. Independent Jev studies are used to discuss the decision component’s limitations, not presented as direct reproductions of the hosted router. The references below link to the underlying provider, research and API documentation. Which local runtime fits which workflow is compared in LM Studio vs Ollama.

Verifiable sources by claim

The router is not the model generating the final answer. Router benchmark figures are OpenRouter or launch-reported; independent Jev studies evaluate the decision component rather than the hosted router itself. Production adoption still needs workload-specific pass/fail evaluation.

Footnotes

1. openrouter.ai: source 3 ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶

2. openrouter.ai: source 15 ↩ ↩² ↩³

3. openrouter.ai: source 1 ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³ ↩¹⁴

4. docs.typesafe.ai: source 16 ↩

5. docs.typesafe.ai: source 17 ↩ ↩² ↩³

6. docs.typesafe.ai: source 21 ↩

7. openrouter.ai: source 7 ↩

8. openrouter.ai: source 13 ↩ ↩²

9. systemonemodels.org: source 29 ↩

10. arxiv.org: source 30 ↩ ↩² ↩³ ↩⁴ ↩⁵

11. arxiv.org: source 31 ↩ ↩² ↩³

12. openrouter.ai: source 14 ↩