Education

Jev: an AI that decides, and never writes

Jev is a new kind of AI model from TypeSafe AI. You give it a situation and a few typed questions, and it hands back answers your code can use directly: yes or no, one option from your list, or a point on your scale, each with a probability. No chat, no essay, no parsing. This guide shows how it works with real answers we recorded, what people build with it, and where it goes wrong.

  • System One
  • Three question types
  • Probability and confidence
  • Composed in code
  • Use cases
  • Honest limits

Every Jev answer below comes from a real call we recorded. Click the messages, drag the sliders, and try it live at the end.

Start here

Two kinds of AI: one talks, one decides

The AI most people know is a chat model (an LLM): it writes text for a person to read. That is perfect for answering an e-mail. It is awkward when a program needs the answer, because the program has to dig the decision out of a paragraph and hope the paragraph looks the same next time.

Jev skips the paragraph. You describe the possible answers up front, and it returns only those, with a probability for each. TypeSafe calls this a System One model, after the fast, intuitive “System 1” thinking in Daniel Kahneman's book Thinking, Fast and Slow: the kind of snap judgment an expert makes in a few seconds.

Same support message, same question: which team should handle it? Press Run both.

A chat model (LLM)
Jev

The chat reply is an illustration we wrote in the typical style of a chat model. The Jev answer and its time are a real recorded call.

Chat model: System 2 style

Writes an answer word by word. Can reason at length, explain itself, write code and letters. Slower and more expensive per decision, and its output is text that software must parse.

Jev: System One

Makes a narrow judgment and stops. Returns typed values and probabilities, so code can branch, sort and route on them. Fast and cheap, but it will not explain itself, reason through many steps or write anything.

Anatomy

One request: a state, some questions, typed answers

Every call has the same shape. The state is what Jev looks at: a message, a document, or a JSON object with several related facts. The questions are what you want to know about it, each with a type and the allowed answers. Back comes one answer per question, under the same name you gave it.

A real request and the real response. Click any highlighted part to see what it does.

Request POST /v1/systemone

                    
Response

                    

The question name is only for your code

Names like refund or team are keys your program uses to find the answer. TypeSafe's docs say the key is not sent to the model, so the whole meaning must be in the question text and the criteria.

The building blocks

Three question types, three kinds of answer

TypeSafe calls them primitives, like the basic types of a programming language. A Noul is a yes/no question. A Choice picks one option from your list. A Score places the state on an ordered scale you describe. Pick a customer message and watch all three answer it.

Pick a message. Every bar is a real recorded answer.

Noul yes or no

Choice pick one

Score a point on a scale

Noul

Returns one number, noul, from 0 to 1: the probability that the answer is yes. Around 0.5 means yes and no are about equally likely, not “medium”. No confidence field. Several labels can apply at once? Ask one Noul per label.

Choice

You define up to 255 options, each with a short description. Returns the winning choice, a probabilities map that sums to 1, and a confidence. It is relative: it always picks the best of what you offered, so offer a “none of these” option when nothing may fit.

Score

You describe 2 to 10 ordered levels. Returns the probability of each level and a score: the probability-weighted average position, so 1.57 means “between level 1 and 2, closer to 2”. Good for ranking. Not a ruler: do not read exact quantities out of it.

Knowing when not to act

Probability, confidence, and the three lanes

A Choice or Score answer comes with a full probability distribution. Confidence squeezes its shape into one number: everything on one option gives 1, and the flatter the spread, the lower it goes (for a Choice, an even spread gives 0). That lets the model say “I'm not sure about this one”, and lets your code do something different when it does.

Drag a bar, or load a real answer. The other bars adjust so the total stays 100%.

Confidence 0.00

TypeSafe's docs approximate a Choice's confidence as (n × top probability − 1) / (n − 1) for n options. We checked it against all 36 Choice answers we recorded: 35 match to within 0.01, which is the API's two-decimal rounding, and the English “Bad fit” ticket is 0.013 off (0.45 by the formula, 0.44 from the API). So it is a close approximation, not the exact definition. A Score's confidence also measures concentration, with its own formula.

Confidence-gated routing: 14 real tickets

A common pattern from TypeSafe's docs: act automatically when confidence is high, ask for a check in the middle, hand it to a person when it is low. Move the two thresholds and watch the tickets change lanes.

0.90
0.50
Automatic 0
Check first 0
A person decides 0

Confidence is not correctness

Look for the “thanks, the new dashboard is great” ticket. No team fits a thank-you, but a Choice must pick one of the options it is given, so Jev sent it to technical, in the English version even with a fairly high confidence (0.83). The fix is not a threshold. It is a better question: we added a fifth option for messages that need no action and asked again.

Speculative fan-out

Ask many questions in one call

Jev reads the state once and answers every question in parallel and in isolation: no question sees another one's answer, so adding questions barely changes the response time. That makes it cheap to ask speculative questions you may not need, and let your code use only the answers that matter.

A second-hand marketplace listing and eight checks. Send them as one call, or as eight.

Measured on our server: the median of three runs of each. The eight separate calls were sent one after another, so their times add up. Sent all at once they would finish sooner, but they would still send the listing eight times and cost the same tokens. The replay runs at the real speed.

TypeSafe measured the same effect

In TypeSafe's parallel-questions cookbook, 13 questions about a Wikipedia article on the GDPR came back 12.2 times cheaper and 10 times faster as one call than as 13 calls, with the same answers.

Code stays in control

Small judgments, combined by your code

Do not ask “is this a good startup idea?”. That hides several judgments in one question. Ask one narrow question per factor, then combine the answers with a formula you own. When your priorities change, you change a number in code instead of rewriting a prompt, and nothing needs to be asked again.

Five startup ideas, three Score questions each, asked once. Now weigh them yourself.

    Each idea's score on a factor is Jev's Score answer (0 to 3) scaled to 0 to 100%. The ranking is a weighted average computed in your browser; no new model call happens when you move a slider.

    What people build

    Use cases: anywhere code needs a judgment

    A good fit is a decision a knowledgeable person could make in a few seconds, that you need made many times, by a program. Filter by area; each card shows which question types do the work.

    We use it too: AI Classifier

    Our free AI Classifier puts Jev behind a simple form and a public API: paste any text, ask up to eight questions, get every answer with a percentage.

    Jagged edges

    Where Jev goes wrong

    TypeSafe publishes a list of known weak spots for each version. For jev-1.13 the short version is: let code do what code can do exactly, and ask Jev only for the judgment in between.

    We tested four of them

    Each question was asked three times with the same input. Jaggedness means exactly this: some of these it gets right and one it gets wrong, and you cannot tell in advance which.

    Numbers from different questions do not add up

    Two recorded experiments. Each answer makes sense on its own, but you cannot do arithmetic across questions.

    Quiz: code, Jev, or a chat model?

    For each task, pick the tool that should do it.

    Under the hood

    How it is trained, what it costs, how fast it is

    Chat models are tuned with RLHF (reinforcement learning from human feedback) to write answers people like. Reasoning models add RLVR (rewards you can verify, such as a correct maths result). TypeSafe trains Jev with what it calls RLCD, reinforcement learning for calibrated decisions: no text at all, just decisions whose probabilities should match how often they turn out right.

    RLHF

    Human feedback. Made chatbots such as ChatGPT pleasant to talk to. Rewards answers people prefer, which can also reward confident-sounding mistakes.

    RLVR

    Verifiable rewards. Produced reasoning models that are strong at maths and code, but slower and more expensive per answer.

    RLCD

    Calibrated decisions. TypeSafe's approach for Jev: return decisions and probabilities instead of text, and make the probabilities honest.

    What “calibrated” means

    If a well-calibrated model says 0.8 for a hundred different answers, about 80 of them should turn out right. It is a promise about groups of answers, never about one. Calibration is TypeSafe's claim; check it on your own data.

    0.80

    An illustration of the idea, not measured data.

    The spec sheet

    Modeljev-latest points to jev-1.13.0 today. Pin the versioned name if you tune thresholds.
    Price$0.042 per million input tokens. Output tokens are free. Prepaid credits.
    Context64k tokens per request in total; the state plus the single longest question must fit in 32k.
    Rate limits1,200 requests per minute and 250,000 tokens per second, which TypeSafe says are adjusting while demand grows.
    InputText only: a string, a JSON object or an array. No images, audio or video yet.
    LanguagesEnglish is the primary training language. Others work with lower accuracy; test yours.
    CustomisingNo fine-tuning: every account uses the same weights. You shape answers through the state, the question text and the criteria.
    DataProcessed in the USA (TypeSafe's subprocessors: AWS, Modal, Nebius, CoreWeave), no EU region. Not used for training. Zero data retention is for enterprise customers.
    SDKsPython typesafe-sdk, JavaScript @typesafe-ai/sdk, or plain HTTP.

    How fast, really: every call on this page

    Each dot is one real call we made to build this guide, timed from our server in Europe to TypeSafe in the USA, network included.

    What would it cost?

    1,000,000
    457

    457 is a real call from this page: one short support message with three questions.

    Who makes it

    TypeSafe AI, Inc. is a San Francisco company founded in 2024. It came out of stealth in September 2026 with a 40 million dollar seed round led by DCVC. Its CEO, Diogo Almeida, is one of the authors of InstructGPT, and TypeSafe credits him as a co-inventor of RLHF, the training technique behind ChatGPT. Not to be confused with Typesafe Inc., the unrelated Scala company behind Akka that renamed itself Lightbend in 2016.

    Hands on

    Ask Jev yourself

    Write any customer message and ask the same three questions as above, live. This runs through our AI Classifier API, so it shares that tool's free daily allowance.

    0 / 600

    Your text goes to TypeSafe AI in the USA to be classified. We never store it. Privacy policy.

    The same call from your own code

    You need your own key from TypeSafe (console.typesafe.ai). Keep it on your server, never in a web page.

    
                    
    Questions

    Frequently asked

    What is Jev?

    Jev is the flagship model of TypeSafe AI, a San Francisco company. It is what TypeSafe calls a System One model: you send it a state (a text, a JSON object or an array) and typed questions about it, and it returns a typed answer with probabilities for each question. It never writes text.

    How is Jev different from ChatGPT or another LLM?

    A chat model generates text for a person to read, so software has to parse its reply. Jev returns only the answer types you define: a probability of yes, one option from your list, or a position on your ordered scale. That makes it fast and cheap and easy to use from code, but it cannot write a reply, a summary or code.

    What are Noul, Choice and Score?

    They are Jev's three question types. A Noul is a yes or no question and returns the probability that the answer is yes. A Choice picks one option from a set you define and returns a probability for every option plus a confidence. A Score rates the state on ordered levels you describe and returns the probability-weighted position on that scale, the probability of each level and a confidence.

    What is the difference between probability and confidence?

    Probabilities say how likely each option or level is. Confidence is one number from 0 to 1 that summarises how concentrated those probabilities are: all of it on one option gives 1, and the more evenly it spreads, the lower it gets (for a Choice, an even spread gives 0). Choice and Score answers carry a confidence; a Noul answer is a single probability and has none. High confidence is not proof that an answer is right.

    How fast and how expensive is Jev?

    TypeSafe lists the price as 0.042 US dollars per million input tokens, with output tokens free. In our own measurements every call, network included, took between 0.23 and 0.42 seconds from a server in Europe. Asking many questions in one call is much cheaper than one call per question because the state is sent only once.

    Does Jev understand Czech and other languages?

    English is Jev's primary training language and where TypeSafe says accuracy is best. Other languages are accepted with lower accuracy. The Czech examples on this page were answered sensibly, but they are a handful of texts, not a measurement, so test your own data before relying on it.

    What is Jev bad at?

    By TypeSafe's own list for version 1.13: reading questions too literally, arithmetic and counting, comparing dates, questions with several levels of indirection, very large states full of irrelevant detail, text written to trick the model, contradictory instructions and criteria, expecting separate answers to add up, and generating text. Keep calculations, date logic and exact lookups in code and ask Jev only for the judgment.

    Where is my data processed?

    TypeSafe runs Jev in the USA (the subprocessors it lists, AWS, Modal, Nebius and CoreWeave, are all US-based) and has no EU region. It says it does not train on customer requests, and zero data retention is offered to enterprise customers. The recorded examples on this page are invented texts. The live demo sends your text through our AI Classifier to TypeSafe and we do not store it.

    In one breath

    The whole thing, recapped

    1. Jev decides, it does not write. A state and typed questions go in; typed answers with probabilities come out.
    2. Three question types: Noul (probability of yes), Choice (one of your options), Score (a point on your ordered scale).
    3. Confidence says how concentrated the probabilities are. Use it to choose between acting, checking and asking a person.
    4. Batch your questions. One call with many questions sends the state once: far cheaper and faster than many calls.
    5. Keep code in control. Ask narrow questions and combine them with formulas and hard rules you own.
    6. Mind the jagged edges. Maths, counting and dates belong in code; always offer a “none of these” option; test on your own data.