{"slug": "jev-the-ai-model-that-doesnt-write-it-decides", "title": "Jev: The AI Model That Doesn’t Write — It Decides", "summary": "TypeSafe AI launched Jev in September 2026, a \"System One\" model that returns typed decisions, probabilities and confidence scores as JSON instead of generating text, targeting software decision tasks rather than open-ended writing. TypeSafe AI, founded by Diogo Almeida, who co-invented RLHF, reports roughly 70–500 ms response times and says Jev can be 20–200× faster than frontier LLMs on System-One-shaped tasks, using parallel sampling to evaluate requested decisions together; pricing is based on input tokens with output tokens free. Jev accepts state plus three question types — Noul, Choice and Score — through the typesafe_sdk Python client, returning answers such as a billing department choice with 0.91 confidence.", "body_md": "We have spent years teaching AI models to **write**.\n\nBut software often needs something much simpler:\n\n***“Given this information, what should I do next?”***\n\nThat is the problem TypeSafe AI is targeting with **Jev**, its first **System One** model.\n\nJev is not designed to generate paragraphs. It takes a piece of state/context plus structured questions, and returns **typed decisions, probabilities, and confidence information** that software can use directly.\n\nJev is an AI model from **TypeSafe AI**, a startup founded by Diogo Almeida, who co-invented RLHF, the training technique behind ChatGPT. It launched in September 2026.\n\nThe easiest way to picture it:\n\nThink of an LLM as a **writer**.\n\nThink of Jev as a **decision engine**.\n\n```\nLLM────────────────────────────────────Context → Generate tokens → Text → Parse / validate → Software logic                                        Jev────────────────────────────────────Context + Questions → Structured decisions → Software logic\n```\n\nFor example, suppose a customer sends:\n\n*“I was charged twice for the same transaction.”*\n\nAn LLM might generate:\n\n*“This appears to be a duplicate transaction. You should investigate…”*\n\nJev can instead answer something like:\n\n```\n{ \"department\": { \"choice\": \"billing\", \"confidence\": 0.91 } }\n```\n\nYou hand Jev some information and a few questions. It hands back structured answers (JSON) that your software can use directly, with a confidence score on each.\n\nBecause generating text is expensive when all you wanted was a decision. LLMs normally generate tokens **one after another**:\n\n```\nToken 1 → Token 2 → Token 3 → Token 4 → ...\n```\n\nJev says it uses **parallel sampling**, allowing the requested decisions to be evaluated together rather than generating a long sequence of output tokens. TypeSafe reports roughly **70–500 ms** response times and says Jev can be **20–200× faster** than frontier LLMs on System-One-shaped tasks.\n\nTypeSafe also lists pricing based on input tokens, with **output tokens free**.\n\nSo the idea is not:\n\n*“Build a smarter chatbot.”*\n\nIt is:\n\n***“Build a cheaper and faster AI component for software decisions.”***\n\nPsychologist Daniel Kahneman described two modes of thinking. System 1 is fast and intuitive, like recognizing an angry face. System 2 is slow and deliberate, like solving a puzzle. LLMs are System 2 machines. Jev is built for System 1.\n\nA rough analogy:\n\n```\nSYSTEM 1                         SYSTEM 2────────────                     ─────────────Fast                             SlowIntuitive                        DeliberateQuick judgment                   Planning / reasoning\"This ticket is about billing.\"  \"How should I solve this                                   complicated problem?\"\n```\n\nTypeSafe uses “System One” to describe models focused on **fast, structured judgments**, rather than open-ended generation.\n\nImportantly, this analogy is about the **type of task**, not a claim that Jev literally thinks like a human brain.\n\nJev only understands three kinds of questions:\n\nHere’s what a support-ticket check looks like. The input is: *“My payouts have been failing for 3 days.”*\n\n```\nSTATE                      QUESTIONS  \"My payouts have       +   is_urgent   → Noul   been failing           +   department  → Choice   for 3 days\"            +   frustration → Score          \\                       /           └──────► [  JEV  ] ◄──┘                        │                        ▼              one structured answer\n```\n\nHere is how you ask those three questions in code:\n\n``` python\nfrom typesafe_sdk import Choice, Noul, Score, TypeSafeClientstate = {\"ticket\": \"My payouts have been failing for 3 days.\"}with TypeSafeClient() as client:   # reads TYPESAFE_API_KEY    response = client.system_one(        state=state,        questions={            \"is_urgent\": Noul(                instructions=\"Does the ticket communicate time pressure?\"            ),            \"department\": Choice(                instructions=\"Which team should handle this ticket?\",                criteria={                    \"billing\":   \"Payments, charges, refunds, payouts.\",                    \"technical\": \"Bugs, errors, integrations.\",                    \"account\":   \"Login, profile, settings.\",                },            ),            \"frustration\": Score(                instructions=\"How frustrated does the customer seem?\",                criteria=[                    \"Calm and neutral\",                    \"Frustrated\",                    \"Very angry or using strong language\",                ],            ),        },    )\n```\n\n*Notice that you define the options. Jev can only pick from them. Its answer comes back as:*\n\n```\n{  \"is_urgent\":   { \"noul\": 0.95 },  \"department\":  { \"choice\": \"billing\", \"confidence\": 0.80 },  \"frustration\": { \"score\": 1.04, \"confidence\": 0.94 }}\n```\n\nOne call answers three questions. Instead of making three separate LLM calls, you ask Jev all of them at once. TypeSafe says the questions are evaluated **in parallel and independently** against the same state, so adding more questions barely slows down the response.\n\nBecause every answer carries a confidence score, you can write ordinary code around it. TypeSafe’s docs suggest a pattern like this:\n\n```\nif confidence > 0.9:    auto_act()            # trust itelif confidence > 0.5:    flag_for_review()     # double-checkelse:    send_to_human()       # don't guess\nSpeed     →  20–200x faster than frontier LLMsCost      →  40–400x cheaperPrice     →  $0.042 per million input tokensOutput    →  freeLatency   →  70–500 msContext   →  32K tokens\n```\n\nJev’s answers are locked into a fixed format, so it can’t ramble, invent a fake field, or break your JSON.\n\nIf your application gives it three choices:\n\n```\nA = BillingB = TechnicalC = Account\n```\n\nit cannot suddenly invent:\n\n```\nD = Please contact our support team...\n```\n\nThe output shape is defined beforehand.\n\nBut that does **not** mean Jev can never be wrong.\n\nIt can still choose the *wrong option*, misunderstand a question, or be poorly calibrated. That’s why the confidence score matters. Jev is trained with a method called **RLCD** (Reinforcement Learning for Calibrated Decisions), which punishes confident wrong answers more than uncertain ones. So the safer statement is:\n\n***Jev removes free-form output hallucination and type errors; it does not remove incorrect judgments.***\n\nJev is meant to sit *beside* LLMs, not replace them:\n\nA typical setup looks like this:\n\n```\n                    USER                      │                      ↓                 Your Agent                      │          ┌───────────┴───────────┐          ↓                       ↓        JEV                      LLM   Fast decisions            Deep reasoning   Routing                    Writing   Classification             Planning   Scoring                    Explanations   Guardrails                  Code generation          │                       │          └───────────┬───────────┘                      ↓                 Your Software\n```\n\nFor example:\n\n**Jev decides** which tool or model should be called.\n\n**LLM decides** how to solve a complex problem.\n\n**Code decides** what actions are actually allowed.\n\nThat hybrid architecture is probably more realistic than “*Jev will replace LLMs.*” TypeSafe itself presents Jev as an automation-oriented component that can work alongside more general generative models.\n\nNobody outside TypeSafe knows yet. The architecture isn’t public. What’s known is that it uses a new training method (RLCD) and a parallel sampler that answers all questions at once instead of word by word. The name comes from the **Jevons paradox**: when something gets much cheaper, people use far more of it.\n\nProbably not **instead of** LLMs.\n\nMore likely, **alongside** them.\n\nWe may be moving toward systems where different models have different jobs:\n\n```\n            AI SYSTEM                 │     ┌───────────┴───────────┐     ↓                       ↓ System One               System Two   (Jev)                    (LLM)     │                       │ Decide quickly          Reason deeply     │                       │     └───────────┬───────────┘                 ↓             SOFTWARE\n```\n\nLLMs are extremely powerful because they can generate almost anything.\n\nJev gives up that flexibility to gain **speed, structure, and decision-oriented outputs**.\n\nIf LLMs are the brain that thinks and writes, Jev is the **reflex**. It’s fast, cheap, and structured. The best AI systems will probably use both.\n\nAnd that may be the real idea behind System One models:\n\n***Not every AI problem needs a model that writes.\nSometimes software just needs a model that decides.***\n\n[Jev: The AI Model That Doesn’t Write — It Decides](https://pub.towardsai.net/jev-the-ai-model-that-doesnt-write-it-decides-6f3d91a78c3a) was originally published in [Towards AI](https://pub.towardsai.net) on Medium, where people are continuing the conversation by highlighting and responding to this story.", "url": "https://wpnews.pro/news/jev-the-ai-model-that-doesnt-write-it-decides", "canonical_source": "https://pub.towardsai.net/jev-the-ai-model-that-doesnt-write-it-decides-6f3d91a78c3a?source=rss----98111c9905da---4", "published_at": "2026-10-28 05:07:26+00:00", "updated_at": "2026-10-28 05:20:07.685156+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-products", "ai-tools", "large-language-models", "ai-agents"], "entities": ["TypeSafe AI", "Jev", "Diogo Almeida", "RLHF", "ChatGPT", "Daniel Kahneman", "typesafe_sdk"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/jev-the-ai-model-that-doesnt-write-it-decides", "markdown": "https://wpnews.pro/news/jev-the-ai-model-that-doesnt-write-it-decides.md", "text": "https://wpnews.pro/news/jev-the-ai-model-that-doesnt-write-it-decides.txt", "jsonld": "https://wpnews.pro/news/jev-the-ai-model-that-doesnt-write-it-decides.jsonld"}}