Jev, explained: TypeSafe AI's System One model
Jev is a model that returns typed decisions with confidence scores instead of text. This page is the short version of what it is, how you call it, what it can and cannot do, what to make of the launch numbers, and which agents already build on it.
The short version
- Jev is the first model of a category TypeSafe AI calls System One models. It was announced on 15 September 2026 and is in early access.
- You give it a block of state and a set of typed questions; it returns one answer per question, chosen from options you declared, each with a probability. It writes no text.
- TypeSafe reports 70–500 ms end-to-end latency and $0.042 per million input tokens with free output. These are vendor figures and no large independent reproduction had surfaced at the time of writing.
- It fits fast, repeated, bounded decisions: routing, classification, safety gates, verification, real-time loops. It does not fit chat, code, prose, arithmetic or anything that needs an explanation.
- In an agent it works best as a fast decision layer that hands low-confidence cases to a slower model or a person.
What Jev is
Jev comes from TypeSafe AI, a startup co-founded by former OpenAI researcher Diogo Almeida. Instead of predicting one token after another, it evaluates every question in a request in parallel and emits one value per question. Each value comes from a set of options the caller declared in advance, together with a probability.
TypeSafe calls this class of model a System One model, borrowing the fast-and-intuitive half of Kahneman's fast/slow split. The label is TypeSafe's own, not an industry standard. The name Jev nods to the economist William Stanley Jevons: the bet is that when model calls get much cheaper, people make far more of them.
How you call it
Jev is reached over an HTTP API (a POST to the System One endpoint at api.typesafe.ai) with Python and JavaScript SDKs. A request carries three things: the model name, a `state` (the text or structured data to judge) and a set of named `questions`. The response returns the answers, keyed by question, plus token usage.
TypeSafe's documentation describes three question types, and every answer is one of them:
- noul: a yes/no question. The answer is a probability.
- choice: pick one option from a set you name, each with a short description. TypeSafe says up to 255 options are supported. The answer is the chosen option plus its probability.
- score: place the input on an ordered scale you describe level by level, such as severity from 0 to 3.
The request below is an illustration of the shape, not a copy of TypeSafe's documentation. Field names can change during early access, so check the current docs before building on it.
{
"model": "jev-latest",
"state": "Customer message: I was charged twice for my plan this month, please fix it today.",
"questions": {
"wants_refund": {
"type": "noul",
"instructions": "Does the customer ask for money back?"
},
"team": {
"type": "choice",
"instructions": "Which team should handle this message?",
"criteria": {
"billing": "Charges, invoices, refunds",
"support": "Bugs, outages, how-to questions",
"sales": "Plans, pricing, upgrades"
}
},
"urgency": {
"type": "score",
"instructions": "How urgent is this message?",
"criteria": ["Can wait", "Needs a reply today", "Blocking the customer now"]
}
}
}What it is good for
The common thread is a decision that happens often, has a known set of possible answers, and needs to be fast and cheap. TypeSafe and early write-ups describe these patterns:
- Routing and classification: which team, which handler, which category, which priority.
- Safety gates: classify a shell command or tool call as read-only, reversible or destructive before an agent runs it.
- Verification: check whether a claim in an LLM's answer is supported by the source text, or how risky a change is.
- Real-time loops: game logic, simulations and robotics, where a slower model cannot keep up. Public demos so far have run in simulators, including Doom.
- Bulk labelling: scoring or tagging large piles of rows where per-call cost decides whether the job is worth doing at all.
What it cannot do
These limits come from how it works, and TypeSafe states most of them itself:
- It cannot generate text: no replies, summaries, explanations or code.
- It cannot answer open-ended questions. Every answer has to be one of the options you declared, so you must know the answer space in advance.
- It gives no reasoning. A decision arrives without a rationale, which matters if you need an audit trail in a regulated setting.
- Its demos so far use structured or text state, not images. One independent write-up also lists weak spots such as arithmetic and date comparisons, so test those before relying on it.
- Whether it generalises beyond short, well-structured decisions is still unproven.
How to read the numbers
The headline figures are TypeSafe's own: 70–500 ms end to end, against several seconds to minutes for frontier LLMs on comparable tasks, and $0.042 per million input tokens (about $42 per billion) with output free. The launch post claims 40–200 times faster at the same level of intelligence on the workflows it tested, and the price per token is far below frontier LLMs'.
TypeSafe itself adds three caveats. The evaluation workflows were built by its own model team, so bias is possible. The LLM figures it compares against come from OpenRouter data, which it says also carries bias. And it calls its 0% hallucination rate not empirical: the claim is structural, since the output is confined to your options, but a valid-looking option can still be the wrong one.
So treat the multiples as an upper bound. The number that matters for you is cost per correctly solved task on your own data, which you can only get by testing.
Pricing and access
As of 21 September 2026, Jev is in early access with a waitlist. Input is billed at $0.042 per million tokens and output is free, though prices and limits may change as access opens up.
Around the model, TypeSafe publishes Python and JavaScript SDKs and a plugin for Claude Code. LangChain has published an alpha integration package, `langchain-typesafe`.
Using Jev safely inside an agent
The pattern that fits Jev's strengths is a fast layer in front of a slow one. Jev makes the frequent small decisions; anything it is unsure about goes to a stronger model or a person.
- Start in shadow mode: let Jev label real traffic while a person or your existing logic still decides, and compare.
- Set confidence thresholds from your own labelled data. Example values in write-ups (act automatically above 0.9, ask for confirmation between 0.5 and 0.9, hand to a person below) are illustrations, not defaults.
- Keep deterministic code where it is already correct. A rule that is always right does not need a model.
- Do not use it where you must explain each decision, unless something else produces the explanation.
- Fail closed for anything risky: if a call fails or confidence is low, leave the normal safe path in place.
Jev versus an LLM, in one view
- Output: Jev returns typed values from options you declare; an LLM returns generated text you may need to parse.
- Speed and cost: Jev is built to be much faster and cheaper per decision, by TypeSafe's account; an LLM is slower and costlier but far more general.
- Confidence: Jev is trained to give calibrated probabilities; an LLM's stated confidence is often unreliable.
- Explanations: an LLM can explain itself; Jev cannot.
- Scope: an LLM can handle open-ended tasks; Jev only handles questions with a fixed answer space.
- Together: Jev decides, classifies and routes; an LLM handles the hard or open-ended remainder.
Agents and tools already built on Jev
Within days of the launch, open-source projects built on Jev started to appear: coding-agent harnesses that use it as a decision layer, MCP servers that expose it to Claude Code and Codex, permission gates for tool calls, browser automation and more. We review the ones that pass our catalogue rules with the same FARS method as every other agent, and the guide below refreshes itself as new ones are added.
Some Jev projects are not in the catalogue because they fail the structural rules for agents, or are too small. That is by design, and it does not mean they are bad.