All resources
Model Intelligence12 min read

Jev Router explained: the decision layer between a prompt and a model.

Jev Router does not write the answer. It makes a typed decision about the work first, then sends the request to a model that fits the task, budget, and preferences.

Most model APIs make the developer choose a model before the request starts. That is predictable, but it also means the same expensive model handles “summarize this paragraph” and “debug a distributed systems failure.” Jev Router puts a decision layer in front of that call: first estimate what the request needs, then select an appropriate model and reasoning effort.

What Jev Router is, and what it is not

Jev is TypeSafe's structured decision model and the first model in its System One category. It is designed to return a typed decision rather than a stream of prose. OpenRouter'stypesafe/jev-routeruses that decision to choose a model and reasoning effort for each request.

The distinction matters: Jev Router decides; the selected language model generates the answer. Jev is not a replacement for the model that writes code, explains a document, or returns a final response. It is a controller for deciding how much capability that response deserves.

The useful mental model

Treat Jev as a typed function call: structured state and a question go in; a choice, score, or yes/no probability comes out. Your application can then branch on that result without asking a chat model to emit JSON that you hope will parse correctly.

The routing loop

OpenRouter describes the router as a policy decision with several inputs: Jev assesses the conversation and task difficulty, then the router combines that signal with the selected cost tier, available model capabilities, model preferences, and reasoning-effort settings. The chosen model receives the original request and produces the response.

  1. 1Read the request and the conversation state, including the context available to the model.
  2. 2Estimate the task’s difficulty and whether a stronger model or deeper reasoning is likely to help.
  3. 3Apply your routing policy: cost tier, preferred or excluded models, capabilities, and effort.
  4. 4Forward the request to the selected model, which remains responsible for the generated answer.
  5. 5Inspect the route in observability data and compare quality, latency, and spend against a fixed-model baseline.

Why typed decisions are the important part

TypeSafe exposes primitives for different kinds of decisions. Achoiceselects an option and returns probabilities and confidence;scoreevaluates a state against a rubric; andnoulanswers whether a statement is true with a value from zero to one. Newer Jev versions add a fourth,box, which locates an object inside an image and returns its edges as fractions of the frame, so the state can carry image parts alongside text. Those shapes are closer to application control flow than to a paragraph that needs post-processing.

For routing, the natural question is categorical: which model or tier should handle this request? The probability distribution is useful for a second decision too. A low-confidence route can be escalated, logged for review, or sent through a conservative fallback policy rather than being treated as certainty.

Where it earns its place

A router is most useful when traffic contains genuinely different workloads. Short transformations, extraction, and routine support questions do not always need a frontier model. Long code changes, ambiguous planning, tool-heavy tasks, and high-stakes explanations may justify more capability or reasoning time. The router gives one application a way to express that policy without hard-coding a single model forever.

The same pattern applies beyond chat. Jev can act as a gate before retrieval, a selector between indexes, a “continue searching?” check, or a lightweight controller in an agent loop. The value is not that the decision is magical; it is that the decision is explicit, typed, and available before the expensive generation step.

Jev is not alone: the decision-model category

Jev did not stay a single product for long. TypeSafe called its new class “System One models”; the market settled on a plainer label,decision models. Within weeks of the September 2026 launch, cloud providers, labs, and independent developers released models with the same contract — a state in, typed decisions and probabilities out — and several of them ship a Jev-compatible endpoint so a routing integration can swap the decision maker without rewriting application code.

The range now spans hosted APIs, open weights you can self-host, and small encoder models that run on a CPU. They differ in size, modality, license, and where they run, but they answer the same routing question the router asks: how much capability does this request actually deserve?

ModelMakerShapeInputsWhere it runs
JevTypeSafeSize not disclosed; text and imagesText, imagesHosted; the reference decision model
Clef / Clef-flashCloudflare27B / 9B on QwenText, imagesWorkers AI plus Apache-2.0 weights
pplx-deciderPerplexity27B / 4BText, imagesHosted API; Apache-2.0 weights
Decisions APIOpenAINot disclosed (gpt-6-luna)Text, imagesHosted, its own schema
d1 / d1-omniLiquid AI3.1B and 587M openText, images, audioHosted plus open weights
Standard OneStandard Thinking3B / 8BText, imagesHosted plus open weights
Strands DeciderAWS Strands Labs~1.9B on QwenTextLocal; open recipe and data
KevOpen source0.8B to 27B on QwenTextLocal; Jev-compatible, 24 GB GPU
LayaConvai Innovations322M / 421M encoderTextCPU; ModernBERT, Apache-2.0
GLiNER2.5-DecideFastino340M encoderTextCPU; Apache-2.0
Decider familyMapika0.8B to 35B-A3BText, images (2B)Local; Apache-2.0
Tev1Together AI4B on QwenTextA training recipe you can reproduce

Sizes, licenses, and availability reflect vendor documentation at publication time. Most accuracy and latency figures for these models are vendor-run and are not directly comparable across providers, so treat the table as a map of the options rather than a ranking. Benchmark on your own labeled data before moving a production route.

How decision models differ from classic routers

Routing statistics are not new. Open-source RouteLLM and hosted services like NotDiamond and Martian have long trained classifiers to pick between a cheap and a strong model. Those systems answer one narrow question — “is this request hard enough to escalate?” — usually with embeddings and preference data, and they optimize for cost at a target quality.

A decision model generalizes that idea. Instead of a single gate, it answers any typed question the application defines: which queue, which index, is this a refund request, should the agent keep searching. It returns calibrated probabilities rather than one yes/no, and it does not generate text, so a valid answer can never fall outside the options you supplied. A router decides where a request goes; a decision model can decide what the software should do next.

The trade-offs teams should measure

Quality

Compare route-by-route success with a fixed strong model. A cheaper route is not a saving if it creates retries or human review.

Latency

The decision is an extra stage. Measure end-to-end time, not only Jev’s decision time, including fallback and queue effects.

Cost

Track router calls, selected-model spend, retries, and escalation rates together. Average token price hides policy behavior.

Stability

Models, availability, pricing, and router policies change. Pin preferences where possible and keep a fallback for unavailable routes.

A sensible rollout

Start in shadow mode. Let Jev make a route recommendation while the production request still uses your current model. Store the request class, selected route, confidence or decision metadata, latency, cost, and an outcome signal. Once the baseline is large enough, enable routing for a low-risk slice and compare it with the control group.

Keep a fixed-model escape hatch. The router should be allowed to fail closed or fall back when a preferred model is unavailable, the task is outside your supported modalities, or the route policy cannot justify a cheap answer. For high-impact workflows, human review and an explicit allowlist are still stronger controls than a confidence number.

The bottom line

Jev Router is interesting because it treats model selection as a first-class software decision. It does not make every task cheaper, and it does not guarantee that the chosen model is right. Its promise is narrower and more useful: when an application serves mixed workloads, a structured decision layer can make capability, cost, and reasoning effort part of the same controllable policy.

The wider decision-model category reinforces the point. When the same typed contract is available as a hosted API, an open weight, or a 340-million-parameter encoder on a CPU, the routing decision stops being a matter of which vendor you picked and becomes a design choice you can own: what question is the software actually asking, and where should the answer come from.