Jev vs LLMs: A Practical Introduction to TypeSafe AI’s System One Model

In this article we will disscuss abou type safe AI’ first system one model called Jev.

What is System One Model?

As per TypeSafe AI’s definition – a System One model is an AI model designed to make fast, structured decisions by evaluating a given state and returning predefined, typed answers with associated probabilities that software can use directly.

Like an LLM, a System One model can understand natural-language input, but instead of generating free-form text, it produces structured, typed decisions along with their probabilities.

So what is Jev?

Jev is TypeSafe AI’s flagship model and the first System One model.As of now Jev only support text input,ouput and Jev was announced September 14, 2026 and is currently in early access.

Large language models(LLM) are excellent at generating text, code,and conversations. But many software systems don’t need a paragraph of text they need a decision. For example :

Is this transaction suspicious?
Which department should handle this ticket?
Should an agent click, wait, or ask for help?

TypeSafe AI’s Jev is designed specifically for this kind of problem.

• Faster decisions – Jev produces structured decisions directly instead of generating long responses token by token.
• Lower cost – TypeSafe reports significantly lower costs for decision-oriented workloads compared with LLM-based workflows.
• Type-safe outputs – Responses stay within the predefined decision space, making them easier and safer for software to consume.
• Reduced risk of invalid or fabricated outputs – Jev returns decisions from a predefined output space instead of generating unrestricted text.
• Probabilities included – Jev returns probabilities with its decisions, allowing applications to set confidence thresholds or trigger human review.

How Jev Differs from an LLM

Both Jev and large language models can understand natural-language input, but they are designed for different purposes. An LLM is primarily designed to generate content such as text, code, summaries, explanations, and conversations. It produces its response by generating tokens sequentially.

Jev, on the other hand, is designed to make structured decisions. Instead of generating free-form text, it evaluates the given state and returns typed answers together with probabilities.

For example, Imagine an online shopping platform receives this customer message:

"My order was supposed to arrive yesterday, but tracking still says it is at the sorting center. I need it before tomorrow."

An LLM could generate an explanation such as:

Your order appears to be delayed in transit. I recommend checking with the delivery partner or contacting customer support for an updated delivery estimate.

This is useful when the application needs to communicate with the customer.

Jev could instead evaluate the same message and make decisions that the application can use directly:

Issue type:

DELIVERY_DELAY        0.94
LOST_PACKAGE          0.04
WRONG_ITEM            0.01
PAYMENT_ISSUE         0.01

Priority:

HIGH                  0.82
MEDIUM                0.17
LOW                   0.01

Escalate to support:

TRUE                  0.89
FALSE                 0.11

The application could then automatically route the request to the appropriate workflow without first asking a language model to generate and parse a textual response.

Another example is an AI agent deciding what to do next:

Current state: 
 A login page is open. 
 The username has been entered. 
 The password field is empty.

Instead of generating an explanation, Jev could return:

Next action:

TYPE_PASSWORD 0.96 
CLICK_LOGIN   0.02 
WAIT          0.01 
SCROLL        0.01

The key difference is that Jev is not trying to describe what should happen. It is producing a decision that software can act on directly.

When to Use Jev?

Jev is a good fit when your application needs to make a fast, structured decision from a known set of possible outcomes rather than generate free-form text.

Typical scenarios include:

• Request routing – decide which team, service, or AI tool should handle a request.
• Classification – categorize support tickets, logs, documents, alerts, or user inputs.
• Risk assessment – classify an event as low, medium, or high risk.
• AI agent actions – choose between actions such as CLICK, TYPE, SCROLL, WAIT, or STOP.
• Fraud or security triage – decide whether an event should be allowed, reviewed, or blocked.
• Software issue triage – determine whether a bug belongs to the frontend, backend, DevOps, or another component.
• Workflow decisions – decide whether to approve, reject, retry, escalate, or request human review.
• LLM output evaluation – determine whether an LLM response should be accepted, verified, or regenerated.

A simple rule of thumb is: Use an LLM when you need generation. Use Jev when you need a structured decision.

Question Types

A question defines one judgment for a System One model to make about a state, and its answer is the typed value that comes back. Jev supports 3 types of questions :

1. Noul

Noul is Jev’s binary question type, used to return a yes/no decision with probabilities.

For exampe :

State : I have asked three times now. Can I please just talk to a real person?

{
"is_human_escalation": {
"type": "noul",
"instructions": "Is the customer asking for a human agent?"
}
}


Response :

{
  "model": "jev-1.13.0",
  "answers": {
    "is_human_escalation": {
      "type": "noul",
      "noul": 0.99,
      "stats": {}
    }
  },
  "usage": {
    "input_tokens": 292,
    "output_tokens": 25
  },
  "request_id": "playground_12a2dc9dd9f61fd45e3b9cd331cbf86202f",
  "evaluation_time_ms": 123.22871299693361
}

2. Choice

Choice is Jev’s multiple-option question type, used to select the most likely answer from a predefined set of choices.

For example :

State : My running shoes arrived in the wrong size. Can I swap them for a size 10?

{
  "department": {
    "type": "choice",
    "instructions": "Which team should handle this?",
    "criteria": {
      "returns": "Exchanges, refunds, wrong or damaged items",
      "shipping": "Delivery status, delays, lost packages",
      "billing": "Charges, invoices, payment problems"
    }
  }
}

Response :

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "returns",
      "confidence": 1,
      "probabilities": {
        "billing": 0,
        "shipping": 0,
        "returns": 1
      },
      "stats": {}
    }
  },
  "usage": {
    "input_tokens": 359,
    "output_tokens": 38
  },
  "request_id": "playground_12a4a0be1a1d3134b568e426ab1e67d5614",
  "evaluation_time_ms": 111.01627499738242
}

3. Score

Score is Jev’s rating question type, used to assign a value on a defined scale based on the given state.

For example :

State : The export button crashes the settings page in Safari. It works in Chrome, but a few of our customers only use Safari.

{
  "bug_severity": {
    "type": "score",
    "instructions": "How severe is the reported issue?",
    "criteria": [
      "Cosmetic; no impact to functionality",
      "Broken or degraded feature, but workaround exists",
      "Blocking issue; no workaround exists"
    ]
  }
}

Response :

{
  "model": "jev-1.13.0",
  "answers": {
    "bug_severity": {
      "type": "score",
      "score": 1.46,
      "legend": {
        "0": "Cosmetic; no impact to functionality",
        "1": "Broken or degraded feature, but workaround exists",
        "2": "Blocking issue; no workaround exists"
      },
      "confidence": 0.3,
      "probabilities": {
        "0": 0,
        "1": 0.53,
        "2": 0.47
      },
      "stats": {}
    }
  },
  "usage": {
    "input_tokens": 341,
    "output_tokens": 20
  },
  "request_id": "playground_12ac5fa026082114b919b3e203a30f84bab",
  "evaluation_time_ms": 96.0590830000001
}

Testing Jev Model

Jev model is currently available in early access. TypeSafe says it is onboarding developers from the waitlist, and the model can be accessed through its hosted API. Luckily I got access to Jev model thanks to Typesafe AI.

JeJev can currently be accessed through:

• REST API
• Python client SDK
• Javascript SDK

For this demo I’m going to use Python SDK, we use Jev model to analyse a twitter(X) post, state will twitter post

from typesafe_sdk import TypeSafeClient, Noul, Choice, Score


state = """
FastSDCPU is amazing! I generated images on my old Intel laptop
without a dedicated GPU. Performance is much better than I expected.
"""


questions = {
    # YES / NO style decision
    "positive_about_product": Noul(
        instructions="Is the author expressing a positive opinion about the product?"
    ),
    # Select one category
    "sentiment": Choice(
        instructions="What is the overall sentiment of this post?",
        criteria={"positive": None, "neutral": None, "negative": None},
    ),
    # Rate on an ordered scale
    "enthusiasm": Score(
        instructions="How enthusiastic is the author about the product?",
        criteria=["very_low", "low", "medium", "high", "very_high"],
    ),
}


with TypeSafeClient() as client:
    result = client.system_one(state, questions)
    print("Positive:", result.nouls["positive_about_product"].noul)
    print("Sentiment:", result.choices["sentiment"].choice)
    print("Enthusiasm:", result.scores["enthusiasm"].score)

Output

Positive: 0.99
Sentiment: positive
Enthusiasm: 3.8

We can see that Jev model output has decisions based on the state and questions.

Conclusion

Jev introduces a different way to use AI in software. Instead of generating text like an LLM, it makes fast, structured decisions with probabilities. That makes it a strong fit for classification, routing, scoring, and automation workflows where speed, reliability, and constrained outputs matter.