What Is Jev, TypeSafe AI’s System One Model?

Jev is TypeSafe AI’s first System One model: an AI model that evaluates context and returns structured decisions that software can use directly. Its outputs include choices, scores, and yes-or-no probabilities. Developers define the questions and possible answers, then use ordinary code to decide what happens next. TypeSafe documentation

For engineers building AI-powered products, that interface addresses a familiar problem. Many workflows need a small judgment—such as which team should handle a message—before the application can continue. A paragraph explaining the answer can be unnecessary overhead when the next step needs a specific value.

Jev focuses on that decision layer. Understanding where it fits starts with its input and output contract.

What Does “System One” Mean?

TypeSafe uses System One for models designed to make fast, focused judgments inside software. The name draws on the distinction Daniel Kahneman popularized between intuitive System 1 thinking and slower, deliberate System 2 thinking. It describes the product’s intended role; it does not establish that the model thinks like a human. System One documentation

An application sends Jev a state, which contains the context to evaluate, and a set of typed questions. The model returns answers within the declared answer spaces. State can include natural-language text and structured text data, such as JSON objects.

For example, a support application might supply a customer message and ask which department should receive it. The answer becomes an input to the application’s routing logic.

How Jev Works: State, Questions, and Application Logic

A Jev integration has three practical parts:

1. Prepare the state. Include the information needed to make the judgment.
2. Define focused questions. Specify what to evaluate and how the answer should be represented.
3. Handle the answers in code. Apply routing rules, thresholds, permissions, and fallback behavior.

Several questions can be evaluated in parallel against the same state. Each is evaluated independently, so the application combines their answers when a decision depends on multiple factors. TypeSafe recommends decomposing broad judgments into smaller questions rather than asking the model to resolve an entire workflow at once. Introduction and question design

This makes the surrounding software architecture important. The developer still owns the business process, including what constitutes an acceptable decision and what requires review.

Jev’s Three Question Types

Choice: Select from Defined Options

Choice selects one option from a set you provide. It returns the selected option, probabilities across the options, and a confidence value. Examples include classifying a document or selecting a support department.

A support workflow might offer technical, billing, and other. Including a fallback option matters when the categories do not cover every possible message. The current documentation supports up to 255 options per Choice question. Choice reference

Score: Evaluate against an Ordered Rubric

Score evaluates the state against ordered levels you define. It returns a score, a probability distribution across the levels, and confidence. The score can be fractional, so it need not equal one of the rubric’s integer level numbers.

For example, a document-review workflow could define levels for relevance: unrelated, partially relevant, and directly relevant. Explicit descriptions make the intended scale clearer than simply asking for an unspecified rating. Score reference

Noul: Estimate Whether a Statement Is True

Noul returns a value between 0 and 1 representing the probability of a yes-or-no judgment. A question might ask whether a message explicitly requests a refund.

Unlike Choice and Score, Noul does not return a separate confidence field. Its probability conveys uncertainty: values near 0.5 indicate an unclear judgment. Noul reference and confidence documentation

Jev vs. a Generative LLM

LLMs can also return schema-constrained outputs. Jev’s distinction is its specialized decision interface and training objective, rather than the mere ability to produce structured data.

TypeSafe describes its training approach as Reinforcement Learning for Calibrated Decisions, or RLCD. The aim is to make predicted probabilities reflect how often outcomes actually occur across groups of predictions. Calibration is an empirical property to evaluate; it does not make every individual answer correct. TypeSafe’s AI primer

Does Jev Eliminate Hallucinations?

TypeSafe’s launch announcement uses strong language about hallucination prevention. The specific guarantee it describes concerns output structure: the model’s answers stay within the declared types and answer spaces. That is different from guaranteeing that the chosen answer is factually correct. Official announcement

A model can choose a valid department and still choose the wrong department. It can also assign a high probability to an incorrect judgment. TypeSafe’s own documentation explicitly distinguishes calibration from certainty about an individual answer. System One documentation

Confidence also needs careful interpretation. For Choice and Score, it is calculated from the returned probability distribution. It summarizes how concentrated that distribution is; it is not an independent verification of the result. Thresholds should be tested against representative examples from the application’s domain. Confidence documentation

A Practical API Example

Here is an illustrative request for routing a healthcare software support message. It uses fictional content and has not been executed:

{
  "model": "jev-latest",
  "state": "The staff scheduling page will not load after I sign in.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which support team should receive this message?",
      "criteria": {
        "technical": "Software errors, failed pages, or access problems",
        "billing": "Invoices, subscription charges, or payment questions",
        "other": "Requests outside those categories"
      }
    },
    "scheduling_related": {
      "type": "noul",
      "instructions": "Does this message concern the staff scheduling feature?"
    }
  }
}

The documented endpoint is POST https://api.typesafe.ai/v1/systemone. Requests use a bearer API key, and answers are returned under the question identifiers. TypeSafe provides a playground and client SDKs for trying the interface. Official quick start

In this proposed design, application code would inspect the routing answer, send uncertain cases to manual triage, and attach the scheduling classification to the ticket. Selecting a department would not grant the model permission to change a schedule or modify a record.

Speed, Pricing, and Current Limits

TypeSafe reports end-to-end response times of 70–500 milliseconds in its launch material. It also acknowledges that its published latency evaluations generally ran near its West Coast service and that its largest reported gains are toward the upper end of expected real-world results. These are company-reported measurements, not a latency guarantee for every deployment. Launch performance discussion

As checked on October 11, 2026, the official model documentation lists:

• Model: jev-1.13.0, also referenced by jev-latest.
• Input pricing: $0.042 per million tokens; output tokens are free.
• Context limits: 64,000 tokens per request, with a separate 32,000-token limit for the state plus the longest question.
• Input support: Text only; image, audio, and video inputs are unsupported.

Aliases can move to newer versions. If an application’s thresholds depend on evaluated model behavior, pinning a version makes upgrades easier to control. Verify pricing and limits before deployment. Current models reference

Where Jev Fits in a Software Architecture

TypeSafe documents patterns such as intent routing, confidence-gated routing, and composite scoring. These organize model judgments into larger systems while leaving orchestration in code. Architectural patterns

For a healthcare SaaS product, a reasonable first experiment would be an administrative support workflow using synthetic or appropriately approved data. My proposed evaluation would compare Jev with existing rules and an LLM-based classifier on the same labeled messages. Measure routing accuracy, uncertain-case coverage, latency, and cost before introducing automatic handling.

The architectural value is the separation of responsibilities: the model provides a bounded judgment, and the application determines its consequences. That gives engineering teams a smaller behavior to evaluate while retaining control of the workflow.

For more about my work in healthcare SaaS, architecture, and AI-enabled engineering, visit my personal portfolio.