Jev is an AI model that, when you enter text, returns a choice, a score, or the probability of Yes/No. It does not generate text. It suits uses where judgments such as routing inquiries are repeated inside an app. The price is $0.042 per 1 million input tokens, and output is free.
Contents
1. What Is Jev?
TypeSafe announced early access to Jev on September 15, 2026. Rather than a chat that returns long explanations, it is designed for judgments inside an app, such as deciding "which team should handle this" or "how well this matches the criteria."
Its key feature is that the shape of the returned values is fixed. However, a response in the correct format can still be a wrong judgment. If you read the announcement's phrase "no hallucinations" as meaning it answers correctly for any content, you will use it incorrectly.
TypeSafe calls Jev a "System One model." According to the announcement, the name is the company's own, drawn from the distinction in the book Thinking, Fast and Slow by psychologist Daniel Kahneman between fast, intuitive "System 1" and slower, deliberate "System 2." It is not a unified performance grade for AI as a whole. The official System One explanation describes it as a model that understands natural language and returns typed judgments that software can use directly.
The name Jev honors economist William Stanley Jevons. It expresses the idea that, as the cost of intelligence falls, its uses grow by orders of magnitude, much like the Jevons paradox, in which efficiency gains increase demand instead of reducing it (Will AI Wipe Out White-Collar Jobs?).
- state
- The material to judge. Text or JSON-formatted data. Put in the body of the inquiry, items the user selected, background information for classification, and so on.
- questions
- What to decide. A question such as "which team should this go to?" along with candidates and judgment criteria.
Because the output options are set in advance, you do not need a step that extracts a category name from text such as "it's probably the technical team." On the other hand, it is not suited to producing long text such as replies, code, or reasoning. If you combine it with a generative AI, the division of labor is this: Jev determines where the work should go, and a generative model is called only when text is needed.
How is this different from having an LLM answer in JSON?
Receiving output as JSON is not unique to Jev. Claude, for example, has structured outputs that constrain output to a JSON Schema. If you already implement classification with a generative model, you do not need to replace it just because "the format is fixed."
Jev specializes in returning choices, graded ratings, and binary judgments along with their probabilities. If you need explanations or replies after the judgment, use a generative model. If you need to repeatedly pick candidates from text, Jev is also a candidate to compare. If you need exact calculations of amounts or dates, use ordinary code. Divide the work this way. A practical approach is to compare accuracy, wait time, and cost on the same input and criteria before choosing.
2. Differences Between Choice, Score, and Noul
The official Primitives explanation divides question types into three. Even similar questions are chosen according to the output you want.
Choice: select a candidate
Prepare unordered candidates, such as "Billing," "Technical," and "Other," and choose one.
The numbers for selections, probabilities, and counts in this article are illustrative examples.
Include "Other" or "Not enough information to decide" to cover inputs that do not fit. If the candidates are too narrow, the classification can be valid in form but not match reality.
Score: measure on a scale
Describes an ordered scale of 2 to 10 levels. The returned value is a weighted average based on the probability of each level, so it can be a decimal.
Calculation example with 3 levels: assuming probabilities of 10%, 40%, and 50%
No information
0 × 0.1 = 0
Partly understood
1 × 0.4 = 0.4
Reproduction steps are complete
2 × 0.5 = 1.0
= 1.4
Between "partly understood" and "reproduction steps are complete." Read it as a value on the defined 0 to 2 scale, not as an accuracy rate.
Source for the calculation method: TypeSafe "Primitives" and "API reference."
It is fine to use the Score value to decide whether a threshold has been exceeded. However, the official documentation cautions against interpolating between levels to back-calculate a number such as "1.4, so the actual amount is about this much." The levels in Jev 1.13 are weakly calibrated as numbers (known weaknesses of Jev 1.13).
Noul: probability of Yes
Make the condition explicit, for example: "Does the text say that the service is currently unavailable?"
At 0.5, Yes and No are about equally likely
It does not mean "moderately serious." To measure severity, use a Score with defined levels.
- Where to write the condition
- State it explicitly in
instructions. The key that identifies a question is not passed to the model's reasoning, so do not try to convey intent with the question name alone. - The confidence field
- Choice and Score have it, but Noul has no separate field.
3. Type Guarantees and Accuracy Are Different
The type guarantee emphasized in TypeSafe's announcement means that output is constrained to the defined candidates or value range. If you split inquiries into billing or technical teams, it will not invent an unspecified department name as free text. However, whether it picks the correct team is a separate question.
According to the official explanation, the confidence for Choice and Score is a statistic that summarizes how concentrated the probability distribution is as a single number from 0 to 1. It is the default metric. If it does not suit your use, you may compute a different metric yourself from the probabilities returned alongside it.
- Candidates are close
- Confidence becomes low.
- Concentrated on one candidate
- Confidence becomes high.
Do not read "0.9, so this one case is 90% likely to be correct." Probability calibration is a property evaluated across many predictions together. It does not indicate whether an individual case is correct.
In practice, you write code that branches on confidence. The official Confidence page shows the following branching, after letting users choose their request from "Check balance," "Approve pending withdrawal," or "Support" (excerpt; the comments are the author's translation).
if confidence < 0.5:
# The model is genuinely unsure. Don't guess
route_to_human(user_message)
elif action.choice == "check_balance":
# Low impact. Showing a different screen can be undone
show_balance(account_id)
elif action.choice == "approve_transfer":
if confidence > 0.9:
# High impact and high confidence. Confirm, then execute
confirm_then_execute(account_id)
else:
# High impact, moderate confidence. Verify first
ask_user_to_confirm(account_id)The 0.5 lower bound is meant to catch cases where the model has indicated that it is genuinely unsure. Beyond that, an irreversible operation such as approving a withdrawal requires a higher threshold than a read-only operation. Note that even above 0.9, the code does not execute immediately; it asks for confirmation. High confidence is not a substitute for permission to execute.
0.5 and 0.9 are examples, not recommended values. The official documentation also says that appropriate values depend on the field and on the model's performance for your use. It recommends starting with conservative thresholds and tuning them on your own data.
4. An Example: Routing Support Requests
Consider an inquiry that says "I press the download button for my invoice, but nothing happens." If you route it to billing because of the word "invoice," you will miss the screen malfunction. If you have Jev make the judgment, explain the boundaries of each team and then have it choose a candidate.
Following the official Quick start and the API reference, the request looks like this. Get an API key and send JSON to POST https://api.typesafe.ai/v1/systemone.
{
"model": "jev-1.13.0",
"state": "I press the download button for my invoice, but nothing happens.",
"questions": {
"team": {
"type": "choice",
"instructions": "Choose the team candidate that matches the main request in the message.",
"criteria": {
"billing": "Questions about the amount billed, payment method, or double charges.",
"technical": "Screen operations, errors, or features that don't work.",
"review": "Multiple requests are mixed together, or there is not enough information to decide who should handle it."
}
},
"service_unavailable": {
"type": "noul",
"instructions": "Does the message report that a screen or feature is currently unavailable?"
}
}
}Sending the request and handling the response
Get an API key from the console, and set Authorization: Bearer <API_KEY> and Content-Type: application/json in the HTTP headers. Manage the key with environment variables or similar on the server, and do not embed it in public HTML or repositories.
To check connectivity first, you can paste the curl example from the official Quick start as-is and run it. Put the key in the environment variable TYPESAFE_API_KEY, then run it. This example uses Noul to ask whether an English inquiry expresses urgency.
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d @- <<'EOF'
{
"state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
"model": "jev-latest",
"questions": {
"urgency": {
"type": "noul",
"instructions": "Does this message express urgency?"
}
}
}
EOFTo send the routing example above, replace the JSON between <<'EOF' and EOF with that JSON. When calling it from code, or having an agent that helps with development read the specification, the official documentation provides the following entry points.
- Calling from Python:
pip install typesafe-sdk(Python 3.10 or later). The SDK client reads the environment variableTYPESAFE_API_KEYand callsjev-latestby default. - Developing with Claude Code:
claude plugin marketplace add typesafe-ai/skills, followed byclaude plugin install typesafe@typesafe-ai. This installs an official skill that gives a coding agent the three question types and design patterns (Agent skill).
Returning to the routing example, the fields to read and their uses are shown in the figure and table below. Choice gives the team candidate, and Noul shows whether a report of an unavailable feature exists.
| Field to read | Example value / meaning | What to do in your app |
|---|---|---|
team.choice | technical (Technical team) | Show the team candidate |
team.probabilities | {"technical": 0.80, "billing": 0.15, "review": 0.05} | Check whether the judgment is split between candidates |
team.confidence | Concentration calculated from the probability distribution | Compare against a condition you set based on your own evaluation data |
service_unavailable.noul | 0.85 (rated as a report of unavailability) | Do not confuse with severity; use as an item to confirm |
Each field is under answers. Also prepare a pending-review destination for cases where candidates are close, information is insufficient, or the response cannot be retrieved. Basis for the types: TypeSafe "API reference."
- 401 and 422: fix the settings or input
- 401 means a missing or invalid key; 422 means input format validation failed. Fix the settings or the message, then resend.
- 429 and 529: wait, then retry
- Do not repeat in quick succession; gradually increase the wait time. The official SDK performs this retry automatically by default.
HTTP errors are separate from low confidence. Do not treat them as answer values. The basis is the API reference above.
When starting out, it is enough to leave your existing routing unchanged and simply place the team a person chose side by side with Jev's candidates. Check whether a technical problem is still routed correctly even when it contains the word "invoice," whether messages with multiple requests can be sent to review, and whether it avoids jumping to conclusions when information is missing. When you find an error, add it as a failure case and review whether the candidate descriptions overlap.
When building it into an AI agent, separate "the model that judges," "the tools that execute," and "the conditions under which execution is allowed," and keep amount calculations and permission checks in code. This makes it easier to trace where a mistake occurred when a misjudgment happens.
TypeSafe's official documentation also has implementation examples for guardrails for LLM apps, selecting documents retrieved with RAG, reordering search results, and verifying citations. Even when using it for guardrails or document selection, the weakness of "inputs that lead the answer," covered in the next section, remains. (The approach of stopping at both input and output is explained in What Are AI Guardrails?)
5. Poor-Fit Tasks and Known Weaknesses
TypeSafe publishes known weaknesses of Jev 1.13. Do not assume that it is accurate just because it is only for judgment. Divide the work as follows.
| Condition it struggles with | Possible problem | Design countermeasure |
|---|---|---|
| Counting and calculating | Mixes up character counts, item counts, or exact numbers | Calculate with a parser or ordinary code |
| Comparing dates | Judgments about order or whether something falls within a period become unstable | Extract the needed elements and compare them as date types |
| Double negatives and indirect questions | Pulled toward the surface wording rather than the intent | State the condition directly and split multiple judgments |
| Inputs with much irrelevant information | Unneeded information gets in the way of the judgment | Search and extract first, then pass only the needed items |
| Inputs that lead the answer | Affected by instructions inside the text, or by sentences asserting how it should classify itself | Evaluate with failure cases that include leading inputs, and manage execution permissions separately |
| Mismatch between instructions and criteria | If the question and the criteria ask for different things, confusion can occur (for example, assigning the meaning of "no" to true in Noul lowers accuracy) | Write criteria as an extension of the question, and align their direction |
| Free-text generation | Not suited to replies, explanations, or code generation | Use templates or a generative model |
Also, the probabilities of separately asked Yes/No questions do not necessarily satisfy mathematical relationships. Even if you ask the same condition and its negation with separate Noul questions, the sum is not guaranteed to be 1, and you cannot treat Choice probabilities and Noul probabilities with the same threshold. When you change the form of a question, evaluate it again rather than reusing previously tuned values.
Points to check when using languages other than English
6. Reading Pricing, Input Limits, and Speed
As of September 21, 2026, the TypeSafe Models page listed the current model as jev-1.13.0. On October 14, 2026, jev-1.14.0 was also released (pricing and context length are the same). At the time of checking on October 19, the alias jev-latest (stable) pointed to 1.13, and jev-preview pointed to 1.14. Aliases switch when a new version is released, so if you want stable results, specify a versioned ID. The price is $0.042 per 1 million input tokens, and output tokens are free. It is not a fixed fee per inquiry; it varies with the number of input tokens, including state and questions. As a rough scale, the official Quick start response example (an English inquiry of three sentences with three questions) shows usage.input_tokens in the range of a few hundred tokens. In its announcement, TypeSafe also writes that it cannot currently prove this price is not subsidized, and that whether it can be sustained will only be shown over the long term. It expects prices to fall rather than rise.
The double limit: 64k and 32k
Condition 1: the entire request
64k tokens max
Condition 2: state + the longest question
32k tokens max
Both must be satisfied. This does not mean you can put a 64k document directly into state. This is the default. If you add the request header TypeSafe-Danger-Zone-Long-Context: true, both rise to 262k tokens. The pricing is the same, but the official documentation explains that it is slower and less accurate.
Input is text only. Images, audio, and video cannot be passed directly, so they must first be converted into text or structured data by a separate process.
Rate limits can change
Rate limits are set per organization. Check your organization's limit in the developer console (as of the Models page on October 19, 2026; previously fixed numbers were listed). The units are tokens per second and requests per second. Exceeding either returns 429 Too Many Requests. The official SDK retries with backoff by default, and if the response has a retry-after header, it follows that. If you call the HTTP API directly, write your own retry logic that increases the wait time, as described above.
The official documentation notes that because demand is very large, limits are adjusted dynamically and may change without notice. Higher limits are available through custom or enterprise contracts. For a design that sends large volumes of text at once, check the values when you start and decide in advance how to wait when you hit a limit.
Compare speed and cost on the same task
In its announcement, TypeSafe gives the time from request to result as 70 ms to 500 ms. However, the company's public evaluations were run mainly from its laptops on the U.S. West Coast, where the service is based.
Compared with generative models, it cites the figure "193.6 times faster and 444.6 times cheaper." This comes from a workflow evaluation the company created, and TypeSafe itself expects it to be on the high end of the improvements that can actually be achieved. It states that the evaluation workflows were not chosen to favor its own model and are not included in training data, but also notes that because they were built by members of its own model capability team, bias is possible. Read both as the vendor's own figures, and compare them on your own tasks, keeping the following points in mind.
- Results change when conditions change: Compare with the same network distance, input length, number of questions, and comparison model settings.
- Cannot be used as a multiplier against ordinary chat: The official comparison includes processing to extract a probability distribution from a generative model.
What to compare in practice
- Cost: API unit price plus operating effort
- Include the share of preprocessing, retries, and waiting for review. Even if classification is cheap, the overall effort will not decrease if human review increases.
- Speed: the average plus slow requests
- Check that work does not stop during congestion or when responses are slow.
7. What to Check When Trying It
Start with the Playground to see whether your question criteria come across. The official Quick start includes steps for getting an API key and calling the API. Because it is in early access, first check your usage permissions after logging in.
① Enter the message
If you have access, type the inquiry text into the Playground.
② Set the candidates
Define the team candidates and their boundaries with Choice.
③ Vary the wording and compare
Look at changes in the candidates and probabilities. You can do this before preparing your execution environment.
Four things to cover in evaluation
Prepare the correct answers and boundaries.
Besides examples where people decided the team, include multiple requests, very short text, negation, and leading sentences. When using real data, confirm that the content may be sent externally.
Fix the criteria for the questions.
Write down what counts as each candidate, and define the conditions for routing to "Other." Also verify with examples that differ from the ones used to adjust the criteria.
Look at accuracy and the share sent for review together.
Count how many items were processed automatically at each threshold, and how many of those were misjudged. Also report the volume waiting for review, so that accuracy alone does not look better than it is.
Record the model and the questions.
Keep the model ID, the input type, the version of the questions, the responses, and the processing time, and compare before and after changes.
1 square = 1 item.
Automatic processing rate
80%
80 items ÷ 100 items in total
Error rate among automatic items
5%
4 misclassified ÷ 80 automatic
Sent to a person
20 items
100 in total − 80 automatic
Look at all three together. 100 items alone do not prove production accuracy.
If you are applying this to your own work
- Repeatedly applying a judgment with fixed candidates to large volumes of text
- Consider Jev as a comparison candidate. Evaluate its accuracy with your own inputs, criteria, and language.
- Writing text such as replies, explanations, or code
- Use a generative model or templates.
- Exactly calculating amounts or dates
- Process with ordinary code.
Premise of this article: it is based on TypeSafe's announcement and the official documentation (checked on September 21, 2026, with the update confirmed on October 19). The author did not run the API, and did not measure accuracy in languages other than English or actual wait times.
FAQ
Q. Can Jev hold a conversation like ChatGPT?
A. It is not a model that generates free-form replies. You enter text and receive judgments in the form you defined with Choice, Score, or Noul. If you need reply or explanation text, combine it with a generative model or templates.
Q. If it has no hallucinations, won't it make mistakes?
A. Constraining output to a type or to candidates and judging content correctly are separate things. The official documentation also lists weaknesses such as calculations, dates, inputs with much irrelevant information, and leading sentences. You need to measure accuracy with your own data.
Q. Does 0.5 from Noul mean moderate?
A. It means Yes and No are being evaluated as about equally likely. It is not a value that represents a midpoint of severity or quality. To measure degree, a Score with explained levels is the candidate.
Q. Can I use it in languages other than English?
A. The official documentation says it handles other languages, including CJK scripts, but explains that English is the main training language and currently gives the best accuracy. Verify with evaluation data in your language before using it for business work.
Q. Can it be used to judge images or audio?
A. The input of the current model is text only, so images and audio cannot be passed directly. If your design passes characters or structured data obtained by another process, evaluate it including the errors of that preprocessing.
