{"slug": "jev-101-a-new-class-of-model", "title": "Jev 101 – A new class of model", "summary": "Typesafe AI released Jev, a discriminative \"System 1\" model that takes a State JSON object and typed Questions and returns calibrated probability distributions for choice, score, and true/false outputs in a single pass rather than generating tokens. The model is priced at $0.042 per million input tokens with free output and is positioned for fast, cheap decision-making in production pipelines, in contrast to slower System 2 LLMs such as Claude Opus 5.5 at $4 per million input tokens and $20 per million output tokens.", "body_md": "In this post, we take a look at Jev, a new “System 1” type of model optimized for extremely fast and cheap decision making with calibrated JSON outputs. In a future post, we will compare it with Claude Opus 5.5 and decide when to use one or the other.\n\nIf you want to learn more about Jev, consider signing up to my Maven cohort, “[Jev vs Claude: Find the Cheapest Model That Meets Your Quality Bar](https://maven.com/bruno-goncalves/jev-vs-claude-a-measured-guide)” taking place on November 18\n\nMeanwhile, we hope you enjoy this post, so\n\nand\n\nto help us grow.\n\nIn his ground breaking 2011 book, “[Thinking Fast and Slow](https://link.amazon/B09Q0rXpx)”, Daniel  Kahneman introduced the idea that your brain has two different modes of thinking, what he called **System 1** and **System 2**. System 1 is the auto-pilot: fast, automatic, *instinctive*, and effortless. It runs continuously in the background and makes judgement calls: he looks angry, the road is blocked, this sounds off, etc. \n\nSystem 2 is the opposite. Slow, deliberate, thoughtful, *rational*. It follows the rules, makes calculations, explains itself, and pays attention. Unfortunately, attention is limited and System 2 is lazy so it often follow the lead of System 1. \n\nThe current generation of LLMs, like Claude, ChatGPT, Gemini, Grok, etc fall cleanly into the System 2 category. They work through the prompt systematically to figure out what to output. They excel at producing long form text, work through complex problems, translate across multiple languages, etc. They fall neatly into the System 2 category.\n\nDespite these strengths, many of the pipelines that leverage LLMs in production revolve around quick decision making. Which team should handle this ticket? Is this summary correct? What tool should be called? System 1 type problems.\n\nA few weeks ago, on September 15, 2026, Typesafe AI released [Jev, the first System 1 AI model](https://typesafe.ai/blog/introducing-system-one-models-and-jev). Jev is a [discriminative model](https://en.wikipedia.org/wiki/Discriminative_model) (not a generative one) that specializes at producing quick, accurate, structured answers. Instead of a prompt, it processes a *State* and a set of *Questions* and it produces a probability distribution over the different possible answers for each question. It’s incapable of stringing two words together but it can make decisions quickly and cheaply. It costs $0.042 per million input tokens, output is *Free*, and generated in a [fraction of a second](https://www.tomshardware.com/tech-industry/artificial-intelligence/typesafe-ais-jev-offers-an-alternative-to-llms-that-claims-to-be-193x-faster-and-445x-cheaper-system-one-type-model-is-bespoke-for-probabilistic-decision-making).\n\nClaude [Opus 5.5](https://platform.claude.com/docs/en/models/opus-5-5/overview) was released a week later, it costs $4 per million input tokens, a million output tokens will set you back $20, and there’s no way to disable thinking. System 2 all through and through. \n\nBoth types of model are just an API call away, so the question becomes when should you use one over the other? This post covers how to use Jev and the next one will compare Jev and Claude head to head. Stay tuned!\n\nUnlike LLMs that generate the output token by token, Jev generates the entire output in one go. You call Jev with a **State** JSON object (alternatively, a string or array are also allowed) and set of typed **Questions**. Jev then scores every answer to every question in parallel. There are three types of questions with three different specialized kinds of outputs:\n\n- **Choice** - Returns a probability for each option (up to 255) and choose the best one.\n- **Score** - Places the state on an ordered scale of 2 to 10 levels.\n- **Noul** - Returns the probability that a statement is*True* .\n\nJev is trained using [Reinforcement Learning for Calibrated Decisions](https://www.sanity.io/glossary/rlcd-reinforcement-learning-for-calibrated-decisions), which, according to Typesafe, guarantees that the output probabilities are properly calibrated: in aggregate, Jev is (supposedly) right 80% of the time is says that the probability is 0.8. \n\nThe offical Jev sdk is [typesafe_sdk](https://docs.typesafe.ai/sdk/python) and is pretty straightforward to use. Instantiating a `TypeSafeClient` class with the API key produces a object with the `system_one()` method that is the main way to interact with Jev. \n\n``` python\nimport os\nfrom typesafe_sdk import TypeSafeClient, Noul\n\nclient = TypeSafeClient(api_key=os.environ[\"TYPESAFE_API_KEY\"])\n\nr = client.system_one(\n    model=\"jev-latest\",\n    state=\"Hi, I was charged twice for the same order. Can I get my money back?\",\n    questions={\"refund\": Noul(instructions=\"Is the customer asking for money back?\")},\n)\n\nprint(r.answers[\"refund\"].noul)          # probability of \"yes\", e.g. 0.98\nprint(r.model, r.usage.input_tokens)     # e.g. jev-1.14.0 305\n```\n\nThe three required arguments are the `model` version we wish to use, the `state` and the set of `questions` for which we would like an answer. Questions are provided as a dictionary where each value is an instance of a `Noul`, `Choice`, or `Score` object.  Each question type is used slightly differently and returns a different set of values. The answer to each question can be found in the `answers` dictionary of the `SystemOneResponse` object returned by  `system_one()` . \n\n# Noul: one probability\n\nQuestions of type `Noul`, cleverly named after [Ber-](https://en.wikipedia.org/wiki/Bernoulli_trial)[noul-](https://en.wikipedia.org/wiki/Bernoulli_trial)[li trials](https://en.wikipedia.org/wiki/Bernoulli_trial), produce a single probability value that quantifies the likelihood of the answer to the question being `True`.\n\n```\nquery = (”Hello- It is urgent I get a refund on this product. The merchant has not been “\n         “helpful, what can I do now to get this resolved ASAP?”)\n\nr = client.system_one(\n    state=query,\n    questions={”refund”: Noul(instructions=”Is the customer asking for money back?”)},\n    model=”jev-latest”,    # pin “jev-1.14” once you tune thresholds\n)\n\nr.answers[”refund”].noul   # 0.98\nr.usage.input_tokens       # 305, for $0.0000128\nr.model                    # ‘jev-1.14.0’\n```\n\nWhen the boundary between the two possible outputs, `True` or `False` is not clear, we can supply the model with further information using the `criteria` argument:\n\n```\nNoul(\n    instructions=”Is the customer asking for money back?”,\n    criteria={”true”: “The customer wants a refund, credit, or reversal”,\n              “false”: “The customer wants information, or a fix to something broken”},\n)\n```\n\nUnlike classic LLMs, there are no other paramters to set: no temperature, system prompt, few-shot examples, etc.\n\n# Choice: a distribution across a list of possiblities\n\nWhen you have more than just two possible answers to your question, you can use the `Choise` question type where you can specify arbitrary classes along with the criteria used to decide how to choose among them. Each class is identified by a unique dictionary key both for the sake of establishing the decision criteria as for identifying which probability corresponds to each group.\n\n```\nGROUPS = {\n    “cards”: “Anything about a physical or virtual card: ordering, delivery, activation, loss, or a card being declined”,\n    “transfers”: “Sending or receiving money, including transfers that failed or have not arrived”,\n    “fees_and_refunds”: “Charges, fees, exchange rates, refunds, and reversals”,\n    “account”: “Identity, verification, personal details, app access, and closing the account”,\n}\n\nr = client.system_one(state=query, questions={\n    “group”: Choice(instructions=”Which team should handle this query?”, criteria=GROUPS)})\n```\n\nEach call to Jev comes with a confidence value. Confidence is a measure of how split Jev is across all the options it has, based on the probabilities is computed. In the case of a `Choice` question, the confidence is:\n\nso it just measures how far away the highest probability is form an even split across all options. For a `Score` question, the calculation is [slightly more complex](https://docs.typesafe.ai/confidence) as it needs to take into account how far from the next level a value sits, but the meaning is the same: how sure is Jev that this is the correct answer.\n\nIn addition to the confidence level, you can also inspect the full set of probabilities so that you can tell not only what the model chose, but also if there were any runner-ups, etc.\n\n```\n{\"type\": \"choice\",\n \"choice\":\"cards\",\n \"confidence\":1.0,\n \"probabilities\":{\n     \"cards\":1.0,\n     \"transfers\":0.0,\n     \"fees_and_refunds\":0.0,\n     \"account\":0.0\n  }\n}\n```\n\nIf you squint a bit, you might think that a Choice with two options `True` and `False` is just the same as a `Noul` and you wouldn’t be *too* far off… however, Typesafe [strongly recommends](https://docs.typesafe.ai/confidence) sticking with `Noul` for binary choices and `Choice` for multinomials.\n\n# Score: a ranking\n\nIf instead of a choice among different unsorted options you must select a position in a ranking, then you should use a `Score`. Here the levels are taken to be in the order they appear in the criteria list and identified by the corresponding index.\n\n```\nURGENCY = [\n    “No deadline. A routine question.”,\n    “The customer wants a fix soon. Nothing is blocked.”,\n    “The customer names a deadline or is blocked right now.”,\n]\n\nr = client.system_one(state=query, questions={\n    “urgency”: Score(instructions=”How urgent is this query?”, criteria=URGENCY)}\n)\n```\n\nThe final `score` output by the model is identified by a float which corresponds to the weighted average of the various levels. To obtain the corresponding level you can round to the nearest integer. A `confidence` value and the `probabilities` assigned to each level is also returned as before. \n\n# Many questions, one call\n\nJev’s unique structure means that we must reason about it in a different way. Output tokens are free, so ideally you want to get as much output per call as possible. Jev is also intrinsically parallel with the entirety of the processing happening in a single pass. The combination of these two features is a large part of what makes Jev so powerful:\n\nYou can ask multiple questions about the same state in a single call!\n\nIf you provide a `questions` dictionary with multiple keys when you call `system_one()` Jev will provide the answer to all of them at the same time. \n\nOne important detail to keep in mind: all questions are processed in parallel, so questions must be independent. There is no way to establish dependencies between one question and another within a single call. There is also only one `State` object per call, so all questions have to refer to the same `State`.\n\n```\nquestions = {\n    “group”: Choice(instructions=”Which team should handle this query?”, criteria=GROUPS),\n    “urgency”: Score(instructions=”How urgent is this query?”, criteria=URGENCY),\n    “refund”: Noul(instructions=”Is the customer asking for money back?”),\n}\n\nr = client.system_one(state=query, questions=questions)\n```\n\nThis single call costs 501 input tokens, or about $0.000021. Splitting it into three calls, costs 1081 input tokens (about $0.000045) and 3x the time.\n\nOutput really is free. The price of a Jev call is set by the size of your state and your question definitions, not by the answer.\n\n# Threshold on sureness, not on the label\n\nWhen it comes to automatic decision making based on Jev’s outputs, Typesafe recommends splitting the probabilities into three bands. If it is high enough, you can act automatically, for intermediate levels, ask for confirmation or provide further information and ask again. Otherwise, refer to a human or another system.\n\nA 0.05 probability is just as informative as a 0.95 one, so we take the `max(p, 1-p)` and threshold on the result\n\n``` python\nBANDS = [(0.9, “auto”), (0.7, “confirm”), (0.0, “human”)]\n\ndef band(p):\n    sureness = max(p, 1 - p)\n    return next(label for cut, label in BANDS if sureness >= cut)\n```\n\n# What Jev cannot do\n\nJev is a fundamentally different class of model and not much is publicly known about its internal architecture. However, the public interface provides important information about its strengths and limitations.\n\nJev can only produce structured JSON output with specific schemas, so tasks such as summarization, explanations, etc are beyond its reach. You must always provide the complete list of options (up to 255 options for `Choice` and 2 to 10 levels for `Score`), so there’s no way to extract a list of items. It has no support for images or PDF documents and each questions must be independent. No chains of steps, arithmetic or lookups are allowed and it has no support for tool use.\n\nIt’s also important to keep a few best practices in mind. `jev-latest` is an alias that can be changed by Typesafe at any time. Pin the model version so a silent version bump doesn’t break the thresholds you tuned. You should also store `response.model` next to every answer you keep so that you have full reproducibility. \n\nIf you enjoyed this post, consider subscribing and sharing it with a colleague who needs to make reliable, affordable decisions at scale. Let me know in the comments your thoughts on Jev and how best to use it. The complete, runnable notebook is available in the series GitHub repository.\n\nDon’t forget to\n\nthis post with others who might be interested, and encourage them to\n\nso that they have access to the entire backlog of posts and be the first to know when a new a new article is posted.", "url": "https://wpnews.pro/news/jev-101-a-new-class-of-model", "canonical_source": "https://data4sci.substack.com/p/jev-101", "published_at": "2026-11-03 11:41:12+00:00", "updated_at": "2026-11-03 11:51:22.868444+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "ai-products", "ai-tools", "ai-infrastructure"], "entities": ["Typesafe AI", "Jev", "Claude Opus 5.5", "Anthropic", "Daniel Kahneman"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/jev-101-a-new-class-of-model", "markdown": "https://wpnews.pro/news/jev-101-a-new-class-of-model.md", "text": "https://wpnews.pro/news/jev-101-a-new-class-of-model.txt", "jsonld": "https://wpnews.pro/news/jev-101-a-new-class-of-model.jsonld"}}