What Jev is
Jev is the first model TypeSafe AI shipped under the label System One model. You hand it a state, which is whatever text you want judged, plus a set of questions you have defined in code. It answers each question and stops. It does not write a reply, explain itself, or produce code.
TypeSafe trained it with Reinforcement Learning for Calibrated Decisions, so the probabilities it returns are meant to match real outcome rates rather than match what a human rater would prefer to read.
What it returns
Three question types, covered in full in Choice, Score and Noul:
- Choice picks one option from a list you write, up to 255 of them, and returns the winner, a probability for every option, and a confidence value.
- Score places the state on an ordered scale of 2 to 10 levels and returns a probability-weighted position, so the answer can land between levels.
- Noul answers a yes/no question with a single number from 0 to 1. There is no separate confidence value, because the probability is the certainty measure.
You can attach several questions to one request. They are answered in parallel against the same state.
What it is good at
Fast, repeatable judgments where the set of possible answers is known before the call. Routing, classification, filtering, reranking, scoring, gating, and yes/no screening. Because output tokens cost nothing and the response is already typed, it fits in places where parsing an LLM’s JSON and retrying on malformed output was the expensive part. See the use cases for the eighteen patterns this site tracks, and examples for what people have actually built.
What it is not for
TypeSafe publishes a jaggedness page per version, which is unusually direct about the failure modes. Jev reads questions literally, so scoping words, negations and implied conditions trip it up. It does not count reliably, whether that is characters, term occurrences or items in a long list, and arithmetic and numeric precision are no better. Ordering dates, computing durations and checking date windows sit outside what it does well. Multi-hop questions, where the answer depends on chaining two facts, degrade, and accuracy falls as unrelated content grows in the state. Nothing built in defends against instructions injected into the state, and contradictory criteria make that worse. Related questions carry no mathematical guarantee, so two complementary yes/no questions need not sum to 1. It generates no text either, so anything that has to be written rather than decided belongs elsewhere.
Access and cost
Early access off a waitlist, opened the day of the launch on 2026-09-15, with batches let in afterwards. It is a closed managed API, not open weights. Input is $0.042 per million tokens and output is free. The vendor latency and speed claims are unpacked in Jev speed and pricing.
Specifications
| Question types | ChoiceScoreNoul |
| Max Choice options | 255 |
| Score levels | Up to 10 |
| Questions per call | Not documented |
| Total context | 64,000 tokens |
| State budget | 32,000 tokens |
| Rate limit | 250,000 tokens/sec and 1,200 requests/min |
| Endpoint | POST https://api.typesafe.ai/v1/systemone |
| SDKs | Python: typesafe-sdkTypeScript: @typesafe-ai/sdk |
64k tokens across the whole request. The state plus the longest single question must fit in 32k of that. A Score needs at least 2 levels. The maximum number of questions in one call is not documented.
Versions
- jev-1.13.0, 15 Sep 2026, The only published version. The aliases jev-latest and jev-preview both resolve to it. TypeSafe ships a per-version jaggedness page listing what this version does badly. Release notes
Use cases
What people use Jev for, one page per pattern.
Support inbox triage with System One models
Send a support ticket to Jev once with every question attached. Category comes back as a selected label, severity and frustration as numbers on scales you wrote, refund intent as a probability. Your code reads those values and decides what happens to the ticket.
Intent and model routing with System One models
One Jev call reads an incoming request and returns its intent as a label plus a difficulty rating on a scale you wrote. Your router reads both numbers and picks the handler: deterministic code, a cheap model, an expensive one, or a human queue.
Confidence-gated actions with System One models
Jev returns a confidence value from 0 to 1 alongside every Choice and Score answer. Your code treats it as a separate axis: act automatically when it's high, confirm or flag when it's middling, hand the decision to a person when it's low. Riskier actions get higher bars.
Typed tool dispatch with System One models
Ask Jev one Choice question over your tool names and one per closed-set argument, so every value that comes back is a value the function already accepts. Nouls decide whether an optional argument was mentioned at all. Your code assembles the call and runs it.
RAG passage filtering with System One models
Retrieval returns whatever looks similar, including noise and hostile text. Put a Jev call between retrieval and generation: four yes/no questions per passage return probabilities, and your code decides which passages become evidence, which get flagged as conflicts, and which never reach the prompt.
Semantic reranking with System One models
Keyword or vector search narrows thousands of documents to a shortlist but rarely puts the right one first. Ask Jev one yes/no question about each query and candidate pair, take the probability it returns as the score, and sort the shortlist by it, highest first.
Citation verification with System One models
An answer with citations is only as good as the citations. Match each quote against the source in code to catch fabrications, then ask Jev one Choice question about how the surrounding section relates to the claim. Confidence decides which verdicts a human reviews.
Entity alignment with System One models
Two catalogues describe overlapping sets of the same products, and a rough first pass hands you candidate pairs. One Jev Score question with a level per outcome decides each pair, and yes/no questions about individual fields tell a curator where the two sources disagree.
LLM guardrails with System One models
Put one Jev request in front of an LLM and one behind it. Yes/no questions return the probability that each hazard holds, a Score rates how much harm complying would do, and your thresholds turn those numbers into pass, review, block, or a crisis path.
Semantic code linting with System One models
A semantic lint is a rule you can state in a sentence but cannot express in a regular linter. Jev turns each rule into a yes/no question over one diff hunk and returns a probability, so CI can comment on the likely violations and stay quiet about everything else.
Compliance verification with System One models
A compliance review is a fixed checklist run against a changing document. Jev answers the whole checklist in one request, returning a probability, a label or a rated level per item, so code can clear the clear-cut findings and send the borderline ones to a person.
Self-consistency checks with System One models
Run a rubric over the same document several times and compare the answers. The spread tells you which items sit safely away from a threshold and which ones wobble across it. TypeSafe documents that Jev does not guarantee structural identities between related questions, so code has to enforce those.
Structured extraction with System One models
Jev is not trained to generate text, so it cannot write a value out for you. Extraction works the other way round: a regex or a parser finds candidate spans, a choice question picks the one the question asks for, and code copies that span unchanged.
Composite scoring with System One models
Asking for one overall rating hides the reasoning inside a single number. Score each dimension as its own question instead, normalise each answer to a 0 to 1 range, and combine them with weights your code owns, so a ranking can be explained and retuned without new model calls.
Feature extraction for machine learning with System One models
A tabular model needs numbers, and a written note is not one. Ask Jev a set of questions about each row, keep the probability distribution rather than the winning answer, and you get numeric columns that a gradient-boosting model can train on alongside your existing features.
Hierarchical classification with System One models
A taxonomy with thousands of leaves will not fit in one question. Ask one choice question per node instead, walking down the tree, and use the probability on each edge to decide whether to follow the single best path or keep several candidates alive.
Real-time control with System One models
A model inside a control loop has to answer before the next frame. Jev returns a typed decision rather than text, and TypeSafe reports end to end latency of 70ms to 500ms, which puts a semantic judgment inside the budget of a game tick or an interface response.
Agent routing and skill selection with System One models
An agent choosing from a long skill roster reads one truncated line per entry and often loads the wrong thing. Jev ranks every entry in one request and separately answers whether any skill applies at all, so the agent gets a short hint instead of a guess.
Examples built with Jev
The most-starred and most-viewed entries in the directory. Browse all examples.
Jev Ultrafast (Browser Use)
Browser Use's fast browser agent where Jev picks the operation and the DOM element in a single request; a small LLM is only invoked to write text when typing is required. Demoed on a Google Flights search.
openjev
Attempt to run a Jev-style System One decision model locally on a single RTX 3090. Companion site at openjev.com.
jevlike
Open reimplementation that trains a small model to choose among a changing list of text options, emitting one probability per option in a single forward pass. Ships Doom, chess and Wikispeedia demos.
jev-trader
Makes one AI trade decision every Monad block on the Kuru MON-USDC market using Jev. Live at jev-trader.vercel.app.
Anil-matcha/awesome-jev-by-typesafe
Independent community collection of use cases, patterns, prompts and starter code for Jev, explicitly not official. The 2023 creation date means the repo was renamed from an older project, so its 412 stars are not Jev-era traction.
typesafe-ai/skills (official TypeSafe agent skill)
Official agent skill for Claude Code, Codex and other agent environments; installs via claude plugin marketplace add typesafe-ai/skills or npx skills add typesafe-ai/skills. MIT licensed.
jkudish/jev-mcp
Proof-of-concept MCP server for Jev that lets Claude Code, Claude Desktop and Codex call the model and receive probabilities they can branch on. The most-starred Jev MCP server found.
JEV Breakdown: The First AI Model Built For Code
Walks through the Choice, Score and Noul primitives live in the TypeSafe playground, with speed and cost numbers and their caveats. The most-watched Jev video found.
wtf is jev?
CJ from Syntax explains what Jev is, how it works, and walks through several use cases and demos. 17 minutes.
[AINews] Jev: a System One Model that only decides/classifies/routes/scores
AI News daily roundup leading with the Jev launch, summarising RLCD and TypeSafe's 20-200x speed and 40-400x cost claims. Frames Jev as part of a broader move toward task-specialised models.
Jev means structured output is interesting again
Argues Jev's speed comes mainly from constrained single-token generation and aggressive prefill, techniques reproducible with existing LLMs, rather than a new architecture. Still treats very fast structured output as a new primitive, while doubting Jev matches frontier models on raw intelligence.
Ran Jev against an existing classifier eval that previously used Gemini 2.5 Flash Lite
Vercel CTO reports Jev saturated an existing classifier eval that had used Gemini 2.5 Flash Lite and ran about 6x faster. Original post; TypeSafe's quote-tweet is a separate item.
Guides
Jev explained: TypeSafe AI's decision model
Jev is TypeSafe AI's System One model: it returns typed decisions and calibrated probabilities, not text. Specs, pricing, access and limits.
Updated
Jev speed and pricing
Jev costs $0.042 per million input tokens with free output. TypeSafe claims 70ms to 500ms and 40x to 200x. What those numbers cover.
Updated
How to get Jev API access
How to get Jev API access: the TypeSafe waitlist, the console key page, the TYPESAFE_API_KEY env var, SDK installs, and a first working call.
Updated
Jev architecture: what is known and what is not
What TypeSafe has said about Jev's architecture: parallel output in one pass, typed answers, RLCD. What it has not said: weights, parameters, design.
Updated