Jev AI is a decision-making model from the San Francisco startup TypeSafe AI, which is why people also search for "type safe ai jev". It launched on September 15, 2026, and it does something unusual for an AI model: it doesn't write text at all.
You give Jev some data, which TypeSafe calls the "state", plus a set of typed questions. It returns structured answers: a yes/no probability, one option from a list you defined, or a score on a scale, each with a calibrated confidence value. TypeSafe reports response times of 70 to 500 milliseconds and, as of October 2026, lists a price of $0.042 per million input tokens with output tokens free.
That makes Jev a tool for the small decisions buried inside software: routing a support ticket, flagging an urgent message, checking a refund against policy, blocking a risky agent action. If your code currently asks an LLM for a JSON label and hopes it comes back valid, Jev is worth a look.
Who makes Jev, and what is a "System One" model?
Jev is the first public model from TypeSafe AI, founded in 2024 by Diogo Almeida (the CEO, a former OpenAI researcher who worked on RLHF, InstructGPT and ChatGPT), Erik Gafni and Sasha Sheng. In its launch announcement, TypeSafe describes "System One models" as "a new class of frontier models built to make fast, structured decisions that software can use directly". The name borrows the idea of fast, intuitive thinking.
The company name explains the design. In programming, type safety means a value always matches its declared type. Jev applies that to AI output: you declare the allowed answers up front, and Jev can only return one of them, as a typed value with probabilities attached. Input is text only, as strings, JSON objects or arrays.
The current versions are jev-1.14.0 (from October 14, 2026) and jev-1.13.0, with jev-latest as an alias. Jev is a closed, hosted model: you reach it through TypeSafe's API, its Python and TypeScript SDKs, LangChain or Cloudflare Workers AI. And despite the name, it has nothing to do with Java or the JVM.
Why Jev isn't an LLM
A normal large language model generates its answer one token at a time. If you want a category label, you ask for JSON and trust the model to produce a valid value. Jev works differently in three ways.
First, it doesn't generate token by token. TypeSafe says Jev "outputs all probabilities in parallel instead of autoregressively generating by token". Every question in a request is evaluated at once, so adding questions adds little latency. Second, its output is bound to your schema. It cannot return a malformed value or an invented category. Third, its probabilities are meant to mean something. Jev is trained with a method TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD), so a probability is supposed to reflect how likely that answer is to be right.
Your data (state) + typed questions
↓
Jev evaluates every question in parallel
↓
Typed answers + probabilities + confidence
↓
Your code acts, asks for confirmation, or escalates to a human
The three question types
Type | What it answers | What you get back |
|---|
noul
| A yes/no judgment, such as "Is this urgent?" | The probability that the answer is yes |
choice
| Pick one option from a map you define (up to 255 options) | The top choice, probabilities for every option, and a confidence score |
score
| Rate against an ordered list of levels | The score, confidence, a legend, and probabilities per level |
What confidence means, and how to use it
Confidence is a number from 0 to 1 based on how the probability is spread. If almost all of it sits on one option, confidence is close to 1. If it is spread across several options, confidence is low.
TypeSafe's documentation suggests three bands. With high confidence, act automatically. With medium confidence, proceed carefully: ask the user to confirm or flag the item for review. With low confidence, don't act; route to a human or ask for more information. The sample code in the docs escalates below 0.5, and the docs suggest starting noul thresholds at 0.7 for yes and 0.3 for no.
Treat those as starting points. The right threshold depends on what the action costs if it's wrong, so set one per action and tune it on your own data.
Where Jev fits
The use cases TypeSafe and its integrations describe are all variations on "a judgment your code needs to make":
- routing a ticket, email or chat to the right team;
- "smart if-statements" that replace brittle keyword rules, such as "Does this message contain a complaint?";
- scoring frustration, risk, lead quality or content quality on a defined scale;
- checking whether a refund, request or document meets your rules;
- guardrails that check an LLM's output, or an agent's planned tool call, before it runs;
- picking which LLM should handle a request based on its difficulty;
- classifying large datasets cheaply, map-reduce style.
Jev is meant to sit next to an LLM, not replace it. The pattern I'd reach for is to let Jev make the fast decision and call an LLM only when you actually need generated text.
Calling the Jev API
Sign up in the TypeSafe developer console at console.typesafe.ai. Jev launched as early access with a waitlist, so access may depend on your account status. Store the key in an environment variable named TYPESAFE_API_KEY, which the SDKs read automatically.
Every Jev model uses a single endpoint, POST https://api.typesafe.ai/v1/systemone. This raw request routes a support message and asks whether it is urgent:
curl https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "My running shoes arrived in the wrong size. Can I swap them?",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this?",
"criteria": {
"returns": "Exchanges, wrong or damaged items",
"shipping": "Delivery status, delays, lost packages",
"billing": "Charges, invoices, payment problems"
}
},
"is_urgent": { "type": "noul", "instructions": "Does the customer need help right now?" }
}
}'
The response looks like this (values are illustrative):
{
"model": "jev-1.14.0",
"answers": {
"department": {
"type": "choice",
"choice": "returns",
"confidence": 0.98,
"probabilities": { "returns": 0.99, "shipping": 0.01, "billing": 0.0 }
},
"is_urgent": { "type": "noul", "noul": 0.12 }
},
"usage": { "input_tokens": 340, "output_tokens": 30 }
}
Python and TypeScript SDKs
# Python
pip install typesafe-sdk
# JavaScript / TypeScript
npm install @typesafe-ai/sdk
from typesafe_sdk import Choice, Noul, TypeSafeClient
with TypeSafeClient(model="jev-latest") as client: # reads TYPESAFE_API_KEY
response = client.system_one(
state="My running shoes arrived in the wrong size. Can I swap them?",
questions={
"department": Choice(
instructions="Which team should handle this?",
criteria={
"returns": "Exchanges, wrong or damaged items",
"shipping": "Delivery status, delays, lost packages",
"billing": "Charges, invoices, payment problems",
},
),
"is_urgent": Noul(instructions="Does the customer need help right now?"),
},
)
print(response.choices["department"].choice)
print(response.nouls["is_urgent"].noul)
import { choice, noul, TypeSafeClient } from "@typesafe-ai/sdk";
const client = new TypeSafeClient({ defaultModel: "jev-latest" }); // reads TYPESAFE_API_KEY
const response = await client.systemOne({
state: "My running shoes arrived in the wrong size. Can I swap them?",
questions: {
department: choice("Which team should handle this?", {
returns: "Exchanges, wrong or damaged items",
shipping: "Delivery status, delays, lost packages",
billing: "Charges, invoices, payment problems",
}),
is_urgent: noul("Does the customer need help right now?"),
},
});
console.log(response.answers.department.choice);
console.log(response.answers.is_urgent.noul);
Both snippets follow TypeSafe's quickstart. The SDKs are new, so check it for the current helper signatures before you copy them into production code.
Calling Jev from C# and .NET
There is no official .NET SDK yet, but the REST API is simple enough that you don't need one. This example routes a support ticket and maps the answer onto a C# enum, so the rest of your code stays type-safe as well:
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text.Json;
public enum Department { Returns, Shipping, Billing }
public static class JevRouter
{
private static readonly HttpClient Http = new()
{
BaseAddress = new Uri("https://api.typesafe.ai/")
};
static JevRouter()
{
Http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
"Bearer", Environment.GetEnvironmentVariable("TYPESAFE_API_KEY"));
}
public static async Task<(Department Dept, double Confidence, bool Urgent)> RouteAsync(string ticket)
{
var request = new
{
model = "jev-latest",
state = ticket,
questions = new Dictionary<string, object>
{
["department"] = new
{
type = "choice",
instructions = "Which team should handle this?",
criteria = new Dictionary<string, string>
{
["returns"] = "Exchanges, wrong or damaged items",
["shipping"] = "Delivery status, delays, lost packages",
["billing"] = "Charges, invoices, payment problems"
}
},
["is_urgent"] = new
{
type = "noul",
instructions = "Does the customer need help right now?"
}
}
};
using var response = await Http.PostAsJsonAsync("v1/systemone", request);
response.EnsureSuccessStatusCode();
using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
var answers = doc.RootElement.GetProperty("answers");
var dept = answers.GetProperty("department");
var department = Enum.Parse<Department>(dept.GetProperty("choice").GetString()!, ignoreCase: true);
double confidence = dept.GetProperty("confidence").GetDouble();
double urgentProbability = answers.GetProperty("is_urgent").GetProperty("noul").GetDouble();
return (department, confidence, urgentProbability >= 0.7);
}
}
Then let confidence decide how much the code does on its own:
var (dept, confidence, urgent) = await JevRouter.RouteAsync(ticketText);
if (confidence >= 0.9)
await queue.AssignAsync(dept, urgent); // act automatically
else if (confidence >= 0.5)
await queue.AssignForReviewAsync(dept, urgent); // suggest, let an agent confirm
else
await queue.SendToTriageAsync(urgent); // too uncertain, human decides
Because the option names are fixed, Enum.Parse won't trip over an unexpected label. That is the practical payoff of a schema-bound model: the parsing code that usually needs defensive handling around LLM output simply works. One thing to add yourself is retry handling. Rate limits return HTTP 429, and while TypeSafe's SDKs retry automatically, in .NET you should add a retry policy (with Polly, for example) that respects the retry-after header.
LangChain and Cloudflare Workers AI
LangChain's langchain-typesafe package (pip install langchain-typesafe) provides a TypeSafeClassifier, plus experimental middleware that uses Jev to route between models or block risky tool calls in an agent.
from langchain_typesafe import Noul, TypeSafeClassifier
classifier = TypeSafeClassifier()
result = classifier.invoke({
"state": "The deploy failed twice and customers are seeing 500s.",
"questions": {"urgent": Noul(instructions="Does this need attention right now?")},
})
print(result.nouls["urgent"].noul)
Jev is also listed in Cloudflare Workers AI as typesafe/jev, with a 32,000-token context window, zero data retention and the same $0.042 per million input token price. Inside a Worker, you call it with env.AI.run("typesafe/jev", { state, questions }).
Context limits
Limit | Default | With long-context header |
|---|
Per request (state plus all questions) | 64k tokens | 262k tokens |
Per question (state plus one question) | 32k tokens | 262k tokens |
Long context is switched on per request with the header TypeSafe-Danger-Zone-Long-Context: true. It costs the same per token, but TypeSafe warns that it is slower and less accurate, and the header name makes the point. Use it only when you can't trim the input.
Jev or an LLM with structured output?
Need | Jev | General LLM with structured output |
|---|
Fast classification or scoring | Designed for it | Works, but slower and more expensive per decision |
Guaranteed valid label | Yes, by design | Usually, with JSON schema enforcement |
Probabilities per option | Yes, calibrated | Not reliably |
Writing, summarizing, explaining | No | Yes |
Images, audio, video input | No, text only | Many models support them |
Jev also has company now. OpenAI opened a public beta of a Decisions API on October 6, 2026, with a /v1/decisions endpoint, similar question types and a listed price of $0.10 per million input tokens. If you're choosing between the two, compare accuracy and calibration on your own data, along with supported input types, data retention terms and latency from your region. The price difference matters less than whether the probabilities hold up on your cases.
And if you searched "type safe ai" because you want typed output from any LLM, you may want a library rather than a new model. Microsoft's TypeChat, Pydantic AI in Python and the structured output features built into most LLM APIs validate generative model responses against types or schemas. On C# Corner, function calling with local LLMs using Ollama covers that route, and fine-tuning an open-source LLM for an ASP.NET Core app covers when training your own classifier makes sense.
How far to trust the claims
TypeSafe's homepage says Jev is "193.6x faster, 444.6x cheaper" than frontier LLMs on its internal workflow evaluations. To its credit, TypeSafe also notes that those tasks were built by its own team, that the speed tests ran from laptops on the US West Coast, and that pricing may be subsidized. Until independent benchmarks appear, treat the numbers as vendor claims, and assume the price could rise.
On funding, TypeSafe raised a $40 million seed round led by DCVC at launch. In October 2026 Bloomberg reported a much larger round of roughly $870 million at a $7.5 billion valuation, led by Andreessen Horowitz; TypeSafe had not announced it at the time of writing.
The marketing line that Jev "can't hallucinate" needs reading carefully. TypeSafe means Jev can't return an invalid type or an option you didn't declare. It can still pick the wrong option, which is exactly why every answer carries a probability you should check before acting. Prompt injection still applies too: instructions hidden inside the state can influence Jev like any other model, so untrusted text shouldn't drive destructive actions without checks.
The other limits are straightforward. Jev generates no text, so pair it with an LLM when you need a reply or an explanation. It accepts text only, so images, audio and video have to be converted to text or structured fields first. English works best; other languages, including CJK, are supported but less accurate. And with no public weights, you can't self-host it, so you are depending on one vendor.
If those limits fit your problem, the quickest test is to take one if-statement in your code that currently calls an LLM for a label, send the same inputs to Jev, and compare the answers and confidence values against what a person would have decided.
Join the conversation! Your thoughts help the community grow.