TypeSafe introduced Jev on September 15, 2026, with a different job from the conversational models most of us use. Rather than writing a response, Jev evaluates information and returns a decision your software can act on. TypeSafe calls this a System One model. Its launch announcement describes a model stack designed around structured decisions rather than generated strings. [1]
That is interesting if you are building an application that needs to decide where a request should go, whether a document is relevant, or which cases need review. In those situations, the desired output is often not a paragraph but a value that determines what happens next.
The useful question then is not whether Jev replaces an LLM. It is which parts of a workflow need language generation, and which need a narrower judgment.
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI? I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev • 20-200x faster • 40-400x Show more
What is TypeSafe Jev?
Jev is TypeSafe AI's flagship decision model. You provide the information to evaluate, called the state, and a set of typed questions. It returns bounded answers and probabilities rather than composing prose. TypeSafe's introduction describes three question types: Choice, Score and Noul. [2]
Think of a support ticket. Your application might need to know which team should handle it, how severe the reported problem is, and whether the customer is asking for a refund. Those are separate decisions. You can define each one explicitly, then let ordinary code combine the answers.
The System One name refers to fast, focused judgments. It is not a promise of general reasoning or a new chat interface. Jev currently accepts text-based inputs and does not write replies, generate code, or explain its reasoning. [3]
A useful way to think about it is as a probabilistic decision function. The model supplies the judgment while your application still owns the consequences.
Jev vs LLMs: more than a different output format
It would be too simplistic to say that LLMs produce unstructured text while Jev produces structured data. General-purpose models can already return schema-constrained JSON.
The difference TypeSafe is proposing is in what the model is trained to do. Its approach, Reinforcement Learning for Calibrated Decisions (RLCD), targets decisions and useful probability estimates rather than preferred conversational responses. That is a different objective altogether. [5]
| Question | General-purpose LLM | TypeSafe Jev |
|---|---|---|
| What do you ask for? | A generated response, potentially constrained to a schema | A decision within a defined answer space |
| What comes back? | Text, code, or structured output | Typed decisions and probability information |
| Can it write an explanation? | It can generate one | Jev does not generate explanations |
| Where does it fit? | Work that needs language generation or broader reasoning | Narrow judgments embedded in software |
This is a comparison of roles, not an accuracy ranking. [3][4]
Consider a support workflow that needs both classification and a customer reply. There is no reason to force one model to do everything. A decision model could select the route, code could check account permissions and policy, and an LLM could draft the reply. TypeSafe documents this kind of intent-routing pattern, with different handlers for different needs. [6]
How Jev works: state, questions and decisions
The state is the context available for the judgment. In TypeSafe's native API, it can be a string or structured text data, such as a JSON record. It should include the evidence relevant to the question, not every piece of information your application happens to have. [7]
You then define the questions and the possible answers. The three primitives serve different purposes:
Choice: select from defined options
A Choice question selects one option from a set you supply. For a support ticket, that might be billing, technical support, or account access. The answer includes the selected option, probabilities across the options, and a confidence value. A sensible taxonomy should also account for cases that do not fit neatly. [8]
Score: evaluate against a descriptive rubric
A Score question places the input on an ordered scale. For example, a severity rubric could distinguish a cosmetic issue, a broken feature with a workaround, and work being completely blocked. Descriptions make those levels meaningful; a bare scale from one to ten leaves much more to interpretation. The result includes probability information across the levels. [9]
Noul: estimate the probability of yes
A Noul question evaluates a yes/no proposition and returns a value between zero and one. You could ask whether a message requests a refund. Unlike Choice and Score, Noul does not have a separate confidence field. Its probability is the signal your application uses. [10]
TypeSafe says Jev processes questions over the same state in parallel, rather than making each answer depend on the preceding one. That makes decomposition important: ask separately about severity, customer intent and evidence, then combine the results in code. A question that depends on information discovered by an earlier call still needs a later step. Parallel questions do not remove genuine dependencies. [11]
This also makes the application easier to inspect. If the routing policy changes, you can change the rule that uses the answers rather than hide the entire workflow inside a larger prompt. TypeSafe's build guidance keeps deterministic checks and execution in code, with the model responsible for narrow judgments. [12]
What do Jev's confidence scores mean?
An answer and the certainty attached to it are different pieces of information. A model might select technical support while spreading substantial probability across other teams. The winning label alone would hide that ambiguity.
For Choice and Score, TypeSafe describes confidence as a summary calculated from the probability distribution. It is not simply a sentence in which the model says it feels confident, and it should not automatically be read as the probability that the selected answer is correct. [13]
Calibration is a related but distinct idea. If a model is well calibrated, events assigned an 80% probability should occur about 80% of the time across an appropriate group of predictions. TypeSafe describes calibration as a training objective; your own evaluation still matters. [5]
For an application, the practical question is where to draw the line between acting and asking for help. TypeSafe's confidence-routing pattern makes that boundary explicit. [14] As an implementation recommendation, test it on labelled examples from your own traffic and measure both mistakes and the share of work sent for review. A threshold that looks cautious can still be poorly matched to the task.
Where Jev fits, and where it does not
Promising starting points are classification, intent routing, relevance checks and rubric-based evaluation. A useful pilot would be a decision that currently needs semantic judgment but has a small, well-defined set of acceptable outcomes. TypeSafe's documented patterns include routing requests to deterministic handlers, specialist models or people. [6][12]
However, structured does not mean correct. A wrong team name chosen from your allowed list is still wrong. Type safety narrows the shape of a failure while it does not remove the need to test the judgment.
TypeSafe publishes a version-specific limitations page for Jev 1.13. It flags weaknesses around arithmetic, counting, date comparisons, indirect questions, distracting context and adversarial input. Keep exact calculations in code, make questions direct, and do not treat the model as a security boundary. Jev is also not the tool for drafting the final customer email. [15][3]
The launch includes large speed and cost comparisons, but these are vendor-run results on particular workflows. TypeSafe itself describes the headline gains as being toward the upper end of expected real-world results. [1] The meaningful comparison for a buyer is the same task, with the same quality target and review policy, measured end to end.
Jev API pricing
Pricing checked on September 19, 2026. Amounts below are in US dollars.
| Published route | Input price per million tokens | Output price |
|---|---|---|
| Jev Pricing | $0.042 | Free |
For a concrete example, assume 100,000 requests with 1,000 billable input tokens each, including the content and question definitions. That is 100 million input tokens. At $0.042 per million, the model bill would be $4.20.
How to access Jev through Requesty
Jev is available on Requesty as typesafe/jev-1.13.0. The Decisions guide uses typesafe/jev-latest with the questions response format. [17][18]
Set REQUESTY_API_KEY to a key from the Requesty Console, then send this classification request:
curl --fail-with-body https://router.requesty.ai/v1/chat/completions \
-H "Authorization: Bearer $REQUESTY_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "typesafe/jev-latest",
"messages": [{
"role": "user",
"content": "My invoice shows two charges for the same subscription."
}],
"response_format": {
"type": "questions",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle this request?",
"criteria": {
"billing": "Invoices, payments and refunds",
"technical": "Bugs, outages and integrations",
"other": "Anything outside those categories"
}
}
}
}
}'Parse the assistant message's JSON and read team. Requesty's Jev integration supports text-only user messages, non-streaming calls and questions, not ordinary chat responses. It is experimental and may change without a deprecation period. [18]
For a production rollout, record the model version and evaluate upgrades deliberately. TypeSafe notes that moving aliases can change the model behind a request; a versioned identifier is more appropriate when thresholds have been tuned to a specific release. [16]
What creators are building with Jev
The posts below are early demos from builders in the days after launch. Each one is embedded in full so you can inspect the project and its context. Performance and cost figures are the creators' own, and these are prototypes rather than production deployments.
Here's a 45-second TL;DR on Jev. I find the core idea beautifully simple, but the video made it really hard to understand. Hope you find it helpful.
Matija Sosic condenses the launch video into a short explainer of the core idea: a model that answers typed questions instead of writing.
jev is INSANE. in 40 seconds it broke down 724 live ads from 37 brands. every hook. every format. offer. cta. awareness stage. landing page mismatch. used 9 cents of tokens. (will be avail in @stealads + mcp)
Matthew Berman has Jev classify 724 live ads from 37 brands by hook, format, offer, call to action and awareness stage. He reports a 40-second run costing about 9 cents in tokens.
jev is insane 🤯 Here is Jev playing subway surfers at super human speed, and also playing 50 games at once. cost less than a cent to do this run. Jev does not replace llms like astra or fable, but opens up an entirely new world of capabilities.
Max Blade uses Jev as a per-frame action picker for an arcade game, including 50 games running at once. He reports the run cost under a cent.
Breaking: Browser Use + Jev = Ultrafast ⚡ Findings flights took 7s and cost only $0.0039 🤯 > new action space every step > DOM state space > small LLM fallback to type (this video is at 1x speed btw) Built a tiny open source browser agent. try it below ↓
Gregor Zunic pairs Jev with Browser Use to choose the next browser action from the DOM state at each step, with a small LLM as a fallback for typing. He reports a flight search in 7 seconds for $0.0039.
Jev is INSANE. 🤯 in 24.9 seconds it read 384 news from this morning and told 15 brands which stories to hop onto today, for $0.19. Claude Opus 5, running on the same feed at the same time, got through 4/384 and cost $0.77. per headline that is ~390x cheaper, and the answer Show more
Elvis has Jev read 384 morning headlines and decide which stories each of 15 brands should respond to. He reports 24.9 seconds and $0.19 for the run.
I built a trading bot with Jev! Jev decides if it should "buy" or "sell", given the price feed of an asset pair, and executes real trades. It uses Monad to place the orders on Kuru's on-chain order book in every 300ms block. Demo link → jev-trader.vercel.app
Jarrod Watts has Jev return a buy or sell decision from a price feed, then executes the trade on Kuru's order book on Monad every 300 ms block.
The useful starting point
Jev is worth evaluating where the output you need is a judgment, not a piece of writing. Its narrower role also gives you a clearer way to test it: define the decision, specify the allowed outcomes, and decide what happens when the answer is uncertain.
Start with one contained workflow. Compare it with your existing approach on decision quality, end-to-end latency, token cost and review workload. The useful result is not the cheapest model call in isolation. It is a workflow that gets the job done at an acceptable cost and error rate.
To try that through Requesty, begin with the Jev listing and the Decisions integration guide.
Sources
- TypeSafe: Introducing System One Models & Jev
- TypeSafe: Introduction
- TypeSafe: System One
- Requesty: Structured Outputs
- TypeSafe: AI primer
- TypeSafe: Intent routing
- TypeSafe: State
- TypeSafe: Choice
- TypeSafe: Score
- TypeSafe: Noul
- TypeSafe: Speculative fan-out
- TypeSafe: How to build with TypeSafe
- TypeSafe: Confidence
- TypeSafe: Confidence-gated routing
- TypeSafe: Jev 1.13 jaggedness
- TypeSafe: Models
- Requesty: Jev model listing
- Requesty: Decisions
Frequently asked questions
- What is a System One model?
- TypeSafe uses the term for models built to make fast, focused decisions that software can consume directly. Jev is its first such model. The name refers to the distinction between quick judgments and slower, deliberate reasoning.
- Can Jev replace an LLM?
- It can be evaluated as an alternative for narrow decision tasks. It does not replace a model that needs to generate prose, code or explanations. Many applications may use both.
- Does a typed answer mean Jev cannot be wrong?
- No. A valid answer format and a correct judgment are different things. Evaluate errors and uncertainty on your own workload, rather than treating type safety as an accuracy guarantee.
- Is Jev available through Requesty?
- Yes. Requesty lists Jev, with setup instructions in its experimental Decisions documentation.
- SEP '26
Which of the smartest models can you run inside the EU, and what is the residency premium?
We took the top 16 models on the Requesty Intelligence ranking and checked each one against the live catalog for an EU region deployment. Thirteen have one. Ten of those cost exactly 10% more in Europe than the global list price, one costs 55% more, one is cheaper, and three of the sixteen (GPT-6 Astra, Grok 4.6, Qwen3.8 Max) cannot be run inside the EU at all today. Here is the full table, the cheapest EU models, and how to make the EU column the only one your organisation can call.
- SEP '26
Claude in the EU: 47 region deployments, one quota wall, and how to fail over without leaving Europe
Two Reddit threads this month describe the same wall: a developer who needs Claude inside the EU gets a 429 from Bedrock Frankfurt on the first request, and a production app on Bedrock is capped at 2.5 million Opus tokens a day with two quota increases rejected. Anthropic's first party API has no EU region, so the only European Claude is the cloud kind, and the cloud kind ships with per region, per account quotas. The catalog lists 47 EU region Claude deployments across six regions on two platforms. That is the fallback chain.
- JUN '26
Best AI Coding Model (2026): Benchmarks, Cost, and Real World Performance
Claude Fable 5, GPT-5.5, Claude Opus 4.8, Gemini 3.5 Flash, DeepSeek V4, and Kimi K2.7 Code all claim top coding performance in 2026. This guide compares them on SWE-bench, Terminal-Bench, FrontierCode, cost per million tokens, and real-world agentic coding tasks so you can pick the right model for your workload.