What is Jev? Why has it been called the “ChatGPT moment” for classification models?

Abstract

In mid-September 2026, the startup TypeSafe AI announced Jev, an AI model designed for fast, low-cost classification and decision-making. The model quickly went viral, attracting considerable attention from the AI research and developer communities. Many developers experimented with Jev and built and shared a range of applications. Jev is believed to have numerous potential applications and may replace large language models (LLMs) in classification and decision-making tasks. This article explains what Jev is, why its release has been described as the “ChatGPT moment” for classification, how to use it through an application programming interface (API), representative use cases, and limitations to consider before deployment.

1. What is Jev, and why has it attracted attention?

1.1. Why are LLMs not optimized for simple decisions?

Large language models are fundamentally text-generation models conditioned on an input context. Given a context, a model generates successive tokens based on the probability distribution of the next token.

This characteristic gives LLMs several disadvantages. First, they can hallucinate, generating content that does not correspond to reality, particularly when they encounter contexts that are rare in their training data. Second, for tasks that require only a classification decision, using an LLM can be cumbersome and poorly matched to the nature of the problem: the output is free-form text that must be parsed before software can use it.

1.2. Jev: an AI model for fast decision-making

Jev was developed by TypeSafe AI, a startup headquartered in San Francisco, United States. TypeSafe was founded in 2024 by Diogo Almeida, who previously contributed to the development of instruction-following training methods at OpenAI. According to TypeSafe AI’s introductory blog post, Jev is the first model in the “System One” category: a class of AI models designed to make fast, structured decisions that software can consume directly.

The term “System One” derives from a concept popularized in Daniel Kahneman’s book Thinking, Fast and Slow. Kahneman, an Israeli-American psychologist, received the Nobel Memorial Prize in Economic Sciences in 2002. In Kahneman’s account, System One is fast, automatic, intuitive, and relatively effortless, whereas System Two is slower, deliberate, analytical, and dependent on focused attention.

Jev was developed to address the limitations of LLMs in classification tasks. Unlike an LLM, Jev does not generate text; it is optimized for decision-making. Jev can be understood as a function call: the input is unstructured data, while the output is a structured classification result with a predefined data type and a probability for each possible option.

Figure 1:compares how an LLM and Jev approach the same classification problem.

According to TypeSafe, Jev is particularly useful when embedded at decision points within a workflow. In agentic AI applications, for example, Jev can select which model should execute a task (model routing) or check inputs and outputs (guardrails), at substantially lower cost and latency than an LLM.

1.3. How did businesses handle classification before Jev?

Classification is a classic problem in artificial intelligence. An AI model might, for example, classify emails as spam or non-spam, or classify comments under a social media post as abusive or non-abusive. Many problems addressed by AI can be formulated as classification tasks. Even an LLM’s process of predicting the next token from the input context is, in essence, a classification problem: the context is mapped to one token in the vocabulary, with each token treated as a class.

Classification problems have typically been addressed in one of two ways:

• Training a dedicated classifier. This involves training models such as Naïve Bayes, support vector machines (SVMs), or recurrent neural networks (RNNs) from scratch, or fine-tuning pretrained language models such as BERT on labeled examples. This approach can deliver high accuracy for a specific task, but preparing data and training the model require considerable effort. A model trained for one task usually cannot be reused for another, so the data-preparation and training process must be repeated.
• Prompting general-purpose generative AI models such as GPT, Claude, or DeepSeek. This approach does not require a separate training dataset or model-training process; instead, it relies on clear and comprehensive instructions. However, general-purpose LLMs are large, often slow, and expensive. They may also hallucinate or return incorrectly formatted structured data, such as invalid JSON. In addition, numerical values reported by an LLM as probabilities or confidence scores are still generated text and may not accurately reflect the likelihood that an answer is correct. Finally, using a deep-reasoning model (a System Two-style model) for a simple classification problem can be disproportionate to the task.

1.4. Why is Jev considered the “ChatGPT moment” for classification?

Soon after TypeSafe announced Jev, the model attracted significant attention from the AI research and application communities. Developers quickly built and shared a wide range of applications and use cases. For example, the Made with Jev website had collected more than 850 projects and applications built with Jev in roughly one month. In his article, researcher Sebastian Raschka likened TypeSafe Jev’s emergence to the “ChatGPT moment” for classification: for the first time, a broad range of text could be classified at low cost without fine-tuning a separate model for each task.

Because classification is not new to AI, readers may wonder why Jev went viral. TypeSafe’s documentation and expert assessments point to several main reasons:

• Jev can classify many types of data without model fine-tuning. In this respect, it resembles an LLM, which can perform varied tasks-such as translation, code generation, and classification-by following instructions and using contextual information.
• Jev’s classification accuracy is reported to be comparable to that of frontier LLMs.
• Jev’s output consistently conforms to a predefined schema. TypeSafe states that Jev cannot return an answer outside the declared options, unlike an LLM that may occasionally generate malformed JSON or an undefined label.
• Jev is trained to calibrate values such as option probabilities and output confidence scores. According to TypeSafe, higher confidence should correspond to a higher likelihood of correctness, allowing developers to set thresholds for automatic processing or escalation to a human reviewer.
• Jev can execute classification tasks much faster than LLMs-by up to hundreds of times, according to TypeSafe. Each Jev call reportedly takes approximately 70–500 milliseconds, making it 40–200 times faster than leading LLMs, which take 3–329 seconds for an end-to-end call. On TypeSafe’s workflow benchmarks, Jev was 193.6 times faster and 444.6 times less expensive.
• The TypeSafe Jev API is inexpensive and charges only for input tokens; output tokens are free. The price is USD 0.042 per million input tokens. By comparison, input tokens for popular LLMs cost between USD 0.20 and USD 10 per million tokens, while output tokens are often approximately five times as expensive as input tokens.

These characteristics have led developers to use TypeSafe Jev in place of LLMs for classification and lightweight decision-making within processing pipelines-tasks that need only a System One-style model.

1.5. Inside Jev and the Race Involving OpenAI, Cloudflare, and AWS

TypeSafe Jev is a closed model: its weights are not published, and its internal architecture is unknown. Consequently, details about its architecture and training process remain unavailable beyond what TypeSafe has disclosed on its website. According to the company, Jev is trained using a method called Reinforcement Learning for Calibrated Decisions (RLCD).

Some experts, including Sebastian Raschka, have speculated that Jev is a relatively small model, potentially similar to encoder models such as ModernBERT, which could explain its low latency. Under this view, much of the model’s performance may derive from its training data and the training method described above. Researchers and engineers are actively investigating Jev’s underlying architecture, and a “DeepSeek moment” for Jev—meaning a clearer understanding of how the model works-may emerge in the near future.

The competition has already begun. Approximately two weeks after Jev’s release, Cloudflare announced Clef, a family of open-weight models licensed under Apache 2.0 and built on Qwen. Cloudflare reported that Clef outperformed Jev on three of TypeSafe’s four benchmarks. Amazon Web Services (AWS) released Strands Decider 2B, a model small enough to run locally. On October 6, 2026, OpenAI launched the Decisions API, a service offering the same three question types-whether a proposition is true, selecting an option, and scoring-and supporting image inputs, at a price of USD 0.10 per million input tokens.

2. Trying Jev: a quick guide for developers

Because Jev is a closed model, it is currently accessible only through the API provided by TypeSafe. In addition to the core API and official SDKs for Python and JavaScript/TypeScript, Jev is integrated with platforms such as the Vercel AI SDK, Cloudflare Workers AI, and the LangChain library. The API endpoint is https://api.typesafe.ai/v1/systemone.

2.1. Three question types: Yes/No, Choice, and Score

Each Jev API call has two main components: a state-the data to be evaluated, which may be text, a JSON object, or a conversation history – and a set of questions. Questions within a single call are evaluated in parallel against the same state, so adding questions has little effect on response time. TypeSafe defines three primitive question types for three different kinds of decision-making problem:

• Noul: a yes/no question (binary classification), such as whether an email is spam. The result is a number between 0 and 1 representing the probability that the answer is “yes.”
• Choice: selects one option from a user-defined list of up to 255 options. For example, a support request might be classified as billing, technical, sales, or other. The result contains the selected option, the probability of each option (which sums to 1), and a confidence value calculated from the dispersion of the probability distribution.
• Score: assigns a score on an ordinal scale defined by the user. For example, a frustration scale might assign 0 to “calm,” 1 to “anxious,” and 2 to “angry.” A score of 1.8 is the probability-weighted mean of the scale values (each value multiplied by its probability), placing the result between “anxious” and “angry.” This score is not a confidence percentage.

Figure 2. The three types of questions in the Jev API and their corresponding outputs (illustrative values).

In addition to these three types, Jev version 1.14, released on October 14, 2026, added the Box question type for identifying an object’s location in an image. Image input remains experimental. By default, each API call accepts up to 64,000 tokens, with a limit of 32,000 tokens per question.

2.2. Example: automatically classifying customer support requests

The following example demonstrates a Jev API call using the Python SDK to classify a customer support request. A single call asks three different types of questions about the same customer message.

Step 1 –  Install the SDK and configure the API key:

pip install typesafe-sdk
export TYPESAFE_API_KEY="<Your API key>"

Step 2 – Call the API with a state and three questions:

from typesafe_sdk import TypeSafeClient, Noul, Choice, Score

ticket = (
    "I was charged twice for the same order. "
    "So frustrating! Please refund the extra charge."
)

# TypeSafeClient automatically reads the API key from the TYPESAFE_API_KEY environment variable
with TypeSafeClient() as client:
    response = client.system_one(
        model="jev-latest",
        state=ticket,
        questions={
            "wants_refund": Noul(
                instructions="Does the customer want a refund?",
            ),
            "department": Choice(
                instructions="Which department should handle this request?",
                criteria={
                    "billing": "Billing, invoices, charges",
                    "technical": "Technical issues, system errors",
                    "sales": "Sales consultation, quotes",
                    "other": "Other requests",
                },
            ),
            "frustration": Score(
                instructions="How frustrated is the customer?",
                criteria=["Calm", "Anxious", "Angry"],
            ),
        },
    )

print(response.model_dump_json())

The response is JSON in the following form (illustrative values, shortened for readability):

{
  "model": "jev-1.14.0",
  "usage": {
    "input_tokens": 475,
    "output_tokens": 80
  },
  "answers": {
    "wants_refund": {
      "type": "noul",
      "noul": 0.98
    },
    "department": {
      "type": "choice",
      "choice": "billing",
      "confidence": 1,
      "probabilities": {
        "billing": 1,
        "technical": 0,
        "sales": 0,
        "other": 0
      }
    },
    "frustration": {
      "type": "score",
      "score": 1.96,
      "confidence": 0.95,
      "legend": {
        "0": "Calm",
        "1": "Anxious",
        "2": "Angry"
      },
      "probabilities": {
        "0": 0.01,
        "1": 0.01,
        "2": 0.98
      }
    }
  }
}

As shown, each answer matches the declared data type and includes a probability distribution, allowing developers to use the results directly in conditional statements. For example, a system could automatically route a request to the billing department only when confidence exceeds 0.8; otherwise, it could send the request to a staff member for review. TypeSafe refers to this design pattern as confidence-gated routing.

The API can also be called directly over HTTP, without using an SDK:

curl https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "I was charged twice for the same order...",
    "questions": {
      "wants_refund": {
        "type": "noul",
        "instructions": "Does the customer want a refund?"
      }
    }
  }'

3. What can jev offer businesses?

According to TypeSafe’s use-case map, Jev is suitable for any step in a software system where the possible answers can be enumerated in advance. Applications include classification, detection, scoring, routing, search, ranking, verification, and field extraction. Jev’s potential applications can be grouped into the following categories.

3.1. Workflow automation: customer service, insurance, banking, and legal work

This is the most direct category of application: replacing LLM calls used for classification in high-volume, repetitive background workflows. TypeSafe’s use-case map lists scenarios across several industries:
• Customer service: classify support tickets; extract issues from calls; detect urgency, churn risk, or refund requests; and route requests to the appropriate department.
• Insurance: classify claims and flag complex cases or suspected fraud for prioritization and escalation.
• Finance and banking: assess Know Your Customer (KYC) files, match entities, prioritize alerts, and refer suspicious cases to financial-crime investigation teams.
• Legal and compliance: classify documents and detect missing clauses or prohibited content.
• Recruitment, sales, and content moderation: score candidates against criteria, assess the suitability of prospective customers, detect harmful content and spam, and decide whether to allow, flag, or block content according to severity.

Low cost makes previously uneconomical tasks feasible-for example, a community project could classify 500 emails for approximately 3.5 cents. Importantly, Jev does not eliminate the roles of LLMs or conventional code; instead, it redistributes the work. Jev handles rapid judgments, code applies business rules, and LLMs focus on content generation (Figure 3). In the refund example above, Jev identifies the responsible department and the customer’s frustration level, code checks eligibility for a refund, and an LLM drafts the response to the customer.

Figure 3. Division of responsibilities among Jev, conventional code, and an LLM in a workflow.

3.2. Making AI agents faster, cheaper, and easier to control

AI-agent loops contain many points at which a rapid decision is needed: which model to use, whether a command should be allowed to execute, and which tool results should remain in the context, among others. If every decision requires an LLM call, latency and cost rise quickly as the number of steps increases. Jev is designed to handle these decision points (Figure 4):
• Model routing: Jev can select an appropriate model for each run according to user-defined criteria. The probability and confidence values can be stored in the agent’s state.
• Guardrails for tool calls: developers can use Jev to inspect each tool call, such as a Bash command, and block risky commands before execution. Its low cost and latency make it practical to check each agent action.
• Context filtering and compaction: the open-source Fast Jev Compaction plugin for Claude Code uses Jev to score tool results and decide whether to keep, truncate, or discard them, rather than summarizing them with an LLM.
• Universal verification: prompts, reasoning traces, tool calls, and LLM outputs can be checked for jailbreaks, prompt injection, incorrect citations, or hallucinations.

Figure 4. Decision points that Jev can handle in an AI-agent loop.

3.3. Processing large data repositories at low cost

At USD 0.042 per million tokens, applying an AI model across a large data repository can be cost-effective. Jev can support semantic search, reranking text chunks in retrieval-augmented generation (RAG) systems, bulk document labeling, and the extraction of semantic features for use by conventional machine-learning models. For example, the pg-jev project allows natural-language filtering conditions to be written directly into PostgreSQL queries, while SQL handles the remaining operations. In Sebastian Raschka’s experiment, Jev classified all 25,000 movie reviews in the IMDb dataset in approximately 22 minutes at a cost of less than USD 0.65.

3.4. Applications requiring immediate responses

Latency measured in milliseconds opens up applications requiring immediate responses that are difficult for LLMs to support. TypeSafe illustrates this by using Jev to play Doom at 10 queries per second for approximately USD 7 per hour. The developer community has also built demonstrations including an agent that plays Super Mario Bros., an agent that completes Minecraft, drone control in the MuJoCo simulation environment, and Jev Ultrafast, a web-browsing agent in which Jev selects each action while a small LLM handles text input.

3.5. Opportunities for Vietnamese businesses and the public sector

In our view, System One-style models such as Jev have considerable potential for digital-transformation initiatives in Vietnam. Potential applications include classifying and routing citizens’ feedback and petitions to the appropriate agencies; classifying administrative-procedure dossiers; screening insurance claims; and providing a guardrail layer to check the inputs and outputs of virtual assistants for public services. However, these applications require careful evaluation of performance on Vietnamese-language data. Data-security and data-storage requirements must also be considered when using an API service hosted abroad.

4. Should You Use Jev? Considerations Before Deployment

Jev represents a new approach: rather than using a general-purpose generative model for every task, software decision points are assigned to a specialized model that is fast, inexpensive, returns outputs in the required structure, and provides probabilities. If an LLM plays the role of “System Two” – slow, in-depth reasoning – Jev plays the role of “System One,” or rapid reflexive judgment. The two model classes complement rather than replace one another.

Nevertheless, several considerations should be taken into account when evaluating Jev:

• Closed model: its architecture, training data, and training algorithms have not been disclosed. Users depend on a single provider and must send data externally, which is an important consideration when handling sensitive information.
• No text generation: Jev cannot write responses, produce summaries, or explain its reasoning. Questions that depend on one another – where the result of one question is needed to formulate the next – must be split into multiple calls.
• Probabilities are not guarantees: calibration is measured across a set of predictions and does not guarantee that any individual answer is correct. “No hallucinations” means that output conforms to the schema; it does not mean the content is always correct.
• Public evidence for Vietnamese-language performance is not yet available: performance should be carefully evaluated on real-world data before the model is incorporated into a product.
• A practical recommendation for development teams is to start with an existing classification or routing call whose possible answers can be enumerated in advance. Compare Jev with the current solution on the same labeled dataset, including ambiguous cases, and measure accuracy, end-to-end latency, and total cost comprehensively, including retries and fallback mechanisms.

Whether or not Jev becomes a new standard, the successive emergence of similar products from OpenAI, Cloudflare, and Amazon suggests that major companies are increasingly prioritizing the separation of the “decision-making” layer from the “content-generation” layer. This trend is likely to influence how AI systems are built in the near future.

References: 

1. Diogo Almeida. Introducing System One Models & Jev. TypeSafe AI Blog, September 15, 2026. https://typesafe.ai/blog/introducing-system-one-models-and-jev
2. TypeSafe Docs. Use case map. https://docs.typesafe.ai/concepts/use-case-map
3. Sebastian Raschka. Language Models for Text Classification: From Bag-of-Words to Jev. Ahead of AI, September 29, 2026. https://magazine.sebastianraschka.com/p/classifier-history-and-jev
4. Building a Harness with Jev. LangChain Blog, September 17, 2026. https://www.langchain.com/blog/building-a-harness-with-jev
5. Bilgin Ibryam. Jev and LLMs: who does what? The Generative Programmer, September 20, 2026. https://generativeprogrammer.com/p/jev-and-llms-who-do-what
6. TypeSafe Docs. Quickstart; Primitives: Noul, Choice, Score. https://docs.typesafe.ai/introduction/quickstart
7. TypeSafe Docs. Models. https://docs.typesafe.ai/models
8. Made with Jev – a collection of projects built with Jev. https://madewithjev.com/
9. ChatGPT co-creator launches TypeSafe AI with Jev. VKTR, September 16, 2026. https://www.vktr.com/ai-platforms/chatgpt-cocreator-launches-typesafe-ai-with-jev/
10. Let’s Data Science. OpenAI Jev rival in three weeks – TypeSafe raised 870 million (October 2026). https://letsdatascience.com/blog/openai-jev-rival-three-weeks-typesafe-raised-870-million