Jev (AI model)

Jev
Developer	TypeSafe AI
Release	September 15, 2026 (2026-09-15)
Stable release	jev-1.13.0
Type	Artificial intelligence model
License	Proprietary
Website	typesafe.ai

Jev is a proprietary artificial intelligence model developed by TypeSafe AI, a San Francisco–based company founded in 2024. It was released in limited early access on 15 September 2026, alongside the announcement of a US$40 million seed round led by DCVC.

Jev is a discriminative model: it is used for classification or regression, not generation. It does not generate natural-language text. It instead returns typed values together with probability estimates and confidence scores. Its output is intended to be consumed directly by software rather than read by a person. Unlike classical discriminative models, Jev does not require data-specific training. Like generative pretrained transformer models, it can perform zero-shot learning of input for categories provided at inference time, based on contextual information provided at inference time.

TypeSafe describes Jev as the first of a class of models it calls "System One models", a name the company says comes from fast, intuitive System 1 thinking as popularized by Daniel Kahneman.

Background

TypeSafe AI was founded in 2024 by Diogo Almeida, Erik Gafni and Sasha Sheng. Almeida, the company's chief executive, spent approximately four years at OpenAI working on reinforcement learning from human feedback (RLHF), InstructGPT, ChatGPT and GPT-4 before leaving in 2024. The System One model works on Reinforcement Learning for Calibrated Decisions (RLCD).

The company positions Jev as a reliable model for automation and software, and as a response to overconfidence in existing models. Before the announcement, Jev was being developed in stealth for roughly two years.

The model is named after 19th-century English economist William Stanley Jevons, whose Jevons paradox describes how more efficient use of a resource can increase consumption. Almeida has said the name reflects an expectation that cheaper machine intelligence will lead to far wider deployment.

Technical specification

Jev takes an input state together with one or more typed questions (or primitives), and outputs a list of probability distributions.

Input

The official API has a limit of 64k tokens per input, with 32k tokens for state plus the longest question.

A state is an entry. An entry is a string, JSON object, or array of string. Examples:

"My card was charged twice."

{"message": "My card was charged twice.", "order_id": "A-104"}

["Hi", "My customer number is TS1337.", "My card was charged twice."]

A question is a JSON object. Jev allows three types of questions, all multiple-choice.

Type	Choices
noul	true, false
choice	an unordered list of items
score	an ordered list of items

Schematically:

"new_noul_1": {
  "type": "noul",
  "instructions": "<true/false question>",
  "criteria": { "true": <entry>, "false": <entry> }
},
"new_choice_2": {
  "type": "choice",
  "instructions": "Which option fits the state?",
  "criteria": { "option_0": <entry>, ..., "option_n-1": <entry> }
},
"new_score_1": {
  "type": "score",
  "instructions": "Where does the state fall on the scale?",
  "criteria": ["option_0": <entry>, ..., "option_n-1": <entry>]
}

If the state is a JSON object, the question can also refer to attributes of the state. For example:

{"food": "hotdog", "category": "sandwich"}

"new_noul_1": {
  "type": "noul",
  "instructions": "Is `food` a `category`?",
  "criteria": { "true": "", "false": "" }
}

Output

Jev outputs a list of probability distributions, one per question. Each probability distribution is a discrete probability distribution over the choices of that question. This is the only type of output by Jev. The official API returns further data, but these are computed by simple programs, not by Jev. There is no official separate limit on its API output, but this is because the output length is already limited by the input length.

All questions are answered in parallel, meaning that the type system of Jev does not allow any dependency between the questions. Consequently, the official documentation state that if one question depends on another's answer, one must make two requests in sequence.

The official API also returns further numerical data, such as choice, score, confidence, computed by fixed formulas based on the probability distributions. It also returns certain metadata, such as legend, for standard book-keeping purposes.

For a choice question, the answer's choice is just the most likely choice (i.e. the mode):$$\operatorname {mode} (p_{0},\dots ,p_{n-1}):=\operatorname {argmax} _{i}p_{i}$$For a noul or choice question, the answer's confidence measures how concentrated the probability distribution is around the mode:$$\mathrm {confidence} ={\frac {p_{\max }-n^{-1}}{1-n^{-1}}}$$where $n$ is the total number of choices (i.e. $n=2$ for noul), and $p_{\max }=\max\{p_{0},\dots ,p_{n-1}\}$ is the largest probability in the distribution.

For a score question, the answer's score is the probability-weighted average $\sum _{i=0}^{n-1}ip_{i}$, and confidence is defined as:$$\operatorname {confidence} =\max \!\left(0,\,1-{\frac {\operatorname {MAD} (p_{0},\dots ,p_{n-1})}{\operatorname {MAD} (1/n,\dots ,1/n)}}\right)$$where$$\operatorname {MAD} (p_{0},\dots ,p_{n-1}):={\frac {1}{n}}\sum _{i=0}^{n-1}|i-\operatorname {mode} (p_{0},\dots ,p_{n-1})|$$is the average absolute deviation around the mode.

Architecture

TypeSafe has not published Jev's architecture, weights, or a technical paper. The company describes it as transformer-based. Outside observers have suggested the model may be built on an open-weight LLM or a BERT-like architecture.

Training

Jev is trained exclusively on synthetic data, by an algorithm the company calls Reinforcement Learning for Calibrated Decisions (RLCD). The details are unpublished, though it is suspected to be a standard supervised learning algorithm with a loss function that includes loss terms that punish calibration. The loss terms may include the Brier score.

Performance

The official announcement included demos of Jev used in workflows. A workflow is simply a standard decision flowchart where some decisions use outputs from Jev.

TypeSafe claims that when tested on its own workflows, Jev achieves end-to-end response times of 70–500 milliseconds, 40–200x faster and 40–400x cheaper than frontier LLMs on comparable tests. TypeSafe states in its own technical notes that the workflows were created by members of its model-capabilities team and thus may be biased compared to real-world tasks.

External links

• Official website
• Developer documentation for Jev