Jev is a TypeSafe AI model for fast decisions within programs and AI agents. Unlike a regular generative model, it does not write long text but receives data and returns a strictly defined result: choose one option, assign a score, or determine the probability of a “yes” answer.
This is what makes Jev interesting for automation. Not every AI agent step requires GPT, Claude, or another large model. Sometimes you only need to determine: is this a lead or spam, which tool to call, which department to send an email to, or whether an expensive LLM is needed at all. For such tasks, Jev offers a separate fast decision-making layer.
What is Jev
Jev is TypeSafe AI’s first public System One Model. The model was introduced on September 15, 2026. TypeSafe describes it as a “frontier-intelligence function call”: it takes a system state and a set of questions as input, and outputs typed probabilistic decisions that a program can use directly.
TypeSafe AI founder Diogo Almeida previously worked at OpenAI on methods for training models to follow instructions. In the post announcing Jev, he writes that this work contributed to the research underlying ChatGPT. Therefore, the common description of him as a “ChatGPT co-author” oversimplifies his role.
The official Jev description can be found in the TypeSafe AI announcement and model documentation.
What System One Model means
The name refers to the “System 1” and “System 2” concept popularized by Daniel Kahneman. Here, it is more of an engineering metaphor.
A large generative model is well suited to a task like: “analyze these documents, find contradictions, and prepare a conclusion.” It has to reason and generate a sequence of tokens.
Jev is designed for a different question: “which of five types does this document belong to?” or “how likely is it that this email requires an urgent response?”
Jev’s principle:
do not generate new text when the program really needs to make a small decision.
Therefore, Jev should not be considered a replacement for ChatGPT, Claude, or other generative models. It is a different system component. We covered in more detail how such components are combined around a model, tools, and memory in an article about agent harness for an AI agent.
What answers Jev can return
Instead of free-form text, TypeSafe uses three basic question types. They are called Choice, Score, and Noul.
| Type | What it does | Example |
|---|---|---|
| Choice | Selects one option from a given list | Sales / support / accounting |
| Score | Evaluates an object on a given scale | Low / medium / high priority |
| Noul | Returns the probability that a statement is true | Does the email contain a refund request? |
Choice and Score also return a probability distribution and confidence — the degree of certainty. Noul returns a probability from 0 to 1.
This is important for automation. The program does not have to receive an answer like “I think this is most likely a technical support request” and then try to extract the word from it technical. It immediately receives a value that can be used in a program condition.
Why Jev works so fast
Jev does not generate a response word by word. Possible result forms are defined in advance, and multiple questions about the same state can be computed in parallel.
TypeSafe claims Jev latency of around 70–500 milliseconds. For tasks suited to System One, the company cites an acceleration range of roughly 40–200x compared with frontier LLMs.
The TypeSafe homepage also publishes a separate workflow test showing 193.6× speed and 444.6× cost results. It is important to understand that these are the company’s own measurements on specifically defined System One workloads, not a claim that Jev will be 200 times faster than any LLM at any task.
The practical takeaway is simpler: if a program needs a choice, classification, or evaluation, generating full text is often an unnecessary operation.
How much Jev costs
According to TypeSafe, as of October 1, 2026, the price is $0.042 per 1 million input tokens. Output tokens for Jev are not charged.
The reason for the unusual pricing model is that Jev does not generate arbitrary text. It returns predefined structured results.
For a single request, the difference may be insignificant. But the architecture becomes more interesting with thousands or millions of small decisions: message classification, RAG result validation, agent tool selection, event filtering, and request routing.
Where Jev is especially useful
Jev’s main area of application is where conventional programming if lacks semantic understanding, but running a full LLM seems excessive.
- Request routing. Determine which process, employee, or AI model to send a task to.
- Lead classification. Sort inquiries into sales, support, partnership, spam, or another predefined class.
- AI agent tool selection. Decide whether to search for a file, query the CRM, run a web search, or use a larger model.
- RAG result evaluation. Check whether the retrieved passage matches the question and whether it should be passed to a generative model.
- Prioritization. Assess the urgency of an inquiry, the relevance of a document, or the quality of a retrieved result.
- Model routing. Determine whether a cheaper model is sufficient or the task requires a more powerful LLM.
This approach works well with the architecture we discussed in the article about Skills, RAG, and AI agent routing.
How Jev changes AI agent architecture
A typical system today often sends nearly every decision to one large model. The user wrote a request — LLM. Need to select a tool — LLM again. Need to validate a result — another LLM call. Need to determine the next step — yet another one.
Jev makes it possible to split the work.
Data source → Jev → decision → code / small model / large LLM → action
For example, a customer inquiry comes in. In one request, Jev can determine the inquiry type, urgency, the customer's level of frustration, and whether a specialist needs to be involved. After that, regular code decides what to do next.
If the question is standard, the workflow runs without a large model. If a full response needs to be written, the task is passed to GPT or Claude. If the situation is ambiguous, it can be sent to a manager.
This is a hybrid architecture: an expensive general-purpose model is used where its capabilities are truly needed, while smaller tasks are handled by a specialized component.
Business example: processing incoming requests
Imagine a company that receives inquiries through its website, email, and Telegram. Currently, all messages are sent to a single LLM with a large prompt.
With Jev, the first stage can be structured differently. The system sends the inquiry text and simultaneously asks several questions: which department to route the request to, whether there is commercial interest, how urgent the inquiry is, and whether a full AI analysis is required.
After the response, a regular workflow performs the required action: creates a CRM record, notifies a manager, launches a generative model, or completes automated processing.
For n8n, this scenario can be built using a standard HTTP Request to the TypeSafe API, with Choice, Score, and Noul results used in IF or Switch. This fits well into the classic automation pattern: source → AI processing → decision → CRM / spreadsheet / notification / manager.
Other practical use cases for such systems are covered in the article on AI agents for business automation.
How to connect Jev
TypeSafe provides a REST API and SDK. The official documentation uses the endpoint POST https://api.typesafe.ai/v1/systemone. The request includes two main elements: state — the data to be evaluated, and questions — a set of typed questions.
There is an official Python SDK typesafe-sdk. TypeSafe also publishes an Agent Skill that can be connected to coding agents. A detailed API request example is available in the official Quick Start.
For an existing system, a complete architectural overhaul is usually not required. Jev can be placed in front of the LLM already in use as a classifier, router, or evaluator.
What Jev should not do
Jev is intentionally limited, and that is exactly why it is interesting. It is not intended for writing articles, dialogues, program code, or detailed analytical responses.
The TypeSafe documentation for version jev-1.13 explicitly states that precise math, calculations, and date comparisons are better handled by regular code. The model also works better with short, specific questions than with complex instructions containing multiple independent decisions.
There is another important principle: do not pass the model a huge amount of data “just in case.” First, use regular code or search to select the relevant context, then give Jev a specific task.
In other words, the right architecture is not “let AI decide everything,” but a division of responsibilities between code, a specialized model, and a generative LLM.
What Jev’s independent evaluation showed
On September 29, 2026, an independent research preprint appeared Evaluating and Benchmarking the System One Model Jev. The authors tested Jev 1.13.0 on 37 datasets: classification, routing, text understanding, moderation, legal tasks, and rubric scoring.
In total, they completed 346,009 requests for less than $10. On a number of standard classification tasks, Jev showed very high accuracy, but researchers also found lower quality on some low-resource languages, complex rubrics, and poorly defined categories.
The practical result for binary decisions is especially interesting: the probability returned by the model is useful, but a universal threshold of 0.5 is not suitable for every task. For a production scenario, it is better to tune the automatic-action threshold on your own data.
This clearly shows how Jev should be used in practice: not as a magical “yes/no engine,” but as a fast probabilistic component within standard program logic.
Where to start: a simple MVP
You do not need to rebuild your entire AI project to test Jev. It is enough to find one process where a large model is currently regularly making a small decision.
A good first MVP is handling incoming requests. Take several hundred real examples, define 3–5 decisions currently made by an employee or LLM, and formulate a separate Choice, Score, or Noul for each.
Then compare three metrics: decision quality, latency, and the cost of the current workflow. If the result is suitable, Jev can gradually be moved to other parts of the system.
This approach is especially interesting for complex AI agents and harness systems, where the model repeatedly selects tools and routes. For example, in DeepSeek Harness and other agent environments a separate fast decision layer can be used before calling the main model.
Why Jev may matter more than another large LLM
Jev’s core idea is not that another “smart model” has appeared. The approach itself is more interesting: not to use a generative LLM where the system only needs a small structured output.
The modern AI stack may gradually become similar to conventional software architecture. One component retrieves data, another makes fast probabilistic decisions, a third performs precise calculations, and a powerful generative model is used only for complex analysis or content creation.
If this approach takes hold, the development of AI agents will depend not only on how smart the largest model is. Properly distributing thousands of small decisions between code and specialized models will become just as important.
And this is where Jev looks most interesting: not as a competitor to GPT or Claude, but as a fast dispatcher ahead of them.
If a company already uses AI but too many requests are sent to expensive models, it can start by reviewing a single workflow and determine which decisions make sense to move into a separate fast layer. CenterAI can help evaluate such an MVP and automation architecture.
FAQ
Is Jev an LLM?
TypeSafe places Jev in a new class of System One Models. In practical terms, the main difference is that Jev does not generate free-form text but returns predefined typed decisions.
Can Jev replace ChatGPT or Claude?
No. Jev is designed for classification, selection, scoring, and other small decisions. Generative models are needed for text generation, complex analysis, and long reasoning.
How much does Jev cost?
As of October 1, 2026, TypeSafe lists a price of $0.042 per million input tokens. Output tokens are not charged.
Can Jev be used with n8n?
Yes. The API can be called from an HTTP Request node, and the resulting structured values can be used in IF, Switch, and other workflow nodes.
What is Noul?
Noul is a TypeSafe question type for binary evaluation. Instead of a text “yes” or “no,” it returns a probability from 0 to 1 that a program can compare against a set threshold.
When should Jev not be used?
When you need to write text, perform precise calculations, compare dates, or solve a complex multi-step task. In such cases, it is better to use regular code or a generative model.
Sources and verification
Last verified: 01.10.2026
Key sources: