What Is Jev? TypeSafe AI's System One Model, Explained

XJev is an AI model from TypeSafe AI that makes decisions instead of writing text. You send it data and questions with fixed answer options, and it returns one answer per question with a probability, in under a second. It is a model for programs, not for people: there is no chat, and the answer is numbers for code to act on. TypeSafe released Jev on September 15, 2026, and calls it the first System One model.

Jev is useful to anyone who builds software with AI inside. In a product, AI spends most of its time answering short questions rather than writing text: is this email urgent, is this command safe to run. Jev is built only for such questions. It answers in about a tenth of a second, and with every answer it says how sure it is. When it is sure, the program acts on its own. When it is not, the case goes to a person. This article covers how Jev works, when it beats the small LLM you already use as a classifier, what a System One model is, how to use it in an AI agent, and where it fails.

🎯 Quick answer

Jev is a decision-making AI model from TypeSafe AI, released on September 15, 2026. A program sends it data and questions with fixed answer options, and Jev returns an answer with a calibrated probability in about 100 ms. It writes no text, so it does not replace an LLM: code uses it for repeated small decisions, acting on confident answers and passing unclear ones to a person.

What Is Jev?

Jev is a model that a program calls the way it calls a function: state in, typed answers out. It picks among options you define and attaches a probability to each one, so the result goes straight into code without any parsing. An LLM can make the same decisions, but it takes seconds per call, bills every generated token, and returns text your program still has to parse and check. Jev answers in well under a second, returns a value in the format you defined every time, and its probability is trained to match how often the answer is correct.

Jev is a hosted API. TypeSafe has not published weights; the model runs on TypeSafe's servers. The current version is jev-1.13.0; the alias jev-latest points to it.

Jev Specifications

Source: TypeSafe documentation and launch post, checked on September 18, 2026.

Jev Pricing

Jev is priced per input token: $0.042 per million, or $42 per billion in TypeSafe's notation. Output tokens are free. TypeSafe explains that an answer is a small set of probabilities, so there is almost nothing to charge for on the output side. The model is in early access, and the price applies to everyone who has a key.

For comparison, input tokens for frontier LLMs cost from $0.20 to $10 per million, and output tokens cost several times more. TypeSafe's home page claims that Jev is "444.6x cheaper". In its launch post, the company adds that this figure comes from its own workflow tests, is the high end of what to expect, and that it cannot prove the price is not subsidized.

Two Ways to Use Jev

The first way needs no LLM at all. Your code reaches a decision point, asks Jev, and branches on the number that comes back. An alert arrives, the code asks "does this need a person right now", gets 0.93, and pages the on-call engineer. There is no chat and no agent in this chain, just your software and one call.

The second way pairs Jev with an LLM inside an agent. The LLM plans and writes, and Jev answers the small questions along the way: which model should take this request, is this command safe to run. The agent stays smart, and the decisions become fast and cheap. How Does Jev Work below shows the first mode; Does Jev Work with AI Agents covers the second.

How Does Jev Work?

A request to Jev has a state and one or more questions. The state is the content to evaluate: a string, a JSON object, or an array of text values. Each question has an ID for your code, a type, and instructions written as a full question. Here is a request an agent could send after an alert from a monitoring service:

{
 "model": "jev-latest",
 "state": "checkout-api returned HTTP 503 on 4 of the last 5 checks from eu-west. Other regions OK. Last deploy: 22 minutes ago.",
 "questions": {
   "needs_human_now": {
     "type": "noul",
     "instructions": "Does this alert describe an outage that affects customers right now?"
   }
 }
}

The answer comes back under the same ID:

{ "answers": { "needs_human_now": { "type": "noul", "noul": 0.93 } } }

According to this answer, there is a 93% probability that the alert needs a person now. The agent compares the number with its own threshold and either pages the on-call engineer or files the alert for the morning report. The value here is an example, not a live call.

This request format is Jev's own. Almost every LLM API follows the OpenAI style or the Anthropic style: a messages array with roles, and a text reply in the response. Jev has neither. The request carries a state and a questions object, and each question has a type, instructions, and criteria. The response carries an answers object where each answer is shaped by its type. This is why agents and gateways need a small adapter for Jev instead of a model name swap.

Three question types cover the decisions code usually makes with an if, a switch, or a threshold:

• Noul: a yes-or-no question. Returns the probability that the answer is yes. Near 1 is yes, near 0 is no, near 0.5 is undecided. No separate confidence; the probability is the answer.
• Choice: one option from a set you define, up to 255. Returns the selected option, the probability of every option, and a confidence score (how sure the model is of its pick, from 0 to 1).
• Score: a position on a scale of 2 to 10 levels described in words, such as "no impact", "one region affected", "most customers affected". Returns the score, the probability of each level, and the same confidence score.

Confidence is TypeSafe's own term: the second number that comes with Choice and Score answers, saying how definite the pick is, from 0 to 1. It is computed from the shape of the probabilities: when almost all the probability sits on one option, the model is sure and confidence is near 1; when the probability is split across several options, the model is hesitant and confidence is low. Ordinary LLM APIs return no such field: a chat model can be asked how sure it is, but the number it writes is not tied to its accuracy. TypeSafe suggests three ranges in code: act automatically at high confidence, ask for a check at medium, do not act at low. One caution: confidence describes how sure the model is, not whether it is right. A confidence of 1.0 can still sit on a wrong answer.

You can ask many questions about the same state in one request. Each is evaluated independently and at the same time, so adding a question adds only its tokens to the cost and almost nothing to the response time. TypeSafe recommends sending every question you might need at once and letting the code decide what matters. The limit is 64,000 tokens for state and questions together, and the practical advice is to keep the state small: accuracy drops when it contains content the questions do not need.

TypeSafe's name for this class of model is a System One model: it reads unstructured input and returns typed decisions with calibrated probabilities instead of text. The training method, which TypeSafe calls reinforcement learning for calibrated decisions (RLCD), rewards a probability that matches how often the answer turns out correct, while a chat model is rewarded for a reply people like. At the time of writing, Jev is the only public System One model, so the term and the product describe the same thing.

Why Use Jev Instead of a Small LLM Classifier?

A small LLM behind chat completions already classifies fine, so a switch has to pay for itself. Here is what using Jev actually buys.

You stop reviewing everything. Jev returns a probability for every option rather than one label, so your code can finally tell the sure answers from the shaky ones and treat them differently: act on its own above the bar you set, ask a person below it, with a separate bar for each action.

For example, a ticket that comes back as billing at 0.97 gets routed and closed. Billing at 0.51 against technical at 0.46 lands in a human queue, because that split means the case is genuinely unclear. The review queue shrinks to the close calls, and the share of work that runs alone becomes a threshold you tune, not a property you wait for from some future model.

Decisions land inside the request path. 70 to 500 ms is fast enough to answer before the request proceeds, so the check gates the action instead of trailing it in an async queue. One call also carries as many questions as you need, all evaluated at the same time: ten questions, the time of one, and TypeSafe reports 12.2x lower cost on its tested workflows from batching this way.

The meter barely moves. Input, $0.042 per million tokens. Answers, free. A decision over 400 tokens of state and questions, about two thousandths of a cent; a night of three thousand such decisions, five cents. At that price a check can sit on every ticket and every tool call without showing up in the bill.

Jev vs LLM vs Classifier: Comparison Table

This table adds the third tool, the trained classifier, and compresses the choice among the three into one view.

What the table shows: which tool to pick

• Classifier: pick it when the categories are fixed for months and you have thousands of labeled examples. Fastest and cheapest per call. Tasks: spam filtering, sentiment tagging, product categorization.
• LLM: pick it when the result is text, code, or reasoning that a person will read. The only one of the three that writes. Tasks: replies, summaries, coding, open-ended analysis.
• Jev: pick it when the answer is one of a few known options, the decision repeats many times, and the questions change too often to train a classifier. Under a second, no training data, probability attached. Tasks: routing, filtering, risk checks, scoring.

Does Jev Work with AI Agents?

Yes, but not as the agent's main model. An agent has to write things all the time: a plan, a tool call, a reply to the user, code. Jev cannot write anything at all, so an agent running on Jev alone would just stay silent. So the setup is always a pair: the agent thinks and writes on a normal LLM, and Jev answers the small questions along the way.

Those questions come up at every step. Is this message worth acting on? Is this command safe to run? Which model should take the request? Is the task finished? Today each one costs a full LLM call, several seconds and output tokens every time. Jev answers in about 100 ms, and the agent's code decides what to do with the number.

Four Ways to Connect Jev to an Agent

• LangChain. Install langchain-typesafe and set TYPESAFE_API_KEY. TypeSafeClassifier takes a state and questions through .invoke(). The state accepts LangChain messages, so the agent's existing context goes in as it is. Two middlewares ship with the package: ModelRouterMiddleware picks the model for a run from the user's first message, and AutoModeMiddleware checks tool calls with Jev and blocks the risky ones before they execute.
• The official agent skill, for Claude Code and Codex. Run claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe@typesafe-ai. For other agents, npx skills add typesafe-ai/skills --skill typesafe-ai. The skill teaches a coding agent to write correct Jev calls, one request carrying every question instead of one call per question. It does not place Jev inside the agent's own loop.
• Plugins for OpenClaw, both community projects rather than TypeSafe's own. openclaw-plugin-typesafe-ai triages group chat messages before the loop starts, scores tool calls for risk from 1 to 5 and asks the operator when the score is high, caches repeat verdicts, and prunes tool output before compaction. openclaw-typesafe-ai stays narrow: one typesafe_decide tool, called by the agent when it wants an answer.
• The API. One endpoint, POST https://api.typesafe.ai/v1/systemone, a bearer key, model jev-latest. Any agent that can make an HTTP call can use Jev with no integration at all.

How to Use Jev in an AI Agent

An agent loop is mostly decisions between the steps: act or skip, safe or not, which model, done or not. Four scenarios show where Jev slots in and which question you would ask it.

Sorting incoming messages. A mailbox agent that checks mail every five minutes wakes up almost 300 times a day, and most wake-ups end in "nothing to do": newsletters, receipts, notifications, replies that close a thread. Jev takes the first look with three questions: does this need a reply (Noul), which topic (Choice: billing, sales, support, other), how urgent (Score: can wait, this week, today). Anything with a low "needs a reply" probability is filed. The rest reaches the LLM with topic and urgency already attached, so it writes replies and does nothing else.

Checking a command before it runs. The agent is asked to clean up old build files and proposes rm -rf ./build. The state is the command together with the user's request, and one Noul asks: would running this delete data, change permissions, send money, or do something the user did not ask for. The probability picks the branch: run, ask the user, or block. Claude Code and Codex ship this check as closed classifiers inside the product; with Jev any agent with a pre-execution hook gets the same. In Python:

from typesafe_sdk import Noul, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY from the environment

response = client.system_one(
   state={"command": "rm -rf ./build", "user_request": "clean the build directory"},
   questions={
       "risky": Noul(
           instructions="Would running this command delete data, change "
           "permissions, send money, or do something the user did not ask for?"
       )
   },
)

p = response.nouls["risky"].noul
if p > 0.7:
   ask_user_to_confirm()
elif p > 0.3:
   log_for_review()
else:
   run_command()

The thresholds 0.7 and 0.3 are a starting point; set them from your own tolerance for false blocks and missed risks.

Choosing a model for the task. "What time is it in Tokyo" and "refactor the payment module" should not go to the same model, yet most agents send everything to one default and pay the difference. One Choice at the start of a run fixes it: the state is the user's message, the options are your model classes with a one-line description each. The answer arrives in a few hundred milliseconds, before the first real LLM call, and low confidence on the choice is itself a signal to take the stronger model.

Choosing the next click in browser control. A planner LLM sets the goal once, for example "find the pricing page and read the monthly price". On each page the agent lists the interactive elements and asks one Choice: which of these leads toward the goal. Up to 255 options covers most pages, though TypeSafe notes that wide choices run a second pass and can be slower. Low confidence means the page has no good option and the planner should be asked again.

Where Jev Does Not Help an Agent

Every decision you hand to Jev needs its answers written down in advance, so the questions nobody could predict stay with the LLM. Jev also cannot count, do arithmetic, compare dates, or read an image. "How many failures in the last hour" belongs in your code, with the number passed into the state. And a typed answer is not automatically a right one: the schema is guaranteed, the choice is not. Read the probability and let the agent stop and ask a person below your threshold.

Where Jev Fails: Nine Known Limits

TypeSafe publishes a page for each model version with the failure modes it knows about. For jev-1.13, last reviewed on September 17, 2026, there are nine. Each comes with the workaround TypeSafe recommends, and most of them come down to the same rule: give Jev the judgment and keep everything else in code.

The last line has a consequence for auditing. When a Jev answer is wrong, there is no rationale to read, only probabilities. For decisions that have to be explained to a customer or a regulator, the common pattern is to route the high-volume cases through Jev and send flagged or low-confidence cases to a model that can write the explanation.

TypeSafe's own scope note covers the rest: jev-1.13 does best on common-sense judgments about text and does worse on tasks that need specialized domain knowledge, several levels of reasoning, or numeric precision. It also reads text only, so screenshots, audio, and PDFs have to be converted before they can be sent as state.

FAQ

Is Jev an LLM?

TypeSafe says no: Jev is trained on a pretrained language model with a different method (RLCD) and returns probabilities over answers you define, not text. Its probabilities are tuned to match how often the answer is correct, while LLM probabilities are tuned to produce text people prefer. The request format is also different: instead of a messages array and a text reply, Jev takes a state with typed questions and returns typed answers. An LLM is built to talk to a person; Jev is built to be called by code.

Is Jev just a classifier?

It does the job of a classifier without training. You write the questions in plain language at request time and can change them on every call. For a fixed set of categories at very high volume, a trained classifier is still cheaper to run.

Should I switch my LLM classifier to Jev?

If the classifier's answers gate anything automatically, the calibrated probability is the reason to test it: code can act on the confident cases and queue the doubtful ones instead of trusting every label equally. If the categories have been stable for months and you have labeled data, a trained classifier stays cheaper per call. The migration itself is an adapter, since Jev's request format is not chat completions.

Can Jev hallucinate?

It cannot invent a value: the output is always one of the answers you defined. It can still be wrong. On TypeSafe's own workflows it agrees with the reference answers 67.8% of the time, and a wrong answer arrives as a valid value with a probability, so the program keeps running.

Is Jev accurate?

On TypeSafe's four-workflow evaluation, Jev scores 67.8%, level with GPT-5.6 Terra and about six points below GPT-5.6 Sol and Claude Opus 5. No independent evaluation has been published as of September 18, 2026.

Does Jev need training on my data?

No. You describe the decision in the question and the options in the criteria, and Jev answers from that description.

How do I get access to Jev?

Through AI/ML API. It is an all-in-one provider: hundreds of models behind one API key, and Jev is already there. You sign up, get a key, and can call Jev the same day. TypeSafe's own API is still in early access, with a waitlist at console.typesafe.ai and no free tier.

Can Jev generate text?

Not free-form text. Jev answers by picking from options you define. If the state says "a monkey in a blue suit with yellow buttons" and the question is "What color is the suit?" with the options blue and yellow, the answer is blue at 99.9% and yellow at 0.1%. The words come from your list, not from the model. For a reply, a summary, or code, you still need an LLM.