Resources for building with Jev

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.

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

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

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

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

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.

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.

david fant

@da_fant

jev will make agents 10x faster and cheaper, here's how: 1/ model routing: pick the right model for each task, without training a custom router https://x.com/mdlahfir/status/2100314182201802811?s=20 2/ computer use: faster, cheaper and more reliable for action-heavy tasks https://x.com/gregpr07/status/2100411066966749359 3/ auto review: ask jev whether an action is safe, instead of using a slow and expensive LLM https://x.com/fazxes/status/2100300097695232164?s=20 4/ less obvious: subagent orchestration long-running agents (cursor projects, grokbot, energy) parallelize work with subagents. but every user message, email, or subagent reply can wake the expensive orchestrator. example: it costs $1 to wake up gpt 6 astra w 100k input tokens jev can decide what each event needs: - route directly to a subagent - queue for later - wake the orchestrator

Matt Van Horn

@mvanhorn

TL;DR of my new article: WTF is Jev by @typesafeai, and the 9 things people are already building with it. The thesis: 𝗮 𝗰𝗼-𝗰𝗿𝗲𝗮𝘁𝗼𝗿 𝗼𝗳 𝗖𝗵𝗮𝘁𝗚𝗣𝗧 𝘀𝗽𝗲𝗻𝘁 𝘁𝘄𝗼 𝘆𝗲𝗮𝗿𝘀 𝗶𝗻 𝘀𝘁𝗲𝗮𝗹𝘁𝗵 𝗼𝗻 𝗮 𝗺𝗼𝗱𝗲𝗹 𝘁𝗵𝗮𝘁 𝗰𝗮𝗻𝗻𝗼𝘁 𝘄𝗿𝗶𝘁𝗲 𝗮 𝘀𝗲𝗻𝘁𝗲𝗻𝗰𝗲, 𝗮𝗻𝗱 𝗶𝗻𝘀𝗶𝗱𝗲 𝟳𝟮 𝗵𝗼𝘂𝗿𝘀 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘄𝗶𝗿𝗲𝗱 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗲𝘃𝗲𝗿𝘆 𝗰𝗵𝗲𝗮𝗽 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁 𝗰𝗮𝗹𝗹 𝗮𝗻 𝗮𝗴𝗲𝗻𝘁 𝗺𝗮𝗸𝗲𝘀. Think AI multiple choice, not AI essay writing. It doesn't chat. You hand it app state plus a typed question, it hands back a decision with a probability attached. 𝟯𝟭.𝟰𝗠 𝘃𝗶𝗲𝘄𝘀 on the launch post in two days (@CompleteSkeptic, who co-invented RLHF). I ran @slashlast30days on it 11 times, then checked every big post by hand. 🌐 𝗔 𝘁𝗶𝗻𝘆 𝗼𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲 𝗯𝗿𝗼𝘄𝘀𝗲𝗿 𝗮𝗴𝗲𝗻𝘁 𝗳𝗼𝘂𝗻𝗱 𝗳𝗹𝗶𝗴𝗵𝘁𝘀 𝗶𝗻 𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 $𝟬.𝟬𝟬𝟯𝟵. New action space every step, DOM as state, Jev picks the click, a small LLM only wakes up to type. The Browser Use founder built it (@gregpr07, 7.2K likes, 1.8M views) and had to note the video is 1x speed 🧹 The sleeper: instant compaction. Score every tool call, drop the junk, skip the summarization prompt entirely. "𝘪𝘯 2026, 𝘸𝘩𝘺 𝘪𝘴 𝘤𝘰𝘮𝘱𝘢𝘤𝘵𝘪𝘰𝘯 𝘴𝘵𝘪𝘭𝘭 𝘢 𝘴𝘶𝘮𝘮𝘢𝘳𝘪𝘻𝘢𝘵𝘪𝘰𝘯 𝘱𝘳𝘰𝘮𝘱𝘵?" asked @tamarajtran, 5K likes, then shipped the answer that afternoon. Run as a Claude plugin it took a session 𝗳𝗿𝗼𝗺 𝟭𝗠 𝘁𝗼𝗸𝗲𝗻𝘀 𝘁𝗼 𝟴𝟲𝗞 𝗶𝗻 𝗼𝗻𝗲 𝘀𝗲𝗰𝗼𝗻𝗱 (@altryne). Diogo's reply: "𝘧𝘳𝘦𝘦 𝘤𝘰𝘥𝘪𝘯𝘨 𝘢𝘨𝘦𝘯𝘵𝘴 𝘧𝘳𝘰𝘮 𝘥𝘦𝘴𝘪𝘨𝘯𝘪𝘯𝘨 𝘢𝘳𝘰𝘶𝘯𝘥 𝘵𝘩𝘦 𝘒𝘝 𝘤𝘢𝘤𝘩𝘦" 🛡️ Vercel put it in production as the safety reviewer in fx auto mode. 𝗨𝗽 𝘁𝗼 𝟭𝟴𝘅 𝗳𝗮𝘀𝘁𝗲𝗿 𝗮𝘁 𝗽𝟵𝟱 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲 𝗮𝗰𝗰𝘂𝗿𝗮𝘁𝗲 than the model it replaced, per @rauchg, 3.7K likes. LangChain open-sourced the same idea the next day as AutoModeMiddleware. The closed danger classifier inside every coding harness is now a 100ms primitive 🚦 Model routing as middleware instead of a paragraph in a system prompt. About a dozen lines, probabilities left in agent state so you can audit the choice. The LangChain writeup by @sydneyrunkle is the cleanest how-to-wire-it piece anyone has published 🔎 RAG precision, solved the dumb way: retrieve as usual, run Jev on every chunk, delete the irrelevant ones. "𝘢𝘭𝘴𝘰 𝘥𝘪𝘥 𝘢𝘯𝘺𝘰𝘯𝘦 𝘳𝘦𝘢𝘭𝘪𝘻𝘦 𝘫𝘦𝘷 𝘴𝘰𝘭𝘷𝘦𝘥 𝘱𝘳𝘦𝘤𝘪𝘴𝘪𝘰𝘯 𝘪𝘯 𝘙𝘈𝘎?" (@kushbhuwalka, 416 likes) 🎮 Minecraft in real time: 𝗝𝗲𝘃 𝗿𝗲𝗮𝗰𝘁𝘀, 𝗚𝗣𝗧-𝟲 𝗔𝘀𝘁𝗿𝗮 𝗽𝗹𝗮𝗻𝘀, and they fight multiple zombies at once (@wuyang_zhou). A launcher that reads intent on every keystroke in about 100ms (@dabit3). TypeSafe's own demo is Doom at 10 decisions a second, roughly $7 an hour 📬 Email triage at scale: 1,500 emails in batches of 100 with 8 workers, 60,996 views on the demo. "𝘞𝘦 𝘰𝘯𝘭𝘺 𝘩𝘢𝘷𝘦 𝘢 𝘣𝘢𝘭𝘢𝘯𝘤𝘦 𝘰𝘧 $5 𝘥𝘰𝘸𝘯 𝘩𝘦𝘳𝘦, 𝘸𝘩𝘪𝘤𝘩 𝘫𝘶𝘴𝘵 𝘴𝘩𝘰𝘸𝘴 𝘩𝘰𝘸 𝘤𝘩𝘦𝘢𝘱 𝘵𝘩𝘪𝘴 𝘮𝘰𝘥𝘦𝘭 𝘪𝘴" 🗂️ 𝟳𝟳𝟳 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁𝘀 𝗶𝗻 𝘂𝗻𝗱𝗲𝗿 𝟬.𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 𝗮 𝗾𝘂𝗮𝗿𝘁𝗲𝗿 𝗼𝗳 𝗮 𝗰𝗲𝗻𝘁. Every's head of evals asked 21 questions of 37 documents in one request, and that is what came back 🧪 Jev in your browser: Reflex, a Qwen model doing structured decisions on WebGPU, built at Shopify by @kshetrajna and passed around by @tobi. Three independent clones inside 72 hours. 𝗧𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗶𝗻𝘃𝗲𝗻𝘁𝗶𝗼𝗻, 𝗻𝗼𝘁 𝘁𝗵𝗲 𝘄𝗲𝗶𝗴𝗵𝘁𝘀 🔌 Already behind the gateways you use: @vercel AI Gateway inside 48 hours (2,341 likes, the company's second-biggest post), Cloudflare, and @OpenRouter in beta 💸 𝟱,𝟬𝟬𝟬 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗳𝗼𝗿 𝗮𝗯𝗼𝘂𝘁 $𝟮. That was one developer counting his bill on day one (@MichaelLee04, 3,060 likes). Input is $0.042 per million tokens. Output is free 🧨 The honest part: Every's second test came out 𝟮𝟱𝘅 𝗳𝗮𝘀𝘁𝗲𝗿, 𝗻𝗼𝘁 𝟮𝟬𝟬𝘅, and Jev caught 6 of 7 planted defects to Fable 5.1's 7. The HN launch thread (1,863 points) spent most of its length on "can't hallucinate." Top critical comment: "𝘪𝘵 𝘤𝘢𝘯'𝘵 𝘦𝘮𝘪𝘵 𝘢𝘯 𝘪𝘯𝘷𝘢𝘭𝘪𝘥 𝘵𝘺𝘱𝘦, 𝘣𝘶𝘵 𝘪𝘵 𝘤𝘢𝘯 𝘴𝘵𝘪𝘭𝘭 𝘦𝘮𝘪𝘵 𝘢 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦𝘭𝘺 𝘸𝘳𝘰𝘯𝘨 𝘷𝘢𝘭𝘪𝘥 𝘷𝘢𝘭𝘶𝘦." Diogo called the "it's a zero-shot classifier" read "𝘷𝘦𝘳𝘺 𝘢𝘤𝘤𝘶𝘳𝘢𝘵𝘦!" And the biggest Reddit thread is someone who open-sourced the same architecture a year ago, 1,568 upvotes. Top reply: "𝘉𝘶𝘵 𝘥𝘪𝘥 𝘺𝘰𝘶 𝘱𝘰𝘴𝘵 𝘪𝘵 𝘴𝘢𝘺𝘪𝘯𝘨 𝘪𝘵'𝘴 𝘵𝘩𝘦 𝘯𝘦𝘹𝘵 𝘣𝘪𝘨 𝘵𝘩𝘪𝘯𝘨? 𝘙𝘰𝘰𝘬𝘪𝘦 𝘮𝘪𝘴𝘵𝘢𝘬𝘦" Bonus: the name is not Kahneman. It's William Stanley Jevons, of Jevons paradox. Make a resource cheaper and people consume far more of it. Naming your decision model after that is a thesis statement. 𝗞𝗲𝗲𝗽 𝘁𝗵𝗲 𝗯𝗶𝗴 𝗺𝗼𝗱𝗲𝗹 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗮𝗻𝗱 𝘄𝗿𝗶𝘁𝗶𝗻𝗴. 𝗨𝘀𝗲 𝗝𝗲𝘃 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗿𝗮𝗽𝗶𝗱-𝗳𝗶𝗿𝗲 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 𝗶𝗻 𝗯𝗲𝘁𝘄𝗲𝗲𝗻. That's the whole article.

codila

@0xCodila

Jev is the "Internet" moment for the AI industry It tells your agents and LLMs what to do next, in milliseconds and at almost zero cost If you set it up correctly, you will have the AI engineer’s stack for 2028 In this article, I show you how x.com/i/article/2077…

Movez

@0xMovez

x.com/i/article/2100…

Ricker

@0xRicker

Jev could become the control layer AI agents have been missing. Instead of spending 5–20 seconds and expensive LLM calls deciding every next step, it can route actions in milliseconds at near-zero cost. In this article, I break down how x.com/i/article/2101…

Charly Wargnier ♨️

@DataChaz

Jev might genuinely be an “Internet moment” for AI. TypeSafe reports up to 193x faster and 444x cheaper performance in tests with Claude Fable 5.1 and GPT-6 Astra. @0xCodila just wrote a great 10-page article explaining what Jev is, how to use it, and where its 100x advantage comes from. Here are the 10 steps: 1 → LLMs create. Agents act. Jev decides the next move. 2 → Turn agent forks into three primitives: Choice, Score and probability. 3 → Build with OpenAI, Anthropic or xAI first, then swap Jev in without rebuilding the graph. 4 → Start with shared state, parallel decisions, risk thresholds and an execution queue. 5 → Batch decisions instead of making them sequentially. In one test, 13 questions were 10x faster and 12.2x cheaper. 6 → Put Jev at bounded forks: agent, model, tool, browser action or human escalation. 7 → Benchmark the whole loop, not just individual model calls. 8 → Rank wide, read narrow: shortlist first, then spend compute on what matters. 9 → Reuse the same system: State → Questions → Action → Verify. 10 → Keep Jev out of math, writing and irreversible execution. Code computes, LLMs create, Jev decides. The result: A slow, expensive agent loop becomes a much faster decision system that can route, score and escalate in milliseconds. Full breakdown below ↓

Codez

@0xCodez

Jev Founder, Diogo Almeida (ex-OpenAI): "The next era is not the Claude Code or Codex era, they are still part of the assistance era with human in the loop - JEV is what comes next for LLMs x200 faster, x400 cheaper, 0 hallucination, no human in the loop - that's JEV, this is how LLMs will look like" in 36-minute tech talk, Jev Founder explained why RLHF isn't a thing anymore and how modern LLMs will be built this talk is worth more than a Stanford Machine Learning degree watch today no matter what, then learn how to become a Jev Engineer in the article below

darkzodchi

@zodchiii

Jev Founder (ex-OpenAI): "I believe JEV is the biggest breakthrough we've ever worked on This sounds too good to be true but it's beating everything" In 5 minutes, he breaks down why older LLMs were great at talking and terrible at deciding and building. Watch it and then read the guide below on how to use it at it's fullest 👇🏼

Scott Williams

@swill1ams

Prediction: millionaires will be made using custom Jev style models (parallel constrained decoding) to make the agent systems companies already run more token efficient. Let me explain with a scenario: Imagine a company already has an agent workflow running where an llm reviews every item before it moves on: a support ticket gets triaged, an invoice gets approved or held, a claim gets flagged. Every one of those goes through a frontier model today, a few seconds and a few cents each, on the way to a decision that in most cases is obvious. Behind that flow sits years of humans (or agents) making the exact same call, with the outcome attached. Now imagine you first run each item through a custom PCD or similar model that costs a fraction of the llm and returns a classification of what to do at that step, with a mathematically accurate probability attached. When it's confident, the item skips the llm entirely. When it isn't, the llm handles it as normal. The model has seen years of your team making this exact decision, usually a constrained set of decisions, so it should be right most of the time. Say it comes back confident on 6 out of 10 items. That's more than half your llm spend potentially gone from that step, likely with comparable accuracy. This pre processing idea works in a bunch of other use cases too, such as: - model/request routing: cheap model, frontier model, or a human - picking which skill or subagent to load for a turn instead of stuffing the whole catalog into context - reranking retrieved context so only the relevant chunks reach the window - guardrails on every agent turn: contradictions, policy issues, prompt injection - extracting typed fields from unstructured data emails, PDFs and transcripts before anything expensive touches them Every one of those is a decision an llm makes today, that could potentially be done by another, cheaper model class. Very excited to see Jev/PCD-based pre processing use cases get deployed to agents at scale.

Alex Volkov

@altryne

This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run! Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮 Ask your claude to install it and be amazed Use this prompt ``` Install, and configure : https://github.com/tamaratran/fast-jev-compaction ```

梭哈.AI

@SUOHA_AI

连 JEV 的联合创始人 @CompleteSkeptic 都亲自下场转发点赞：这是 JEV 正确的打开方式！ 大家在 Claude Code 里写长代码，最恶心的就是上下文一满，系统就卡住 10 秒去写总结小作文 开发者 @tamarajtran 刚刚开源了这个插件：利用 JEV 的打分能力，几十毫秒内精准识别并清空所有没用的终端垃圾与冗余日志 Github：https://github.com/tamaratran/fast-jev-compaction 它的作用是： • 彻底治好 Agent 失忆症：几千行终端废话和文件内容让 JEV 毫秒级打分，没用的直接扔，核心代码与状态 100% 原样保留 • 彻底消灭卡顿与账单：几十毫秒无感完成瘦身，不花一分钱废话 Token @typesafeai 的联合创始人 Diogo Almeida 也公开实名认可：这就是编码 Agent 绕过传统 KV 缓存的最佳解法🧐

Erick

@ErickSky

Este tipo de herramientas empieza a hacer que el contexto de los agentes parezca menos una ventana limitada y más una memoria que se administra dinámicamente. [fast-jev-compaction] No resume, hace que Jev analice cada tool call y su resultado para decidir qué sigue siendo necesario. - Lo que importa se queda verbatim. - Lo que ya no aporta, se elimina. - Y los resultados que todavía pueden ser útiles permanecen intactos. Además: • Funciona como plugin de Claude Code • También puedes usarlo como librería npm • Las decisiones se toman sobre el contexto completo • Puede truncar resultados o eliminarlos junto con su llamada • Mantiene intactos los mensajes de usuario y assistant • Tiene fallback al compaction tradicional de Claude Code En otras palabras: En vez de resumir tu memoria, intenta podarla. REPOOO👇

Theo - t3.gg

@theo

This is a terrible compaction strategy that fundamentally doesn't understand how compaction and context management work. Seems like a lot of people are confused so let's break this down. 1. Compaction isn't a filter The role of compaction is to clean up history to keep the agent focused, not just deleting noise. It should be used sparingly when context gets too long, not constantly to keep context small. 2. Jev doesn't even know what it's deciding on! Models use the context of the thread to decide what to keep or not keep in a summary. This implementation goes through on a "line-by-line" (per tool call) basis to decide what should be left or deleted. Not only does this 32k token context model know very little of what happened before, but (in this implementation) it doesn't even know what the result of the tool call is! Deleting these things randomly will keep the model from knowing what it's tried and dooms you to end up in "stupid loops" where the model keeps trying the same thing over and over. 3. You're giving up the reasoning entirely Frontier models from OpenAI, Anthropic, XAI, and Google do not share reasoning traces over the API. They share encrypted payloads, which Jev cannot see (and often will drop). Anthropic is even stricter with this, requiring you to preserve the entire history in order to get any of the reasoning data. As a result, using this in Claude Code guarantees the model will act way dumber. 4. Models are tuned on their compaction flows For the last year, Frontier Labs have been including compaction and long runs as part of the training process. These models have learned ways to compact that are more effective than any rudimentary solution. Fun fact: If you switch models in Codex and compaction is necessary, compaction will run on the model that was previously used in the thread. 5. Cache writes are more expensive than cache reads. Cache writes are the biggest cost by far for agents. I often see cache write costs go over 60% of my total LLM spend in my personal use of Claude Code and Codex. Cache writes are insanely expensive when data earlier in the history is changed (because the old cache is invalidated when things change at the top). Every history edit requires a cache rewrite for ANY data past the history edit. If your history is "1,2,3,4,5,6" and you delete "2", you have to rewrite "3,4,5,6". This is more expensive than leaving "2" in the history. Good news. Since we're already killing all of the reasoning tokens by doing this stupid compaction strategy, the rewrite cost won't actually be that high because the model is missing so much data! 🙃🙃 6. The implementation is hot garbage. > "Whatever is not kept is deleted permanently, but the assistant can always re-run a tool or re-read a file." Good luck with that one. To be clear: this is a cool experiment and I find it genuinely interesting. That said, if you think this style of bs filtering on a probability threshold is actually a compaction strategy, I highly recommend you just use the defaults in tools like Claude Code and Codex. You're much less likely to hurt yourself that way.

Tonino Catapano (tonnoz)

@tonnoz

You still don't understand the use cases Jev unlocks. I've been waiting for something like this since early ChatGPT models. prediction: we will see the fastest-growing SaaS by MRR in history within the next month or two

Ian Nuttall

@iannuttall

Unsure how to get started with Jev? Install the skill: npx skills add typesafe-ai/skills --skill typesafe-ai Then prompt in your project: use /typesafe-ai to see how Jev can be used to replace slow, expensive LLM usage and find possible new features it would enable for users.

OpenRouter

@OpenRouter

Jev by @typesafeai is now on OpenRouter, in beta. Jev is a System One model. Instead of generating text, it takes your app's state plus a typed question and returns a typed decision with a probability attached. There is no JSON prompting, parsing layer, and nothing to validate against.

Cloudflare Developers

@CloudflareDev

Jev from @typesafeai is now live on @CloudflareDev AI Gateway. Try the first System One model — send state and typed questions; get structured answers your code can use directly. developers.cloudflare.com/ai/models/type…

Matt Van Horn

@mvanhorn

WTF is Jev by @typesafeai? Here’s the tl;dr ELI5: Think AI multiple choice, not AI essay writing. It doesn’t chat. It makes decisions your software can act on: “Spam or not?” “Which tool should this agent use?” “Does this need a human?” The exciting part: roughly 200x faster and 400x cheaper than frontier LLMs in TypeSafe’s own workflow benchmarks, with responses in a fraction of a second. Why that’s powerful: imagine an app or agent making hundreds of little judgment calls without hundreds of expensive, slow conversations with an LLM. Keep the big model for the hard thinking and writing. Use Jev for the rapid-fire decisions in between. Excited to dig in.

Isaac Flath

@isaac_flath

I've been using Jev by @typesafeai Here's the six things i've tried and am confident I'll still use Jev for 60 days from now. There's many more experiments, ideas, and things I think I will use it for. It's a big deal (more on why in next post). But I am only sharing things that I am 99% sure will lead to stuff I will still be using Jev for in 60 days. That means I started with small, boring, but useful, stuff. - Fact-checking my scripts - Ranking my news feed - Finding the right text in PDFs - Checking citations - Grouping my review notes - Figuring out why agents fail (eval over traces) https://isaacflath.com/writing/six-things-i-tried-with-jev

Kostas

@Kostastsale

This made me rethink where AI actually fits into security engineering. For purely engineering work, forget about ChatGPT or Claude. TypeSafe AI just released Jev, and I think it’s going to change how we build AI into security workflows. Instead of asking an LLM to “investigate this,” you define the questions and possible outputs, then get structured probabilities and decisions your code can actually use. For security, the possibilities are huge. Think of the below use cases 🤯: Threat Hunting: ➡️ Rank broad hunt results by relevance ➡️ Score users, hosts, processes, or sessions based on how suspicious their surrounding activity looks ➡️ Classify noisy activity at scale. Think thousands of rundll32.exe executions automatically grouped into expected admin activity, software execution, suspicious usage, or unknown Detection Engineering: → Classify historical alerts for FP analysis → Add context-aware scoring on top of deterministic detections → Validate whether an alert actually supports the behavior the rule claims to detect Incident Response: → Reduce massive timelines down to the events most relevant to the intrusion → Continuously score hosts/users for possible compromise → Help prioritize scope expansion, triage, and response decisions This feels much closer to how AI should be integrated into security engineering. I'm currently working through most of the above, mostly focusing on instant response, but at the same time doing some of the threat hunting use cases that I mentioned. Typesafe AI can be basically a decision engine sitting inside the workflow while being x200 fast and cheaper. Don’t sleep on this... This is huge! 👉 https://typesafe.ai/

Jason Zhu

@GoSailGlobal

拿 Jev 做搜索重排，我先泼一盆冷水：单独用，它没打赢向量检索 TypeSafe 的 Jev 这阵子很火，一堆项目拿它做重排。我们在 Agent Skills Hub 的 33,047 条目录上认真测了一次，164 条中英文真实查询，9,831 对分级标注，整套只花了 2.6 美元 三个结论 01｜单独重排，约等于没赢 Jev 重排 bge-m3 的前 30 条，NDCG@10 只多了 0.012，置信区间跨过零。MRR 和前三命中率倒是涨得明显，它很会把最强的那一条顶到第一，后面几条基本是重新洗牌 02｜裁判偏差，被我们量出来了 Jev 自己也参与了打标注，这就是循环 只用 Jev 当裁判，它领先 0.053 两个裁判合并，领先 0.012 只用 Haiku 当裁判，反而落后 0.028 同一组比较，换个裁判结论直接翻面。所有涉及 Jev 的结论，我们只认 Haiku 那一列 03｜真正稳赢的是融合 把 Jev 和 bge-m3 的排序做 RRF 融合，NDCG@10 到 0.864，比纯向量高 0.064 到 0.116，三种裁判下都成立。代价是每次查询多一次 API 调用，约 0.0002 美元 顺便暴露了我们自己的问题：Hub 线上 CLI 用的关键词排序只有 0.609，短板是召回。相关结果有一半压根没进候选，后面怎么重排都救不回来 数据、标注、每条查询的得分全部开源，不用 API key 就能复现打分

Jiayuan (JY) Zhang

@jiayuan_jy

一些关于 Jev (@typesafeai) 的 notes 研究了一天 Jev，带来的新鲜感迅速回落，这好像就是一个更快的通用分类器/决策器，LLM 完全可以做到。 而且因为不了解模型背后的参数规模（应该不会很大），世界知识可能不一定有常规 LLM 那么全，在这种情况下，它的复杂场景的决策结果是不是真的准还是要打一个问号的。 在一些有限解空间 + 低延迟要求的问题上，Jev 可能是一个很好的方向，加上形式化输出从程序上保证了正确性。 一个最常见的场景就是 Computer Use，太适合 Jev 了，网页的 Dom 元素是一个有限集，完全可以让 Jev 来做操作，这里面的 loop 相当于是 dom list -> jev action -> new dom list 这样的循环，但是这里 Jev 的推理能力和长上下文情况下的 computer use 效果如何还不清楚，目前还没有看到 benchmark（直观判断肯定是不如 GPT 6 Astra 的，但是速度太快了）。 昨天有尝试把 Pi Agent 中间的一些模块用 Jev 来重写一下，发现可以优化的地方不是特别多，tool using 部分的选择还是不能用 Jev 来代替，因为这不是一个有限集（每一步 tool using 实际上带了很多参数，比如 edit tool，会有具体的 lines 等参数，这部分是需要模型推理出来的，没有办法提前加到 Jev 的决策列表中），但是有一些地方是可以的，比如说 Compaction，可以让 Jev 快速做分类器（LLM 也能做，这里面差异化不太大）。 另外一类场景是依赖决策树逻辑的，例如： - 游戏 AI - 机器人 - 自动驾驶 而且这些场景对实时性要求比较高，传统的 LLM 来做这些事情的一个很大问题就是太慢了（plus 很大一部分场景是缺乏数据来训练的）。 目前正在做的两个 demo： 1. Poker AI，Poker 非常适合这个场景，而且决策树非常长 + 复杂，正在用 Jev 和其他模型做对抗式 battle。（btw 传统的 GTO Wizard 用来做训练实在是太难用了） 2. Pokemon VGC AI，这是严肃的宝可梦双打对战，有世界锦标赛的那种，每个赛季都有对应的规则，因为数据很全，所以非常适合用来研究 AI 的决策，plus 之前竟然没有一个很好的用来个人训练的 AI（这个做完了打算用这个 AI 实际在 Pokemon Champion 排位赛里用一下）。 这两个 demo 场景都是偏回合制的，其实用 LLM 也能做。

Jason Zhu

@GoSailGlobal

一个只会做选择题的小模型，能长出多少玩法？ TypeSafe 的 Jev 就是这么个东西：给它最多 255 个选项，几百毫秒挑一个，再附一个校准过的置信度，输出 token 免费 结果开发者们已经拿它做出了 19 个开源项目，加起来 6800 多星 挑几个最有意思的 jev-ultrafast，browser-use 出品，2700 星，一句 slogan：i. am. speed. openjev，想在家里一张 3090 上跑出类似 Jev 的东西，925 星 fast-jev-compaction，替换 Claude Code 的上下文压缩，每次工具调用逐条打分，过期的丢，留下的原文保留 typesafe-computer-use，操控 Mac 每一步只要 0.0002 美元 jev-router，在 Claude Code 里按任务自动路由到最便宜的模型 pg-jev，Postgres 扩展，用大白话查表 还有人拿它打超级马里奥、在 MuJoCo 里以 2.5Hz 开无人机 我们在 Agent Skills Hub 把这 19 个放进了一张对比页，星数、语言、协议、质量分一张表看完，每 8 小时按 GitHub 实时数据重算 两个提醒： 1️⃣ 19 个都过了 Hub 的基础规则扫描，但那是规则扫描不是人工审计，装之前还是看一眼代码 2️⃣ 另外有 4 个项目没写开源协议，拿去商用前先确认

Moritz Kremb

@moritzkremb

All of the coolest Jev projects I could find on X today 🧵

小墨同学

@xiaomovps

Jev 发布没几天，开源社区已经开始疯狂复刻了🔥 最值得推荐的五个模型： 1、Laya 421M：原生决策模型，支持 Mac 2、Decider-2B：最像 Jev，基于 Qwen3.5 3、NanoJev 0.6B：专门的 Decision Head 4、Reflex：Qwen3.5 + Direct Logits 5、System-One 4B：专门做概率校准 如果和我一样是苹果的芯片，我推荐： Laya 和 Reflex 下一步我准备选两个在本地运行 然后测试一下和Jev的差距

思维怪怪

@0xLogicrw

Jev 这个 waitlist 还是很给力的，昨天申请，今天就能用上。 给已经拿到 API、但还不知道怎么玩的人整理了一份 Awesome Jev，目前我能确认到的 Jev 项目基本都在这里： 1. jev-ultrafast Browser Use 做的高速浏览器 Agent。Jev 负责每一步判断「做什么、点哪个元素」，需要输入文字时才调用小模型。Google Flights 搜航班完整跑完约 7.1 秒。 https://github.com/browser-use/jev-ultrafast 2. typesafe-mcp 把 Jev 直接接进 Claude Code、Claude Desktop 和 Codex。Agent 可以随时调用 Jev 做 Choice / Score / Noul 这类结构化判断。 https://github.com/itsmostafa/typesafe-mcp 3. jev-mcp 另一个更偏实用工具的 MCP，已经封装好事实核验、Prompt Injection 检测和语义排序。 https://github.com/jkudish/jev-mcp 4. SemDecide 把 Jev 做成 Unix 命令行工具，可以直接拿来做语义判断、分类、打分、过滤和 Guard。很适合塞进脚本、CI 和数据流水线。 https://github.com/sharziki/semdecide 5. Jev Codex Router 先让 Jev 判断每一轮编程任务有多难，再自动决定交给便宜模型还是更强模型。作者用 237 个真实 turn 回放，自测成本降低约 60%。 https://github.com/0xNatoshi/jev-codex-router 6. Winnow 给 Claude Code 做「上下文垃圾回收」。Read、Bash、Grep 输出太长时，先让 Jev 判断哪些内容真的跟当前任务有关，再决定哪些需要进上下文。 https://github.com/GhalebDweikat/winnow 7. Jev Review 用 Jev 做代码审查前置筛选，先判断 correctness、security、reliability、兼容性和测试风险，再把重点问题交给更重的模型处理。 https://github.com/devagrawal09/jev-review 8. Blink 用 Jev 在代码库里做语义寻路。每到一层目录，就判断哪些文件或文件夹最可能和问题有关，再把更多 walker 分配过去。 https://github.com/ellipsis-dev/blink 9. neo4jev 把同样的思路用到知识图谱。Jev 给每条候选边打概率，再用 beam search 一步步找到最可能的路径。 https://github.com/jexp/neo4jev 10. jev-desktop 把 Jev 接到桌面自动化里。它读取 Accessibility Tree，判断该操作哪个控件、执行什么动作，再交给本地执行器。 https://github.com/lahfir/agent-desktop 11. TypeSafe AI Playground 一个专门拿 Jev 做实验的 Rust CLI，已经做了 PHI 检测、代码注释审查、实时语气分析、职业和行业分类等玩法。 https://github.com/markjaquith/typesafe-ai-playground 12. Prism 目前我看到最接近量化/交易场景的项目。它让 Jev 判断流动性池的 toxic flow、市场压力、均值回归可能性和流动性分布方式，目前默认还是 shadow/advisory，不直接驱动交易。 https://github.com/irfndi/prism-liquidity-agent 13. 1v1 Jev 直接做了一个 FPS，让 Jev 大约 9Hz 判断移动、瞄准、ADS、开枪和跳跃。属于最直观展示 Jev 低延迟决策能力的项目之一。 https://github.com/emrickgarrett/OneVOneJev 14. TypeSafe on Neon 拿 Jev 做模型 Router。请求先由 Jev 判断属于哪种任务，再转给 Grok 4.6 或 GPT-6 Astra 等模型执行。 https://github.com/andrelandgraf/typesafe-on-neon 看完这些项目，你大概也知道 Jev 可以怎么玩了，就是拿它反复做「要不要、选哪个、打几分、下一步干什么」。 真正需要生成代码、写文章和复杂推理时，再把任务交给传统大模型。

StudioYebisu

@studio_yebisu

やぁ！兄弟たち！ Jevに関するGitHubの実用性と発展性がありそうなリポジトリをまとめたよ！ やはり、高速判断を要するComputerUseや完全自動トレードなんかに対しての活用が多い印象だね！ Jevは公式のウェイトリストも1日ほどで承認されるけど、待たなくてもVercel AI GatewayからModel: typesafe-ai/jevで直接呼び出せるってさ！ このGrok翻訳っぽい文章はわざわざタイピングしてるゾ！ 1. browser-use/jev-ultrafast Jevがブラウザ自動操作と対象要素を選び、文字入力時のみ小型LLMを使うブラウザエージェント。 https://github.com/browser-use/jev-ultrafast 2. TheoLeeCJ/openjev TypeSafe公式の非公開モデルを再現したものではなく、オープンモデルで同じ入出力パターンを試す独立プロジェクト。ローカルGPUで動かせます。 https://github.com/TheoLeeCJ/openjev 3. vinnylarouge/jevlike 変化するテキスト候補から1つを選ぶJev-likeモデルを、自前データで学習する独立プロジェクト。TypeSafe公式モデルではありません。※使い物にはならないが面白い試み https://github.com/vinnylarouge/jevlike 4. jarrodwatts/jev-trader Monad上のKuru MON-USDCを対象に、Jevで売買判断を行うトレードbot。デフォルトはdry-run/mock動作で、収益性を証明・保証するものではありません。 https://github.com/jarrodwatts/jev-trader 5. Anil-matcha/awesome-jev-by-typesafe TypeSafe Jevの使い方、パターン、プロンプト、スターターコード、事例などを集めたコミュニティのまとめ。 https://github.com/Anil-matcha/awesome-jev-by-typesafe 6. awlevin/typesafe-computer-use 画面をOCRで読み取り、次のクリック操作をTypeSafe/Jevで選ぶMac向けのcomputer-use実装。 https://github.com/awlevin/typesafe-computer-use 7. devagrawal09/jev-review Git diffやコードベースを段階的に検査し、正確性・安全性・信頼性・互換性・テストリスクを構造化して表示するコードレビューworkflow。 https://github.com/devagrawal09/jev-review 8. gargpratyush/jev-router Claude CodeやOpenAI Codexのターンごとに、簡単な作業を速いモデル、難しい作業を強いモデルへ振り分けるルーター。 https://github.com/gargpratyush/jev-router 9. vlad-terin/jev-browser 既存のブラウザ自動操作ツールにJevを組み込み、連続的な観測・操作・検証ループで対象要素を選ぶ非公式runtime/skill。 https://github.com/vlad-terin/jev-browser 10. droidrun/mobile-jev 実機のAndroid端末をJevで操作するモバイルエージェント。ライブ操作デモ、CLI、実行トレースを含みます。 https://github.com/droidrun/mobile-jev