
Infographic
What is Jev, on one page
The call, the three question types, the ticket example, the evals and the limits.
Updated Nov 3, 2026
Docs and reading for a first Jev call: TypeSafe’s quickstart and cookbooks, the LangChain harness guide, the awesome-jev lists and the launch coverage.

Diogo Almeida
@CompleteSkeptic
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 cheaper (w/ output tokens free) • Frontier composable intelligence optimized for decisions AFAICT the shortest path to AI-based economic revolution
Both guides on one page each, then seven links in reading order: our explainer, the quickstart, the launch post, two plain explanations, our guide to Jev Engineering and the list that tracks the rest. Everything below is the rest of the library.

Infographic
The call, the three question types, the ticket example, the evals and the limits.

Infographic
The three-way split, the seven rules, the confidence threshold and the price.

Our guidemadewithjev.com
Our explainer: what a System One model is, the three question types, what it costs, what it cannot do, and the builds that show it working.

Guidedocs.typesafe.ai
The three question types, Choice, Score and Noul, in one support-ticket example.

Guidetypesafe.ai
TypeSafe’s launch post: the model, the evals, and their caveats.
Akshay 🚀
@akshay_pachaar
LLMs vs. Jev, clearly explained! TL;DR The key difference is not that Jev generates faster. Jev does not generate text at all. A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it. Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel. Consider an agent handling a failed deployment. It may need to determine: → Whether the incident is urgent → Which team should handle it → Whether the proposed command is risky → Whether the task is complete An LLM generates a response containing these answers sequentially. The application then parses and validates it. With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities. Jev supports three decision primitives: 1. **Choice** selects from known options, such as engineering, billing, or sales. 2. **Score** places the input on an ordered scale, such as low, medium, or high risk. 3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true. The probabilities matter as much as the selected answers. If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model. This keeps control inside ordinary software. Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text. It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly. It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential. Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments. The clean mental model is this: LLMs generate new language when the answer space is open. Jev evaluates known paths when the answer space is bounded. I wrote the full breakdown explaining Jev and where it fits. The article is quoted below.
Guidex.com
Akshay Pachaar: Jev does not generate text at all. It answers Choice, Score and Noul questions in parallel, and your code owns the thresholds.
Nathan Flurry 🔩
@NathanFlurry
hype-free explanation of jev: jev does not replace gpt / claude jev is just a *really* smart switch statement like if 2016 ml classifiers got 2026 levels of intelligence it's a new* type of tool that will make a lot of workloads insanely fast, cheap, and accurate * = and by new, i mean rebranded ~~~ it needs a predefined set of options and it will tell you which one to take it cannot: - write code - generate natural language - reason step by step / show its work - produce any output you didn't define in advance - pick from more than ~255 options in one shot but it can: - classify, route, score, rank - give confidence - pick the right branch, tool, model, or sub-agent - judge / verify / guardrail an llm's output - label tons and tons of rows ~~~ i'd imagine a lot of workflows that look like: llm proposes options → jev decides → code executes and i see this fitting *really* well with code mode and mcp ~~~ implying this will lead to agi seems incredibly far fetched to me, but i don't want to discount the types of applications that this will make possible
Guidex.com
Nathan Flurry: Jev does not replace GPT or Claude. It works like a very smart switch statement.

Our guidemadewithjev.com
Our guide to the term: split an agent into an LLM that writes, Jev that decides and code that acts, with the rules the builds on this site have in common.

Guidegithub.com
The GitHub awesome list for Jev: use cases, projects, SDKs, tools and learning resources, with pricing, limits and a quick start.
Our guidemadewithjev.com
Our own: a Mac app that sorts, labels and marks your Gmail with a System One model running on your machine, so nothing is uploaded and nothing is installed in your browser. In build now, and the first 50 on the list pay $5.

Our guidemadewithjev.com
Our own count: every public Jev build in week one, with the median published cost per decision, the median decision time, and the stars and languages of every repository created since launch. Free to cite, with the rows as JSON.
Guidetypesafe.ai
TypeSafe’s JevDay post: jev-1.14.0 as jev-preview, image input on 1.13 and 1.14, the Box type and opt-in long context, all behind headers and none of them production-ready yet. jev-latest moves to 1.14 a week after 14 October.
Guidedocs.typesafe.ai
TypeSafe’s reference for image input: the TypeSafe-Danger-Zone-Images header, PNG and JPEG only, 16 MiB per file, 256 to 1568 pixels per side, 32 MiB per request, and images billed as input tokens with no separate charge.
Diogo Almeida
@CompleteSkeptic
Types Beyond Decisions: box We’re also releasing a new type that is somewhere in the gray area of decisions: a single bounding box. We warned you there’s a reason we call them System One Models! (only on jev-preview)
Guidex.com
Diogo Almeida of TypeSafe on the new Box type: one bounding box per question, somewhere in the grey area of decisions, and only on jev-preview.
Alex Warren
@exrhizo
New @typesafeai Jev capabilities! Some decision models can ask questions about images but can they ask questions with images? 🧵 How to get the most out of the new Jev launch
Guidex.com
Alex Warren’s thread on asking questions with images, not only about them, and how to get the most out of Jev 1.14.
Nathan LeClaire
@dotpem
Here's another JEV TIP in honor of JEVDAY Jev can answer as many questions as you can fit into context in parallel. You can ask hundreds in one call, and since output is free, why not? 100 questions on a 32k token input document: ~$0.00001 per question ~1ms per question
Guidex.com
Nathan LeClaire’s JevDay tip: Jev answers every question that fits in context in parallel. 100 questions on a 32k-token document came to about $0.00001 and about 1 ms per question.
Guideyoutube.com/@KodeKloud
KodeKloud’s short: what a System One model decides, and why it answers in milliseconds.
Guideyoutube.com/@CalebWritesCode
Caleb Writes Code: what Jev is and how to use it, in seven minutes.
Guideyoutube.com/@madewithjev
Our own video, under five minutes: an LLM writes, Jev decides and code acts, where the term comes from, and how to move your first decision.
Matt Canham
@matthewcanham
I've had many people reach out saying they've read everything they can about Jev but still don't get it. Here's an explanation for the normies

Guidex.com
Matt Canham’s X article, written for everyone who read the launch posts and still did not get it.

Avid
@Av1dlive
everything you need to start building with jev, in one article. code, architecture, diagrams... everything you need to follow the build and make it your own.

Guidex.com
Avid’s builder’s guide, and the fullest public write-up of the pattern: where the decision layer sits in a coding harness, the five rules that keep it enforceable, and keel, the Rust app it was built in. Honest about the self-improvement part it has not proved.
CyrilXBT
@cyrilXBT

Guidex.com
cyril on where the 200× and 400× headline figures come from and why they are a ceiling rather than a typical result: 31 bounded checks counted in one real session, and the decision-point audit that finds yours.
unicode
@unicodef1wn

Guidex.com
unicode’s 12-step roadmap for a self-managing company: the Grok Bot marketplace supplies the workers, and Jev answers the five forks between them — who goes next, is the research good enough, continue or stop, is it done, does this need a person.
Hassan
@nutlope

Guidex.com
Together AI fine-tunes a Jev-like classifier on Qwen3.5 4B: about 38,000 questions sampled from eight public datasets, roughly 25 minutes of training, and the tev1 repository that runs it. The $17 is the training job, not the system around it.
GREG ISENBERG
@gregisenberg
Jev is HERE and this is the CLEAREST explanation of what it is and what NEW businesses it unlocks. (and at the end I'll tell you how to get Jev even if you're on the waitlist) WHAT IT IS You know how you open your inbox and have to decide what's junk, what needs a reply, and what can wait? Jev does that part. It looks at each thing and says "this is junk, I'm 94% sure." It doesn't write anything back to you. It just sorts. 1,700 emails for 18 cents, instantly. That sounds kinda trivial but the important part WHAT IT UNLOCKS My explanation of Jev sounds small until you realize HOW MANY jobs are exactly this. Someone reading a stack of applications. Someone deciding which support ticket goes to which team. Someone looking at inbound and deciding who's worth calling back. A few ideas on what it unlocks: 1/ Instant quotes that are actually instant. Every quote form on the internet says "we'll email you by end of day." Build the version that answers in under a second, for roofers, movers, insurance, legal intake. 2/ Lead scoring as a product. Every agency and service business has a contact form full of junk. Score every submission and send the real ones straight to the owner's phone. 3/ Support triage for companies with no support team. The ticket gets classified and routed before anyone opens it. 4/ Clipping tools. Pass in a transcript, get the best moments scored in three seconds. Every clipping product just got a cheaper engine. 5/ Application piles. Grants, permits, insurance claims, job apps, loan docs. Someone reads that stack one item at a time today. 6/ Marketplace matching. Someone types what they need and gets matched to the right local business instantly instead of waiting for callbacks. 7/ Browser agents that actually move FAST. That makes bulk browser work practical: pulling quotes from five carriers, filing the same form for 200 clients, checking supplier inventory in real time etc. TLDR; find an expensive queue and put Jev at the front of it. HOW TO GET IT I didn't realize you can skip the waitlist because Jev is live on the Vercel AI Gateway right now, so you can start calling it today. In this episode, we share how. Episode now live on @startupideaspod (thanks to @ryanvogel for coming on and spilling the sauce today) Watch: https://www.youtube.com/watch?v=4mTLpuQpB80 Jev is a big deal because this is a whole new way to do AI Really cool Happy Jev day.
Guidex.com
Greg Isenberg: find an expensive queue and put Jev at the front of it. Seven ideas, from instant quotes to lead scoring, plus a Startup Ideas Pod episode with Ryan Vogel.

Guidedocs.typesafe.ai
TypeSafe’s recipe for picking at most one skill per agent turn out of 182: one request ranks them all, a second reads the top three.

Guidedevelopers.cloudflare.com
Examples for support routing, refund decisions and risk escalation.

Guidelangchain.com
Routing between models, and blocking risky tool calls with a Jev decision.

Guideflaviocopes.com
Flavio Copes on triage, RAG filtering, citation checks and confidence thresholds.

Guideblog.lepine.pro
Jean-François Lépine on Choice, Noul and Score, calibrated confidence and batching questions, with a complete Python project.


Guidedev.to
Valyu’s practical guide to TypeSafe’s System One model, on DEV.

Guideskillsagentes.com
Skills Agentes’ guide in Spanish: what Jev does, what it costs, what the evals say, and where it fits in an agent.

Guidearcherhume.com
Archer Hume probed Jev with 10,000 API calls to work out roughly how it is built.
iwashi / Yoshimasa Iwase
@iwashi86
Jevの内部アーキテクチャを推測している技術記事(Jev’s Architecture Unmasked)からメモ。 ・本記事はJevのAPIを約1万回の呼び出して、内部構造を推測したもの ・従来の言語モデルを用いた分類やルーティングでは、トークンを1文字ずつ逐次生成するために膨大な無駄な計算コストが発生していた。 ・JevはLLMの膨大な知識をそのまま保持しつつ、テキスト生成を完全に排除して内部表現から直接確率を出力する ・システム全体の構造は、共通の文脈をエンコードする共有状態、並列に処理される質問群、そして確率を直接読み出すヘッドの3要素から成立 ・モデルは入力を左から右へ読む事前学習済みの因果トランスフォーマーであり、プロンプト処理の直後に推論を終了する ・テキスト生成ループは存在しない ・だから、単語の綴りやJSONのフォーマットを出力するためのステップが一切不要 ・APIレスポンスに含まれる出力トークン数という項目は、単に返却された文字列の長さから、後で計算された課金用の指標にすぎない ・選択肢が2個の場合でも200個の場合でもサーバーの処理時間はほぼ変化せず、モデルがトークンを逐次生成していない事実を強く裏付けている ・入力データは共有状態と複数の質問に分割され、問い合わせ本文などの共通コンテキストは一度だけKVキャッシュに保存される ・複数の質問は同じ共有キャッシュを参照するため、質問数が増加しても共有状態を何度も再計算する必要がない ・それぞれの質問はお互いの存在や指示が見えないようになっている ・質問同士が干渉することなく完全に隔離された状態で推論される ・ある質問内に秘密のコードを記述しても別の質問からは参照できない ・共有状態に置いた場合のみ全質問から認識可能 ・約100個の質問まではリクエストの処理時間がほとんど増加せず、共通状態を一度だけ計算して並列処理する設計の恩恵が明確に現れている ・Jevが持つ高度な知識水準を考慮すると、双方向エンコーダを新規開発したのではなく、既存の因果デコーダ型LLMを再利用した可能性が極めて高い ・トークナイザの挙動は既存の公開モデルと完全には一致しない ・数字の分割方法やチャンク処理に独自の工夫が見られる ・選択肢の並び順に関する実験では、判断の根拠となる情報が選択肢リストの末尾に配置されていてもモデルは正しく正解を選択できた ・質問に含まれる各選択肢は独立して採点されるのではなく、リスト全体が互いに文脈として影響を及ぼし合った上で判断される ・無関係なダミーの選択肢を追加すると既存の選択肢間の相対的なオッズ比が変化した ・このことから、選択肢同士が相互作用していることが実験的にわかる ・リスト全体を一括して読み込む設計のおかげで、上記のどれでもないといった他の選択肢に依存する回答も適切に処理できる ・選択肢の提示順序を逆転させると出力確率に若干の変動が生じるため、実務で特定の閾値を用いて自動処理を行う際は順序バイアスへの配慮が求められる ・学習手法にはRLCDと呼ばれる独自のアプローチが採用されている ・強化学習の枠組みを用いて真の結果に即した予測確率を出力するように調整されている ・モデルの出力は対数損失やブライア損失といった適格スコアリングルールで最適化され、正直な不確実性を反映した確率分布を形成する ・ベンチマークの検証結果において予測確率と実際の正解率は高精度に一致しており、期待キャリブレーション誤差は0.0313という極めて低い値を記録した ・難易度の高い数学問題ではモデルが提示する正解確率自体が低下する ・なので、自身の知識の限界に応じた不確実性を表現できている ・APIが返す信頼度スコアは学習された固有値ではなく、得られた確率分布の最大値から算術計算で求めた便宜的な数値にすぎない ・Jevのバックボーンには、必要な専門モジュールのみを選択的に起動するスパースなMixture of Expertsが採用されていると推測される ・テキスト生成を行わないプロンプト処理のみのタスクでは計算負荷がボトルネックとなるため、疎な構造による演算量削減が大きな効果を発揮する ・約3万トークンの入力をわずか160ミリ秒程度で処理する速度性能は、巨大な密結合モデルではなくMoEを採用している推測ともあう ・質問枝はチャットのような逐次的会話ではなく独立したバッチとして処理されるため、GPUリソースを最大限に活用した一括計算が可能 https://archerhume.com/posts/jevs-architecture-unmasked
Guidex.com
Yoshimasa Iwase’s notes on Archer Hume’s article: shared state, isolated questions, calibration and a likely mixture of experts.

Guidetech.layerx.co.jp
LayerX ran a 30-minute internal session on Jev. More than 50 engineers came, and they left with more than 50 ideas for their products.

Guidenews.ycombinator.com
The launch discussion, including the doubts about the benchmarks.

Guidetechcrunch.com
TechCrunch on Jev: why developers see a cheaper and faster path to software intelligence.
Moritz Kremb
@moritzkremb
Full Jev Tutorial What it is, how you can build with it and what new applications it can unlock → 0:00 Intro → 0:34 Jev explained → 4:06 API setup → 5:59 Demo 1: Voice-controlled browser → 11:33 Demo 2: AI memory → 17:27 Demo 3: YouTube predictor
Guidex.com
Moritz Kremb’s video: what Jev is, API setup, and three demos: a voice-controlled browser, AI memory and a YouTube predictor.
cocktail peanut
@cocktailpeanut
Jev is cool not because it re-invented classification, but because it makes ARBITRARY classification into a type-safe programmable primitive. A general purpose zero shot decision model whose native interface is RUNTIME-DEFINED typed decisions, optimized for that exact interface
Guidex.com
cocktail peanut: Jev did not reinvent classification. It makes any classification a typed decision you define at runtime.
Paarangat
@paarangatrai
this is the easiest way to understand Jev: LLMs generate answers. Jev makes decisions. that sounds like a small difference, but it actually changes the entire use case. say you give a normal LLM this: “here’s a user, their account history, payment behavior, support chats, device data, etc. tell me if this looks risky.” the LLM might reason through it and return: “yes, this looks high risk.” maybe in JSON if you ask nicely. with Jev, you define the possible decisions upfront: risk: * low * medium * high manual review: * yes * no and Jev returns something closer to: risk = high (96%) manual review = yes (91%) that’s basically the product. it’s not trying to be another ChatGPT. it’s more like an AI-native if statement. instead of: if transaction > $10,000: review() you can start thinking more like: if “does this behavior look suspicious?” > 95%: review() and that opens up a pretty interesting category of software. a few assumptions I had at first that turned out to be wrong: 1. “so it’s just a classifier?” kind of, but that undersells it. the input can be messy real-world context, and you can ask multiple typed questions about that state at once. fraud? churn? escalate? eligible? priority? all from the same input. 2. “so it replaces GPT / Claude?” not really. I actually think the interesting architecture is: Jev decides WHAT needs to happen Claude / GPT reason or generate WHEN deeper intelligence is needed normal code executes the deterministic stuff. Jev becomes the routing layer. 3. “it can’t hallucinate?” this one needs nuance. if your allowed answers are: LOW MEDIUM HIGH Jev won’t suddenly invent: “EXTREMELY HIGH 🚨” the output structure is constrained. but it can still be wrong. HIGH at 92% can still be the wrong decision. so “no hallucinations” doesn’t mean “always correct.” 4. “why not just force an LLM to return JSON?” you can. we already do this everywhere. but you still deal with generation latency, schema validation, retries, weird outputs, confidence estimation and a lot of glue code. Jev is designed around the decision itself rather than text generation. 5. “why should I care?” because most software is ultimately a giant tree of: if this → do that if this → route here if this → escalate if this → reject if this → ask a human Jev is basically asking: what if those if statements could understand messy human context? that’s a much more interesting framing than “another AI model.” I can see this being very useful for: fraud / risk support routing moderation PR / QA automation lead scoring compliance workflow orchestration agent routing especially as the cheap + fast decision layer sitting in front of larger reasoning models. early tech, obviously. but the category itself makes a lot of sense.
Guidex.com
Paarangat explains the difference with a user-account example.
What to read before you build: TypeSafe’s own quickstart, docs and cookbooks, the LangChain harness guide, the awesome-jev lists other builders keep, and the launch coverage.
181 guides