
Most AI applications use a generative language model for every step: classify a ticket, choose a tool, score a document, and write the final response. That approach is flexible, but it also introduces latency, token cost, parsing work, and unpredictable text inside software.
Jev takes a different approach. TypeSafe AI describes it as the first System One model, built to make fast, structured decisions that code can consume directly. This guide explains what Jev AI is, how its typed questions work, where it fits beside an LLM, and where it is the wrong tool. For broader context, see the AI Engineering hub, the LLM agents hub, and our guides to AI agent skills and MCP.
Last Updated: September 22, 2026
Table of Contents
Open Table of Contents
- What Is Jev AI?
- How Jev Works
- The Three Jev Question Types
- Jev vs a Traditional LLM
- A Practical Jev Example
- Where Jev Fits in an AI Application
- Best Use Cases for Jev
- What Jev Cannot Do
- Performance, Cost, and Access
- How to Evaluate Jev Safely
- Frequently Asked Questions (FAQs)
- Conclusion
- References
- YouTube Videos
What Is Jev AI?
Jev is a hosted AI decision model from TypeSafe AI. You provide a state, such as a support ticket, document, event, or JSON record, and define focused questions about that state. Jev returns answers constrained to the types you defined, along with probabilities or confidence fields where the question type supports them.
The simplest mental model is:
State + typed questions -> structured decisions -> application logic
That makes Jev different from a chat model. A chat model produces a string that a person can read. Jev is designed to produce a value that your application can compare, threshold, route, or store without first asking an LLM to format prose as JSON.
TypeSafe calls this class of model System One. The name is inspired by the fast, intuitive side of the System 1 and System 2 distinction popularized by Daniel Kahneman. In software terms, the useful distinction is not psychology; it is that Jev focuses on small, bounded judgments inside a larger workflow while generative models remain better for open-ended writing and reasoning.
Jev is not a replacement for every LLM. It is closer to a decision primitive that can sit next to an LLM, a rules engine, a database, and ordinary application code.
How Jev Works
Jev follows a small contract that is easy to reason about: provide the current state, define the judgments your program needs, then let the program decide what to do with the returned values.
flowchart TD
A[Application state] --> B[Typed Jev questions]
B --> C[Jev System One model]
C --> D[Choice, Score, or Noul]
D --> E{Confidence or threshold}
E -->|High confidence| F[Route, rank, filter, or act]
E -->|Low confidence| G[Ask an LLM or a human]
State
The state is the information Jev evaluates. It can be plain text or structured text such as a JSON object or array. A support workflow might pass the customer message, recent order details, and the relevant policy as one state.
The state should contain the evidence needed for the judgment. If the application asks Jev whether a refund is supported but omits the refund policy, the model cannot recover that missing business context. This is the same engineering rule that applies to any model: make the important evidence explicit instead of hoping the model will infer it.
Typed Questions
A Jev question has an identifier, a type, instructions, and, for Choice or Score questions, a set of possible answers. A good question asks for one narrow judgment:
- Good: “Does this message request a refund?”
- Good: “Which team should handle this ticket?”
- Weak: “Analyze everything and decide what the company should do.”
The narrow form matters because it gives the result a clear meaning. If a decision depends on several independent factors, ask several atomic questions and combine the answers in code. That keeps business policy visible and editable rather than hidden in a large prompt.
Structured Decisions
Jev does not need to generate a paragraph and then have your application parse it. A Choice answer is one of the options you supplied. A Score answer is tied to an ordered rubric. A Noul answer is a probability for a yes-or-no statement.
This does not mean Jev is always correct. A type-safe answer can still be a bad judgment about the input. The benefit is that the failure mode is bounded: your application receives a value in the expected shape and can use confidence thresholds, testing, and human review to control what happens next.
The Three Jev Question Types
Jev’s primitives are intentionally small. Pick the primitive based on the shape of the answer your code needs.
| Question type | Use it when | Example output | Common use |
|---|---|---|---|
| Choice | One option from a list is required | technical plus probabilities | Ticket routing, intent classification, tool selection |
| Score | The answer belongs on an ordered scale | 1.4 on a defined rubric | Severity, urgency, relevance, frustration |
| Noul | A clearly defined yes-or-no probability is useful | 0.92 for true | PII detection, refund request, policy match |
Choice
Choice is appropriate when the options are categories without an inherent order. For example, a support ticket might be routed to billing, technical, account, or other. Include an other option when the list may not cover every possible input.
Score
Score is useful for an ordered rubric. You define levels such as “low”, “medium”, and “high”, and Jev returns a position along that scale with a distribution over the levels. The result can be used as a threshold, but the rubric must be meaningful. A score without clear level definitions is only a number with a label attached.
Noul
Noul is a yes-or-no question expressed as a probability between 0 and 1. For example, 0.96 can mean that the model estimates a strong probability that a message contains an urgent request. A value near 0.5 should be treated as uncertainty, not as a weak version of either answer.
Jev vs a Traditional LLM
The main difference is the interface between the model and the application.
| Concern | Generative LLM | Jev |
|---|---|---|
| Primary output | Free-form text | Typed decision values |
| Application integration | Parse and validate generated text | Consume the defined answer shape |
| Best fit | Writing, explanation, long reasoning, conversation | Classification, routing, scoring, filtering, guardrails |
| Output space | Open-ended | Defined by the question schema |
| Uncertainty | Often requested in prose | Returned as probabilities or confidence fields |
| Latency profile | Depends on model and generated tokens | Optimized for focused decisions |
| Human interaction | Directly useful | Usually a building block inside software |
The choice is not either-or. A support assistant can use Jev to classify a ticket, score urgency, and detect a refund request. Application code can then route the ticket and call a generative LLM only when a customer-facing explanation is needed. This is often a better separation of responsibilities than asking one model to classify, reason, format, and write in a single response.
Our guide to reducing AI and LLM costs covers the broader model-routing idea. Jev makes that pattern more explicit by turning a routing judgment into a first-class model output.
A Practical Jev Example
The following Python example follows the current TypeSafe SDK pattern. It asks three independent questions about one support ticket in one request.
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
ticket = {
"message": "Our production API is failing and we were charged twice. Please refund us today.",
"customer_tier": "enterprise",
}
with TypeSafeClient() as client:
response = client.system_one(
state=ticket,
questions={
"department": Choice(
instructions="Which team should handle `message`?",
criteria={
"billing": "Payment, invoice, or refund issues.",
"technical": "Bugs, outages, or integration failures.",
"account": "Login, access, or account settings.",
"other": "Anything that does not fit the other teams.",
},
),
"urgency": Score(
instructions="How urgent is `message`?",
criteria=["Routine", "Important", "Production blocker"],
),
"refund_requested": Noul(
instructions="Does `message` request a refund?",
),
},
)
# The application owns the action. Jev only supplies typed judgments.
department = response.answers["department"].choice
urgency = response.answers["urgency"].score
refund_requested = response.answers["refund_requested"].noul
if department == "technical" and urgency >= 1.5:
print("Page the on-call engineering team")
elif refund_requested >= 0.9:
print("Open a billing review")
else:
print("Place the ticket in the normal queue")
The important boundary is the final if statement. Jev does not have permission to page an engineer, issue a refund, or change a customer record. It supplies evidence for an explicit policy that your application can test and review.
Where Jev Fits in an AI Application
A useful production design treats Jev as a fast decision layer rather than as the entire assistant.
- Collect state from the request, database, retrieval layer, or tool result.
- Ask atomic questions that map to real application branches.
- Apply confidence gates so uncertain results go to a human or a stronger model.
- Execute ordinary software for permissions, transactions, side effects, and audit logging.
- Call a generative model only when the next step needs prose, code, or open-ended reasoning.
- Record the decision and evidence so you can evaluate errors after deployment.
This architecture pairs naturally with agent systems. In an agent workflow, Jev can decide whether a tool is relevant, whether a retrieved passage should be kept, or whether a request should be escalated. The agent or application remains responsible for planning, tool execution, and user-facing communication. For a larger view of those components, read what an AI agent is.
Best Use Cases for Jev
Ticket and intent routing
When a support system has a stable set of queues, Jev can classify the incoming message before a larger agent sees it. The result can select a prompt, a retrieval index, a team, or a service-level policy.
Guardrails and escalation
Jev can evaluate bounded questions such as whether a prompt appears to request a restricted action or whether a response needs human review. The surrounding system should still enforce the policy; a model output is not a substitute for authorization code.
Ranking and filtering
A retrieval pipeline can use a Score question to rank passages for relevance or filter obviously weak candidates before spending more tokens on generation. This is useful when the candidate set is large and the decision is narrow.
Real-time application decisions
Fast, structured responses can be useful in interactive products where a decision happens on a hot path. Examples include selecting the next tool, choosing a workflow branch, or deciding whether a user action needs a deeper check.
Batch classification
If a data pipeline must label many records, a model that returns a bounded value can simplify downstream storage and validation. The batch still needs representative evaluation, rate-limit handling, and error monitoring.
What Jev Cannot Do
Jev is a poor fit when the output itself is the product. Do not choose it for:
- Writing an email, article, explanation, or code sample.
- Summarizing a long document for a reader.
- Translating between languages.
- Performing exact arithmetic that ordinary code can handle.
- Enforcing permissions, payment rules, or other deterministic policies.
- Processing images, audio, or video in its current documented interface.
Jev also does not remove the need for evaluation. Calibration describes how well probabilities line up with outcomes across a population; it does not guarantee that an individual prediction is correct. Define what confidence means in your domain, measure false positives and false negatives, and keep an escalation path for uncertain or high-impact decisions.
Performance, Cost, and Access
TypeSafe’s launch material reports a 70 to 500 millisecond end-to-end range for Jev, with a published input price of $0.042 per million tokens and free output tokens for decision results. Those are vendor-published figures, and actual latency depends on network distance, request size, batching, rate limits, and the access route you use.
Jev is currently presented as an early-access hosted service. The practical consequence is that you should treat the API contract, limits, and pricing as moving parts. Pin the model alias where supported, keep an evaluation fixture in your repository, and avoid making an irreversible product commitment before measuring your own workload.
How to Evaluate Jev Safely
Start with a narrow task where the answer space is already known.
- Build a representative, privacy-safe evaluation set.
- Define the options and rubrics before looking at results.
- Measure accuracy, calibration, latency, cost, and abstention or escalation rates.
- Compare Jev with a simple rules baseline and with the LLM you would otherwise use.
- Test ambiguous, adversarial, multilingual, and out-of-distribution inputs.
- Set thresholds separately for low-risk routing and high-risk actions.
- Log the state version, question version, model version, answer, and final outcome.
The comparison should measure the entire workflow, not only a model call. A faster prediction that sends more tickets to the wrong queue can make the product slower for users and more expensive for support teams.
Frequently Asked Questions (FAQs)
Is Jev an LLM?
Jev is not positioned as a traditional text-generating LLM. It is TypeSafe AI’s first System One model. It accepts text-based state and typed questions, then returns bounded decisions and probability information rather than a free-form paragraph.
Can Jev generate text?
No. Jev is designed for structured decisions, not for writing, summarizing, translating, or explaining. Pair it with a generative model when the workflow needs natural-language output.
Does Jev eliminate hallucinations?
Jev’s constrained answer space can eliminate malformed or out-of-schema outputs for the defined question. It cannot guarantee that the judgment about the input is correct. Your system still needs evaluation, thresholds, monitoring, and human review for consequential decisions.
What are Choice, Score, and Noul?
Choice selects one option from a list. Score places the input on an ordered rubric. Noul returns the probability that a yes-or-no statement is true. Pick the primitive that matches the value your code needs to consume.
Should I replace my existing LLM with Jev?
Usually no. Use Jev for narrow decisions such as routing, classification, scoring, and guardrails. Keep a generative model for conversation, long-form reasoning, tool planning, and user-facing writing. A hybrid design is often the most practical option.
Is Jev suitable for high-risk decisions?
Do not treat model output as an automatic authorization for high-impact actions. Use Jev as one signal in a system with explicit policy checks, audit logs, human review, and a tested failure mode. The higher the cost of an error, the less you should rely on a single model judgment.
Conclusion
Jev AI is best understood as a typed decision layer for software. It receives application state and focused questions, then returns Choice, Score, or Noul answers that ordinary code can use without parsing generated prose.
The model is compelling when a workflow needs fast, bounded judgments: route a ticket, score urgency, filter retrieval results, or decide whether to escalate. It is not a chatbot, a rules engine, a permissions system, or a replacement for a general-purpose LLM. The right design combines Jev’s structured decisions with application code, deterministic policies, and generative models where each tool is strongest.
References
- TypeSafe AI: Introducing System One Models and Jev
- TypeSafe AI documentation: Introduction
- TypeSafe AI documentation: Primitives
- TypeSafe AI documentation: Quick start
YouTube Videos
- “JEV: How It Works and What You Can Build” - Riley Brown [https://www.youtube.com/watch?v=o1CogAtWdBk]