jev-latest

Jev is TypeSafe's flagship model and the first model in the new System One class. It does not write text; instead, it quickly makes decisions that a program can use directly: supply a state (state), as text or JSON, and a set of questions, and receive typed values with calibrated probabilities.

Language models write words for people; according to TypeSafe, Jev is closer to code: the response arrives in the form code needs, quickly and with no values outside the specified options. The model is designed to provide consistent answers to repeated requests.

How System One differs from a language model

• It does not generate. Jev does not write user responses, write code or explain its reasoning. You specify possible answers through one of three question types.
• It is trained for calibrated decisions. TypeSafe trains the model with RLCD (Reinforcement Learning for Calibrated Decisions): probabilities are fitted to actual outcomes and reflect uncertainty. Across many answers with a probability of 0.8, approximately 80% should be correct. Calibration is a property of a large sample, not a guarantee that an individual answer is right.
• A different training objective. Chat models are trained to please people through RLHF, which TypeSafe observes can encourage sycophancy and confidently expressed errors. Diogo Almeida, one of the co-authors of RLHF, is a TypeSafe co-founder.

The name refers to System 1 in Daniel Kahneman's Thinking, Fast and Slow: fast intuitive judgment versus the slow deliberative thinking of System 2. Jev is designed for fast, narrow judgments.

Three question types

A question is one judgment about the state; the answer is a value that code compares to a threshold, sorts or passes onward.

1. Choice — selecting an option. The department for a request, a product category or the language of a code snippet. Options are an option-to-description dictionary, with up to 255 entries. The response contains the selected choice, probabilities for all options, summing to 1, and confidence. If the list may not cover every case, add "other" or "none of the above."
2. Score — a rating on a scale. A position on an ordered scale you describe: bug severity, customer frustration or skill level. There are 2 to 10 levels from lowest to highest; the model assesses each level separately without seeing its number or neighboring levels. The response contains score, the sum of level numbers multiplied by their probabilities, so the value can fall between levels; legend with level descriptions; probabilities; and confidence.
3. Noul — yes or no. Whether a statement is true. The noul answer is the probability of yes from 0 to 1: near 1 means a confident yes, near 0 a confident no, and near 0.5 the model is uncertain. There is no separate confidence: one number describes the answer completely. Optional criteria refine what counts as yes and no.

How to choose: known unordered options call for choice; positions on a spectrum for score; a pure yes/no question where probability itself matters for noul. Noul 0.5 means equal odds of yes and no, not a medium level: degree is measured by score. If two types are suitable, choose the one code can act on immediately: choice for branches, score for a threshold and noul for if.

Types can be mixed in one request. An answer is always restricted to your options and does not depend on other questions: questions can be added or removed without changing the other answers.

State

State is what the model evaluates: a customer message, document passage, database record or your application's state.

• String when there is one text: a message, article or excerpt.
• Object for named fields, related records or application state. TypeSafe recommends an object for most requests because each part has a clear name.
• Array for a sequence of messages or records.

Prepare it like material for experts: include correspondence, the order and return rules together if a decision requires comparing them. Keep content in the state and judgments in the questions. If a question concerns one part of the state, identify its path in backticks, for example ticket.messages[0].text.

Asking questions

• One quick judgment per question. A good question is one a knowledgeable person with the required context could answer in a second: "Does the message express urgency?" "Analyze the message and decide what to do" already requires slow reasoning and should be split into simple questions.
• The entire question belongs in instructions. The question key, such as refund_requested, is only needed by your code and is not passed to the model.
• All questions for one state in one request. The model assesses them in parallel: according to TypeSafe, additional questions barely increase response time and cost only their own tokens. A just-in-case question costs almost nothing; the code decides which answers are needed.
• Break a complex judgment into parts. Instead of "assess the startup application," ask separately about market size, technical feasibility and differences from competitors, then calculate the result in code using weights. When priorities change, change the weights rather than rewrite the question.
• Dependent questions belong in a second request. Answers in one request do not provide context to one another. A second request is needed only if it cannot be assembled without the first answer: data needs to be loaded or options for the next question selected.
• An object for a long question. instructions and criteria are usually strings, but can be an object or array: the question in one field and data in others. This is useful for comparing a resume with database records in one question.

Confidence

For choice and score, confidence from 0 to 1 indicates how much probability is concentrated on one answer: 1 means all of it is on one option, and 0 means it is equally distributed across all options. For score, a neighboring level reduces confidence less than a distant one. For noul, confidence is the value itself: the farther it is from 0.5, the firmer the answer.

TypeSafe recommends three ranges:

1. High confidence — act automatically.
2. Medium — act cautiously, for example by asking the user to confirm.
3. Low — pass the case to a person, refine the request or use a fallback, such as a more powerful reasoning model.

The more costly an error, the stricter the threshold: irreversible actions need a higher one than reads. The answer indicates what to choose; confidence indicates whether to act. Select thresholds on your own data by comparing confidence with accuracy.

Building a system around Jev

Jev is designed not for agents that choose their next step independently and can drift on each iteration, but for programs whose workflow is controlled by code while the model answers narrow semantic questions. TypeSafe's eight design steps are:

1. Do everything that can be done in code in code, reliably and cheaply.
2. Include only what current questions need in the state; obtain fresh facts from your own knowledge base, not the model's memory.
3. Structure the state as nested JSON, and specify the relevant field path in backticks within the question when this reduces ambiguity.
4. Ask the narrowest, most specific questions: according to TypeSafe, this may be the most important rule, because a broad question hides several judgments behind one answer.
5. Structure questions: keep the question itself short, with explanations, examples and database values in neighboring fields of an instructions or criteria object rather than one long string.
6. Ask many independent questions about one state in one request, for more value per dollar.
7. Combine answers in code using rules, a weighted sum or features for a conventional machine-learning model.
8. Branch on confidence: uncertain cases go to a person or reasoning model.

Jev is not a chat or code-completion model and cannot replace a language model in a coding agent. An agent can, however, write code that calls Jev where a fast calibrated answer is needed.

Uses

• Background automation — decisions run a million times without a person nearby.
• Real time — according to TypeSafe, most requests take around 100 ms, enough for on-the-fly processing and interfaces.
• Large datasets — search across huge corpora, labeling of agent-work logs and features for predictions.
• Checking other models — requests, extractions, reasoning and tool calls: bypasses of restrictions, citation errors and fabrications.
• Search and ranking — relevance of a query-candidate pair, reranking and context selection.
• Intent-based routing — what a user wants and which handler is needed: simple logic, a specialized model or a person; topic, complexity and risk determine which language model receives the request.
• Safety checks — language-model input, output and tool calls: injected instructions, policy violations and disclosure of personal data.
• Support — request topic and intent, urgency, frustration, churn risk, refund request and queue.
• Moderation — under your platform's rules: toxicity, harassment, spam, fraud, dangerous advice and personal data; severity and confidence determine whether to allow, warn, review or block.
• Industries — insurance claims, financial investigations and KYC, contracts and advertising, product cards, recruitment, leads, games, risks, demand forecasting, knowledge graphs, scientific reviews and semantic code checks in CI.

Specifications

• jev-latest is an alias for the latest stable version, currently Jev 1.13; the responding version appears in model, for example jev-1.13.0. When a new version is released, the alias moves to it, and answers may change without any edits on your side. Monitor this field if thresholds were tuned for a version.
• Context is 64K tokens per request: state and all questions together; state plus the longest question is up to 32K. The model reads the state once and checks all questions against it in parallel.
• Input is text only: a string, JSON object or array of texts. Images, audio and video are not yet supported; convert them to text first.
• Language — the main training language is English, in which current accuracy is highest. The model accepts other languages, including Chinese, Japanese and Korean, but accuracy is lower; test it on your data.
• Pricing and billing in Ailoot API — terms depend on the selected method and are listed on its card.
• Customization — Jev is not fine-tuned on customer data: put your material in state and domain rules in instructions and criteria.
• Data — TypeSafe states that Jev is not trained on customer requests and responses.

Known weaknesses of Jev 1.13

TypeSafe openly lists the current version's weaknesses and promises to address many in future releases. The model is fast, calibrated and makes sound common-sense judgments, but:

1. Literal reading. It answers the written question, not the implied one: qualifications, negations and implicit conditions are interpreted literally. Write the exact condition and edge cases in criteria; split unavoidable interpretation into two literal questions.
2. Not a calculator. Counting characters, repetitions and list items is unreliable, with error growing as size increases. Count in code and ask one question per candidate. The model understands hex or RGB colors less well than color names. score works for a threshold, not an exact number between levels.
3. Dates and times. Which date is earlier, the interval between dates and whether a date is inside a period are unreliable, especially with mixed formats and relative dates. Extract date parts through choice with a "not specified" option, then compare in code.
4. Indirectness. Double negatives and questions about a property's property reduce accuracy. Write directly and name state parts explicitly.
5. Excess state material. Unrelated text reduces accuracy. Filter in code, or, if that is impossible, screen out irrelevant material with noul questions.
6. Adversarial text. By default, the model does not expect traps in the state: an injected instruction or text arguing about its own classification may shift the answer. Write precise criteria and test edge cases before launch.
7. Contradictions. If instructions and criteria ask for different things, such as describing a noul yes as no, accuracy falls. Criteria continue the question.
8. Option order. Sometimes the model favors the first choice option. Reorder options and check that the answer does not change.
9. Generation. Jev is not trained to write text. For data extraction, find candidates with a regular expression or a generative model, then have Jev choose the correct one through choice.