What people are building with Jev

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.

Ross Simmonds

@TheCoolestCool

Jev is freaking ridiculous for SEO 🤯 8 SEO workflows you can put it to work on: 1. Internal links → Finds page pairs that have a real reason to link to each other 2. Cannibalization → Spots pages targeting the same search intent and flags which ones to merge 3. Thin content → Scores pages for originality before they go live 4. Search intent → Tags queries as learn, compare, or buy, and finds pages that don't match 5. Content audits → Sorts every URL into keep, update, merge, or remove 6. Redirect maps → Matches old URLs to the best new ones and flags uncertain matches for review 7. Schema → Checks whether your structured data matches what's actually on the page 8. AI visibility → Checks whether ChatGPT, Claude, and Gemini recommend your brand or your competitors

Paul Vengeons

@VengeonsP

JEV est une révolution pour le SEO Les bonnes décision, en une fraction de seconde, en masse : La rédaction n’est plus le goulot Le goulot, c’est tout ce qu’il faut décider après : - quelle page doit recevoir ce lien - quel mot-clé mérite sa propre URL - quel contenu garder, mettre à jour ou fusionner - quel brouillon doit être relu Le guide pour automatiser les décisions SEO avec Jev AI repose sur 5 étapes : 1/ Transforme chaque décision en choix, score ou oui/non Jev renvoie une réponse et un niveau de confiance 2/ Donne-lui des options fermées Pour le maillage, présélectionne au maximum 255 cibles pertinentes 3/ Groupe les contrôles indépendants Intention, cannibalisation, sources et liens internes peuvent être évalués dans une même passe 4/ Calibre ton seuil sur des cas déjà relus Au-dessus : automatisation En dessous : revue humaine 5/ Garde une validation humaine pour publier, fusionner ou supprimer Un score n’est jamais une autorisation irréversible Sur un test cité dans le guide : - 586 pages analysées - 584 liens placés - 45,1 secondes - 0,21 $ de coût Tu peux appliquer le même principe au tri de mots-clés, aux audits de contenu, à la prospection et au routage entre modèles 1. Follow 2. Like + signet 3. Commente "jev" (guide dispo en français et en anglais)

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

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

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 ↓