What Is Jev? TypeSafe's Decision Model Explained for Developers
Kenny Rogers · · Updated
What is Jev? And what should you use it for? It’s TypeSafe’s decision model that takes a passage of text (and, since Jev 1.14, images) plus a typed question, and returns a typed answer that is one of the choices among your predefined set of answers. So if I have a question about ticket routing, like should this ticket go to billing, technical, or account, Jev looks at the text of the ticket and answers with one of the predefined choices, billing. But it’s even cooler than that because it gives you the calibrated probability of the answer choice as well as the probability of each of the other choices. Oh, and there’s also an overall confidence score (more on that later). TypeSafe calls these System One models, and Jev is the first of them.
But what does Jev actually return? Let’s find out! It answers four kinds of question, called primitives, and there are real API responses for each below. Here’s how to read the probabilities without fooling yourself. And here’s how to call Jev with an OpenRouter API key.
What is a decision model (System One model)?
Jev is a decision model. A System One model is one that takes in a piece of state and, given that state, returns a decision. In this case, Jev’s decision is always a typed value you defined in advance, plus an actual probability number from zero up to one. The name comes from what Daniel Kahneman called System One in Thinking, Fast and Slow: fast, pattern-matching thinking, where System Two is slow and deliberate.
So what makes this a decision model and not some oracle? A decision model must return from a small set of values you decided beforehand. There is no free-form text, so nothing you need to parse or worry about hallucination.
Now, TypeSafe calibrated Jev so that when it says 0.8 (an 80% chance), it means that, like an 80% chance of rain, Jev is right about that kind of answer about 80% of the time (System One concepts).
That’s only true when you average across many answers. Any single answer can still be wrong. That makes a practical difference; it’s a point we’ll come back to later.
Jev vs LLM: what each one returns
The difference between Jev and LLMs becomes clear once you understand what both do. Both can read natural language, but the split is entirely on the output side.
Here’s how the two compare side by side:
| Generative LLM | Jev | |
|---|---|---|
| Output | Tokens: prose, code, JSON you asked for | A typed answer plus a probability distribution |
| Shape guaranteed? | Only with structured outputs, and the content can still be wrong | Always one of your options, levels, or a yes/no probability |
| Uncertainty | Hidden inside the prose | Returned as numbers you can threshold on |
| Input | Text, and often images, audio, or video | Text and images (strings, JSON objects, arrays of text and image parts). No audio or video |
| Price on OpenRouter | Varies by model, input and output billed | $0.042 per million input tokens, output free |
Whenever you need words as the main output, for example, a reply, summary, or code patch, reach for an LLM. When you need to make a code-actionable decision, use Jev. In just about every real-world case, the two systems work together: Jev routes and verifies things, while the LLM provides the language. And that’s what the companion post Jev vs LLM: when to use each is all about. It benchmarks that split on 140 support cases and ties the two together in TypeScript.
Jev’s four primitives: Choice, Score, Noul, and Box
Every question you ask Jev is one of four types. A request has two parts: state, the text or images to evaluate, and a questions object containing one or more typed questions. Jev answers all in one pass, each answer returned under the key you gave.
The examples below are real calls I placed on October 16, 2026. They run against typesafe/jev-1.14 through OpenRouter’s Decisions API, and if you set OPENROUTER_API_KEY, you can run the examples as written.
Choice: pick one option from a fixed set
When you get a Choice from the API, it always has three things: the selected option, a probability for every option, and a confidence value.
This command sends the request:
curl https://openrouter.ai/api/alpha/decisions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "typesafe/jev-1.14",
"state": "My invoice for September shows two charges for the Pro plan. I only have one workspace.",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle this ticket?",
"criteria": {
"billing": "Charges, invoices, and refunds",
"technical": "Bugs, outages, and broken features",
"account": "Login, password, and profile changes"
}
}
}
}'This response shows what the API returned:
{
"model": "typesafe/jev-1.14-20261014",
"answers": {
"team": {
"type": "choice",
"choice": "billing",
"probabilities": {
"billing": 1,
"technical": 0,
"account": 0
},
"confidence": 1
}
},
"usage": {
"input_tokens": 357,
"output_tokens": 38,
"cost": 1.4994e-05
},
"id": "gen-dec-1792170400-UBIaakN5nEoW6gLSGZGD",
"provider": "TypeSafe"
}Jev reads the criteria descriptions before making a choice, so write them as you would brief a new hire. TypeSafe’s API reference says the question id (team here) is never sent to the model. All the meaning has to be in the descriptions. Second, the model field names the exact snapshot OpenRouter served.
Score: rate on ordered levels you describe
Score takes an ordered array of level descriptions. It returns a number representing the score for the text and a legend mapping every index in the array to its description, plus Jev’s probability for each level and a confidence value.
curl https://openrouter.ai/api/alpha/decisions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "typesafe/jev-1.14",
"state": "Export to CSV fails with a 500 error for every workspace in our org since this morning. We can still download JSON exports, but our finance team can only import CSV.",
"questions": {
"severity": {
"type": "score",
"instructions": "How severe is this bug report?",
"criteria": [
"Cosmetic; no impact to functionality",
"Broken or degraded feature, but a workaround exists",
"Blocking issue; no workaround exists"
]
}
}
}'{
"model": "typesafe/jev-1.14-20261014",
"answers": {
"severity": {
"type": "score",
"score": 1.21,
"legend": {
"0": "Cosmetic; no impact to functionality",
"1": "Broken or degraded feature, but a workaround exists",
"2": "Blocking issue; no workaround exists"
},
"probabilities": {
"0": 0,
"1": 0.79,
"2": 0.21
},
"confidence": 0.69
}
},
"usage": {
"input_tokens": 354,
"output_tokens": 17,
"cost": 1.4868e-05
},
"id": "gen-dec-1792170402-eLn9v13BBrBgVkFOhKyE",
"provider": "TypeSafe"
}The score, 1.21, is the probability-weighted average of the levels, 0.79 times 1 plus 0.21 times 2, as shown in the above response. Your own run will land a few hundredths away because Jev’s probabilities vary slightly between calls. Reading “we can still download JSON exports” as a workaround, Jev lands mostly on level 1. It also gives some weight to “blocking” because finance can’t use the workaround.
Because scores are on an ordinal scale, you must keep the levels in a real order from least to most and describe each level in words. The TypeSafe docs list the Score primitive details, including a cap of 10 levels.
Noul: probability that a yes/no proposition holds
Noul is the simplest primitive of the four. It takes as input a proposition and returns the probability that the answer is yes.
The command below sends the request:
curl https://openrouter.ai/api/alpha/decisions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "typesafe/jev-1.14",
"state": "I was charged twice for September. Please refund the duplicate charge.",
"questions": {
"refund": {
"type": "noul",
"instructions": "Is the customer asking for money back?"
}
}
}'Here’s the response that the API returned:
{
"model": "typesafe/jev-1.14-20261014",
"answers": {
"refund": {
"type": "noul",
"noul": 0.98
}
},
"usage": {
"input_tokens": 287,
"output_tokens": 20,
"cost": 1.2054e-05
},
"id": "gen-dec-1792170403-8ZxWBk1v84WmZdC8FfC2",
"provider": "TypeSafe"
}Keep in mind that a Noul answer has no separate confidence field. The probability is the whole answer. The next section explains how to interpret it.
Box: find something in an image
Jev 1.14 also reads images, and Box is the question type that uses them. You describe a target, and Jev returns the four edges of a box around it as fractions of the image’s width and height, measured from the top-left corner, plus a confidence value. Box takes no criteria, and Jev 1.13 rejects it with a 400.
Images go in the state array as image_url parts with a base64 data URL (PNG or JPEG). This request sends a ticket with a screenshot of a card statement, and asks a Noul and a Box about it in one call:
IMAGE=$(base64 < statement.png | tr -d '\n')
curl https://openrouter.ai/api/alpha/decisions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"model": "typesafe/jev-1.14",
"state": [
"Ticket: I think I was charged twice this month, screenshot attached.",
{ "type": "image_url", "image_url": { "url": "data:image/png;base64,$IMAGE" } }
],
"questions": {
"duplicate": {
"type": "noul",
"instructions": "Does the screenshot show the same charge listed twice?"
},
"statement": {
"type": "box",
"instructions": "the white card statement, including its border"
}
}
}
EOF{
"model": "typesafe/jev-1.14-20261014",
"answers": {
"duplicate": {
"type": "noul",
"noul": 1
},
"statement": {
"type": "box",
"box": {
"top": 0.15,
"bottom": 0.85,
"left": 0.56,
"right": 0.94
},
"confidence": 0.95
}
},
"usage": {
"input_tokens": 1034,
"output_tokens": 36,
"cost": 4.3428e-05
},
"id": "gen-dec-1792170612-Z1dmwek8HmFenSx9T9YK",
"provider": "TypeSafe"
}
The Noul is 1 because the same charge appears twice. My first Box instruction, “the card statement in the screenshot”, got a box around only the lines of text, with confidence 0.44. Naming what the edge should include (“the white card statement, including its border”) brought it to 0.95. So write Box instructions the way you write criteria, literally.
Box has no “not found” answer: it returns four edges even when the target isn’t in the image, so ask a Noul about the target in the same request. TypeSafe marks image input and Box as early features whose request format, answers, and limits can change between releases. The Multimodal Decisions guide has the part format and size limits.
Ask several questions in one call
You might even be asking yourself, hey, how many questions can go in that questions object? As many as you want. The state doesn’t have to be a plain string: it can be a JSON object with all the flexibility that implies. Your instructions can then refer to its fields by name in backticks.
Let’s say you want to ask a Choice, a Score, and a Noul all at once from the same ticket domain in a single round trip.
The command which sent this request is shown below.
curl https://openrouter.ai/api/alpha/decisions \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "typesafe/jev-1.14",
"state": {
"ticket": "Hi, I was charged twice for my Pro subscription this month. Please fix this before my next payroll run on Friday."
},
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle `ticket`?",
"criteria": {
"billing": "Charges, invoices, and refunds",
"technical": "Bugs, outages, and broken features",
"account": "Login, password, and profile changes"
}
},
"urgency": {
"type": "score",
"instructions": "How urgent is `ticket`?",
"criteria": [
"No deadline; routine question",
"Customer wants a fix soon but nothing is blocked",
"Customer names a deadline or something is blocked now"
]
},
"refund": {
"type": "noul",
"instructions": "Is the customer in `ticket` asking for money back?"
}
}
}'The response shown below is the one the API returned.
{
"model": "typesafe/jev-1.14-20261014",
"answers": {
"team": {
"type": "choice",
"choice": "billing",
"probabilities": {
"billing": 1,
"technical": 0,
"account": 0
},
"confidence": 1
},
"urgency": {
"type": "score",
"score": 2,
"legend": {
"0": "No deadline; routine question",
"1": "Customer wants a fix soon but nothing is blocked",
"2": "Customer names a deadline or something is blocked now"
},
"probabilities": {
"0": 0,
"1": 0,
"2": 1
},
"confidence": 1
},
"refund": {
"type": "noul",
"noul": 0.82
}
},
"usage": {
"input_tokens": 447,
"output_tokens": 69,
"cost": 1.8774e-05
},
"id": "gen-dec-1792170404-hgawpTDiBEW9h0GrRP8K",
"provider": "TypeSafe"
}If all went smoothly, each answer lands under the key you gave it. In code, you’ll then be able to go answers.team.choice and answers.refund.noul directly.
How to read Jev probabilities and confidence
There are three guidelines to keep in mind when reading Jev’s probabilities and confidence.
When the Noul is near 0.5, that’s Jev saying it doesn’t know what to think. Read it as a state of uncertainty. Let’s do a quick experiment to show you how. I asked the same refund question, “Is the customer asking for money back?”, about the state “There are two charges on my card this month. If one of them is a mistake, what are my options?” on two separate calls. One returned a Noul of 0.42, and on the exact same message (yes, verbatim), Jev returned a Noul of 0.44. If you’re tempted to say, “Aw, the customer is just asking for money back,” consider that the customer never once asked for money back in the message. They’re circling it, but Jev is feeling the tug in two directions, and you and I wouldn’t be certain either. Meanwhile, the explicit refund request in the earlier Noul call hit 0.98. See the pattern? When the outcome is in the middle, treat it as a third outcome, one you can take action on. Ask a follow-up question, or hand the ticket over to a person.
Choice and Score confidence is a measure of how concentrated the distribution is. The more all of the distribution’s weight falls on one outcome, the higher the confidence. A choice concentrated around a single option yields a high confidence number, on a scale from 0 to 1. The higher the confidence number, the less hesitation there is between the options. But just because Jev concentrates its attention on an option doesn’t mean the answer is right. TypeSafe draws its confidence numbers from the shape of its probabilities, not their actual correctness (confidence docs). In the extreme case, a model that assigns all of its weight to one outcome will have a confidence of 1.0, while less concentration will diminish that number.
You can verify that with the billing example. This state was muddier: “I upgraded to Pro yesterday but the dashboard still says Free and I got charged. Which one is it?” The response below shows you exactly what the API returned:
{
"type": "choice",
"choice": "billing",
"probabilities": { "billing": 0.88, "technical": 0.11, "account": 0.01 },
"confidence": 0.82
}Jev still picks billing, although about a tenth of its weight sits on technical, and the confidence drops to 0.82. Confidence is a measure of how torn Jev is between options, but whether those options are well chosen is up to you.
Pick your own thresholds from your own labeled data. The operational advice is simple. Calibration holds in aggregate, which means that the right cutoff for you depends on how expensive your mistakes are. TypeSafe’s confidence guide suggests three bands: Act automatically if the confidence passes one threshold. Proceed with caution in the middle, flagging for an additional layer of user confirmation or simply flagging for review. And route to a person or different system if the confidence falls below the other threshold.
How do you set those bands? Label a few hundred examples. For each of them, inspect where Jev’s probabilities fall. Then pick bands that ensure the error rate within the act band is one that you can live with.
What Jev leaves to your code
There are a few things that Jev doesn’t do that you might expect it to do as a model. Those stay in your own code or with an LLM:
-
Text generation. Every Jev response is one of the typed shapes shown earlier, never a completion, never a JSON body, never an explanation. When a pipeline needs a sentence, an LLM produces it and Jev checks it. The verified cascade cookbook shows this pattern.
-
Visible reasoning. Jev returns only the distribution over your options, nothing else. No rationale, no chain of thought. Keep the distribution as the signal to log and threshold on. For an audit trail, log the request ID, names of the questions, the probabilities, and the threshold your code applied. Keep the
stateitself out of the log because tickets and documents contain customer data. -
Tool calls, conversation, or multi-step plans. Jev answers the questions you sent about the state you sent in one round trip. It makes no tool calls, holds no conversation, and takes no steps. It works inside agents as the deciding part, for example gating tool calls.
That’s three! Here are two more constraints to keep in mind:
-
Jev reads text and images (PNG and JPEG). It doesn’t accept audio or video, so turn those into text or structured fields first.
-
Exact arithmetic, date math, and threshold comparisons aren’t Jev’s job. Compute them first and hand Jev the semantic part.
When to use the Jev model
Now that you’ve got the idea of what Jev does, let’s talk about when it makes sense: when the answer your LLM is expected to provide fits into an enum, a boolean, or a number.
When to use Jev
- Routing and triage: you determine queue, owner, priority. One Choice and one Score per ticket.
- Classification and tagging at scale: cheap enough (see pricing below) to run on every row; the output is already a label.
- Gating agent actions: before a destructive tool run, ask a Noul whether the user’s request authorizes deleting these files; block below your threshold.
- Verifying LLM output: draft with an LLM, then ask Jev whether that draft is grounded in the policy text you supplied.
- Ranking and filtering: score candidates against described levels, then sort.
When to skip Jev
When the answer needs to be prose, or when the input is audio or video, or when the logic is deterministic. An exact rule? A regex or database lookup beats any model. To poke at it before coding, Jev Lab runs several of these patterns in the browser on live calls.
How to access Jev on OpenRouter
You’ll need an OpenRouter API key and a model ID: typesafe/jev-1.14 (pinned) or ~typesafe/jev-latest (alias to track the newest version). typesafe/jev-1.13 is still available if you need to stay on it. The same call can be made three different ways: using the OpenRouter SDK, the TypeSafe SDK, or raw HTTP.
Decisions API with the OpenRouter SDK
The code below shows the same call as the one in the muddier ticket in the confidence section: a POST https://openrouter.ai/api/alpha/decisions call via the OpenRouter TypeScript SDK’s alpha.decisions. The code has been tested with SDK 1.4.25, installed via npm install @openrouter/sdk. Because of the top-level await, run it with bun run or as an ES module. Let’s go:
import { OpenRouter } from '@openrouter/sdk';
const openrouter = new OpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
const decision = await openrouter.alpha.decisions.create({
decisionsRequest: {
model: 'typesafe/jev-1.14',
state: 'I upgraded to Pro yesterday but the dashboard still says Free and I got charged. Which one is it?',
questions: {
team: {
type: 'choice',
instructions: 'Which team should handle this ticket?',
criteria: {
billing: 'Charges, invoices, and refunds',
technical: 'Bugs, outages, and broken features',
account: 'Login, password, and profile changes',
},
},
},
},
});
const team = decision.answers.team;
if (team.type === 'choice') {
console.log(team.choice, team.probabilities, team.confidence);
}billing { billing: 0.88, technical: 0.11, account: 0.01 } 0.82These numbers match the earlier run on this ticket, but other calls in this post moved a few hundredths between runs (the Score example came back at 1.21, then 1.17 through the TypeSafe SDK below), so it’s best to set threshold values on bands rather than exact values. Finally, note that the OpenRouter SDK returns decision.usage.inputTokens and decision.usage.outputTokens in camelCase, rather than the raw API’s input_tokens and output_tokens.
TypeSafe JavaScript SDK pointed at OpenRouter
The second calling path is the TypeSafe SDK: point the SDK’s base URL at OpenRouter and pass your OpenRouter API key as the API key. The SDK will append /v1/systemone to the base URL. Bare model names like jev-1.14 map to typesafe/jev-1.14. The code below is the same call to Jev, using @typesafe-ai/sdk; the code has been tested with SDK 0.7.0:
import { TypeSafeClient } from '@typesafe-ai/sdk';
const client = new TypeSafeClient({
apiKey: process.env.OPENROUTER_API_KEY,
baseURL: 'https://openrouter.ai/api',
});
const result = await client.systemOne({
model: 'jev-1.14',
state: 'Export to CSV fails with a 500 error for every workspace in our org since this morning. We can still download JSON exports, but our finance team can only import CSV.',
questions: {
severity: {
type: 'score',
instructions: 'How severe is this bug report?',
criteria: [
'Cosmetic; no impact to functionality',
'Broken or degraded feature, but a workaround exists',
'Blocking issue; no workaround exists',
],
},
},
});
console.log(result.answers.severity);{
type: "score",
score: 1.17,
legend: {
"0": "Cosmetic; no impact to functionality",
"1": "Broken or degraded feature, but a workaround exists",
"2": "Blocking issue; no workaround exists",
},
probabilities: {
"0": 0,
"1": 0.83,
"2": 0.17,
},
confidence: 0.74,
}TypeSafe Python SDK pointed at OpenRouter
The same idea in Python, with typesafe-sdk 0.7.5 (pip install typesafe-sdk):
import os
from typesafe_sdk import TypeSafeClient
client = TypeSafeClient(
api_key=os.environ["OPENROUTER_API_KEY"],
base_url="https://openrouter.ai/api",
)
result = client.system_one(
model="jev-1.14",
state="There are two charges on my card this month. If one of them is a mistake, what are my options?",
questions={
"refund": {"type": "noul", "instructions": "Is the customer asking for money back?"}
},
)
print(result.answers["refund"])type='noul' noul=0.45Keep your OpenRouter key safe and sound on the server-side. The TypeSafe SDK guide has details about the alias mapping, the response envelope, and error handling.
Jev pricing and context window
From the OpenRouter model page on October 16, 2026:
| Jev 1.14 on OpenRouter | |
|---|---|
| Input price | $0.042 per million tokens |
| Output price | $0 |
| Context window | 262,144 tokens |
| Modality | Text and images in, decisions out |
| Provider | TypeSafe |
To sum up: the three-question ticket call above used 447 input tokens and cost $0.000019 (about two thousandths of a cent). A million tickets of that size come to about $19. Output is free and the answers are tiny (between 17 and 69 tokens across every call above). Because the key order inside probabilities shifts between calls, I suggest you index entries by name rather than by position.
TypeSafe’s models page gives two limits: 64k tokens per request, and 32k for your state plus any one question. Its long-context mode raises both to 262k, which is the window OpenRouter lists. OpenRouter turns that mode on for you when a request carries more than about 32,000 bytes of text or any image. TypeSafe says long context is slower and less accurate, so keep state short when you can.
Is Jev open source?
Quick question: Is Jev proprietary? The answer is obvious (yes), but let me explain. TypeSafe hasn’t published Jev’s weights or a paper on Jev, and everyone who wants to use Jev calls the same hosted model.
Other decision models on OpenRouter
Jev was the first decision model on OpenRouter, but it isn’t the only one. As of October 16, 2026, the catalog lists 21 decision models from 13 makers, all behind the same Decisions API. Some of the bigger ones:
- OpenAI GPT-6 Luna Decisions: GPT-6 Luna served as a decision model. Text and images, a 1.05M-token context window, $0.10 per million input tokens.
- Microsoft Microsoft-Decision-1: a small model built for fast decisions. Text only, $0.042 per million input tokens.
- Perplexity Decider V1.1 27B: text and images, $0.02 per million input tokens.
- Cloudflare Clef, Clef Flash, and Clef Omni: open-source Qwen fine-tunes served on Workers AI. Clef Omni also reads audio and video.
- Inception Mercury Decide: text and images, $0.02 per million input tokens, with a free variant.
- Liquid AI d1 and d1-ultra: text and images.
- Upstage Solar Decide and Solar Decide Flash: text only, with a 524K-token context window.
Smaller makers add Nace.AI Drex, Respan Span-02, ScaleDown Classify-1, Together Tev1, and Kev 4B.
Browse the full list of decision models, or see which ones developers use most on the decision model rankings.
Try it
Now it’s time to see all this with your very own OpenRouter API key! Grab it, paste one of the curl commands above, and change the state to a real message from your own system.
- If you would rather use TypeSafe’s client, read the TypeSafe SDK guide.
- Work through how to gate tool calls with Jev, putting a Noul in front of an agent action.
- Read Jev vs LLM: when to use each for benchmarks, and the route-then-write pattern.
- Follow How to Use Jev to build a full moderation pipeline in TypeScript, with Choice, Score, and Noul questions in one request.
- See how Jev scored against a frontier model in Is Jev as Accurate as Frontier Models at Classification?, and where it fits next to a judge model in Jev vs LLM-as-a-Judge.
- The Jev documentation hub lists every Jev guide and cookbook on OpenRouter.
- Compare Jev with the other decision models on OpenRouter, which take the same request.
- And before you budget, check the model page to see what the current pricing looks like for that model!
FAQ
What is Jev?
Jev is a decision model made by TypeSafe. You interact with most models by sending them text. You don’t do only that with Jev. Instead, you send it text plus one or more typed questions, and the answers you get back are typed answers with calibrated probabilities. No text generation. TypeSafe calls this category of models System One models.
Who makes Jev?
Jev is a decision model. It was built by TypeSafe, an AI lab that was founded by Diogo Almeida, Erik Gafni, and Sasha Sheng. Jev was released in early access on September 15, 2026. The current version is Jev 1.14, released October 14, 2026, and Jev 1.13 is still available. You can get it through TypeSafe’s own API or through OpenRouter.
Is Jev an LLM?
No. Jev is a non-generative decision model, while LLMs are generative models: Jev reads your natural language like LLMs do, but then generates no text, no tokens. Jev returns one of four answer shapes, depending on your question: a choice among a set of pre-determined options, a score on a defined set of levels, the probability of yes vs no, or a box around something in an image. Because there’s no generated text, there’s nothing to parse and no chance of output hallucination.
What is Jev used for?
Okay, so you’ve got to decide which support ticket gets routed to which team. You’ve got to classify this blog post into a content type. You want to gate an AI agent’s tool call based on a confidence threshold. You’ve got to rank a set of candidates in order. And you’ve got to verify a draft against a policy. Sound familiar? In these situations, you’re the one who would previously ask an LLM a question, then use a regex to parse out a boolean value or an enum value. Meet Jev, the model purpose-built for just these kinds of decisions, replacing that LLM-plus-regex workflow.
How do I access Jev?
So you want to access Jev through OpenRouter? Well, you only need an OpenRouter API key and a POST to the following URL: https://openrouter.ai/api/alpha/decisions, with model typesafe/jev-1.14. Alternatively, you can use the decisions client in OpenRouter’s SDK. You can even use the TypeSafe JavaScript and Python SDKs. Just set the base URL to https://openrouter.ai/api and pass your OpenRouter key.
What does Jev cost?
Jev 1.14 on OpenRouter costs $0.042 per million input tokens (and output is completely free) as of October 16, 2026. Which means a typical three-question call on a short support ticket used around 450 input tokens, costing you roughly two thousandths of a cent. So always remember to check out the model page to see current pricing.
Are there other decision models besides Jev?
Yes. As of October 16, 2026, OpenRouter lists 21 decision models from 13 makers, including OpenAI GPT-6 Luna Decisions, Microsoft-Decision-1, Perplexity Decider, Cloudflare Clef, Inception Mercury Decide, Liquid AI d1, and Upstage Solar Decide. They share the Decisions API, so most take a Jev request with only the model changed. See the full list of decision models.
Is Jev open source?
No. Jev is a proprietary model and as such there are no published weights and no paper. You can, however, call it through the TypeSafe API or OpenRouter.