Jev - The Ultimate Classification Model?

The reasoning detour, and what it skipped

For two years, roughly every frontier lab has pushed in one direction: reasoning. To get that reasoning they leaned on longer chains of thought and larger thinking budgets, so the strongest models will happily think for minutes before answering, and most labs will not even show you the chain of thought you paid for.

Sam frames this through Daniel Kahneman's Thinking Fast and Slow. Reasoning is System 2: slow, deliberate, effortful. System 1 is the fast, intuitive gut call you make without deliberation. His point is that most decisions sitting inside software are System 1, not System 2: often just simple classification. What kind of support ticket is this, is this message urgent, did an agent's output break a rule. You should not need 30 seconds for that, let alone minutes.

The trap is that using a reasoning model to answer these still makes you pay for all the thinking. You can ask one of these models for a one-word label wrapped in JSON, but you pay a huge latency cost to generate a pile of text before that single label comes back.

Jev, and the lab that built it

This week a lab that has just come out of stealth went the opposite way. It built a model you cannot chat with, let alone have it deliberate. It is non-autoregressive: it does not generate text one token after another in the standard way. The tell is that its output tokens are free, and working out why they are free says a lot about how it is built. The company is TypeSafe AI and the model is Jev.

The founder is Diogo Almeida, who spent years at OpenAI and was one of the top authors on the InstructGPT paper, the work that taught a base language model to follow instructions and led to ChatGPT. His driving question for four years: as models became superhuman at chat, where is all the automation? His answer is that chat is the wrong interface for software. Software does not want a paragraph. It wants a value it can use straight away.

The three building blocks

Jev is what TypeSafe calls a system one model, and the cleanest way to picture it is a function call. You pass in two things: a state, which is your unstructured text or data (a support ticket, an agent trace, a log file), and a set of typed questions.

There are only three kinds of questions. Choice gives it a list of options and it picks one. Score rates something on a scale you define. Noul is a yes or no question that comes back as the probability the answer is yes. Nothing here is text you have to parse: for a Choice question you get the option it picked plus a probability for every option.

That last part matters. A lot of us have been faking this with JSON, asking a model to answer and return a number, but that number is just generated text. Look at LLM as a judge and you often see the text skew a certain way: the model writes the characters "0.9" rather than expressing a real probability. Jev returns the probability directly.

The intended mental model is a smart if statement. You do not ask one big fuzzy question like "rate this startup pitch." You ask small gut questions (what is the feasibility, what market are they after), then combine the answers in ordinary code. When something changes, you change a number in your code instead of tweaking a prompt.

The demo app: Choice, Score, and Noul

Sam built a small demo app and calls Jev on OpenRouter using the OpenAI API endpoints. The pricing is unusual: about 4.2 cents (that is $0.042) per million input tokens, and zero for output.

For Choice he classifies language. He gives it a choice of five classes and the text "Bonjour, comment allez-vous?", and it returns French at 1.00 confidence with a probability bar for every option, in about 623 milliseconds. It handles Thai just as easily, including a Romanized version.

For Score he does sentiment. He asks it to give a score between zero and two on the review "The food was delicious, but the service was painfully slow," and it returns 1.00 out of 2 (Mixed). Nudge the text more positive and the number moves. It is a stochastic process, so each ping is slightly different but stays in the same ballpark, and each call costs a fraction of a cent.

Noul returns the probability of a yes/no answer, flattened between zero and one like a sigmoid. "Is this text asking a question?" comes back high even when the question mark is missing, so it is not just pattern-matching punctuation. "Can you help me find my cat?" is 90% yes, and the longer and more specific the input, the more confident it gets; two-word inputs make it lose confidence.

Putting them together: four practical demos

The practical demos combine several judgments in one call. Given a support message, Jev works out which team to route it to. An obvious billing-or-sales message gets a confident answer; an ambiguous one like "Something is wrong with my account. Can someone help?" comes back Unclear rather than guessing, while still leaning technical.

The demo runs multiple things at the same time on the same input: a Noul for whether a refund was requested, plus a time sensitive judgment. Add "right now" to the message and the time-sensitive probability jumps from single digits toward 60 to 70%. It also holds up against attempts to trick it: prompt injection attempts and sarcasm are handled reasonably well, which is unusual for this kind of task.

Other tasks work well too. Code reviews, where it judges whether a pattern is safe or unsafe, catch things like SQL injection. It does PII detection, flagging personal identifiable information, and spam detection.

The fourth demo is agent tool selection, a little like the Cactus model looked at a while ago. The key caveat: Jev only tells you which tool to use. It is not extracting the arguments to pass to that tool, so a separate function-calling model still has to generate the actual inputs.

Stringing actions together

The demo Sam found most interesting chains many classifications in a row. He runs 20 different tasks over one item (set priority, check inventory, choose a warehouse, add cushioning, and so on), each returning a decision with its own latency and confidence, and it flies through all of them. Done sequentially like that, and some could be parallel, the whole run of stringing 20 tasks together costs just over one twentieth of one cent. This is where he sees the real value: chaining lots of quick classifications to get a useful result fast.

How it works

TypeSafe does not tell us muchno paper, no architecture diagram. They disclose three pieces. There is a new model architecture, a parallel sampler, and the most interesting one, a training method they call RLCD, reinforcement learning for calibrated decisions.

They contrast RLCD and its calibrated decisions with the training everyone else uses: RLHF (reinforcement learning from human feedback) and reinforcement learning from verifiable rewards, the GRPO family behind today's reasoning models. Sam's read is that this is probably a transformer that uses the prefill stage to compute its heads and then makes a prediction, a classification or a regression depending on the task. Because nothing is generated token by token, everything comes back in a single pass, which is why answers land in about 70 to 500 milliseconds.

TypeSafe claims Jev can't hallucinate. What that really means is that it will not break the schema you give it: no broken JSON, no invented tool names, only the options you actually provided. It can still pick the wrong option and give you a wrong answer, and that is where they lean on RLCD to keep quality high.

The speed is the headline. Jev can even play Doom, making the per-frame decisions fast enough to respond live. Running about 10 queries per second, that costs only around $7 per hour. Sam's take: if you do any classification with a BERT model, this is worth trying, and he wonders whether it ends the practice of fine-tuning small BERT models for pure classification. He expects it has kicked off people building open source versions, so similar ideas may show up as open source models within a month.

Tools and resources

Claims to verify

• "Output tokens are free" and pricing of $0.042 per million input tokens: confirmed on the OpenRouter model page in the video, and consistent with TypeSafe's launch materials.
• "Two orders of magnitude faster" and "40 to 200x" speed/cost gains: TypeSafe's own claim (the launch cites specific multipliers against named frontier models); independent benchmarks were not shown in this video.
• "Can't hallucinate": narrowly true as a schema guarantee (it cannot invent an option or break the type), but it can still return a wrong label, which Sam states explicitly.
• Architecture ("transformer using the prefill stage", parallel sampler, RLCD): RLCD and the parallel sampler are named by TypeSafe; the transformer/prefill mechanism is Sam's inference, since there is no paper.
• External context not in the video: reporting around the launch says TypeSafe raised about $40M; treat as background, not a video claim.

Glossary

• System 1 / System 2: Kahneman's two modes of thought. System 1 is fast, intuitive, automatic; System 2 is slow, deliberate reasoning. Jev targets System 1 decisions.
• System One Model: TypeSafe's name for a new class of model built to make fast structured decisions software can use directly, rather than to chat.
• Autoregressive: generating output one token at a time, each token conditioned on the previous ones, the way normal language models write text.
• Non-autoregressive: producing the whole output in one pass instead of token by token; the reason Jev is fast and its output tokens are free.
• Classification: assigning an input to one of a fixed set of categories, as opposed to generating free-form text.
• Chain of thought: intermediate reasoning steps a model generates before its final answer; central to reasoning models and to their latency.
• Thinking budget: a cap on how much reasoning (tokens or time) a model may spend before answering.
• Choice: a Jev question type that picks one option from a list you supply and returns a probability for each option.
• Score: a Jev question type that places the answer on an ordered numeric scale you define (for example 0 to 2).
• Noul: a Jev question type that returns the probability that the answer to a yes/no question is yes, squashed between 0 and 1.
• State: the unstructured text or data you pass to Jev to be judged (a ticket, a log, an agent trace).
• Calibration: how well a model's stated probabilities match real-world frequencies; a calibrated 0.9 means roughly 90% correct.
• RLCD: Reinforcement Learning for Calibrated Decisions, TypeSafe's training method for producing trustworthy probabilities.
• RLHF: Reinforcement Learning from Human Feedback, the standard alignment method behind instruction-following chat models.
• RLVR / GRPO: reinforcement learning from verifiable rewards; GRPO is a common algorithm in this family used to train reasoning models.
• InstructGPT: the OpenAI paper that made a base model follow instructions, a precursor to ChatGPT; Diogo Almeida was a top author.
• Parallel sampler: the component TypeSafe credits for emitting all of Jev's answers in one request rather than sequentially.
• Prefill: the stage where a transformer processes the input prompt and computes its internal representations before any generation.
• Transformer: the neural-network architecture underlying most modern language models.
• LLM as a judge: using a language model to score or grade text; its numeric scores are generated text and often poorly calibrated.
• Sigmoid: a function that squashes any number into the 0-to-1 range, used here to describe Noul's yes probability.
• PII: personally identifiable information, such as names, emails, or account numbers.
• Prompt injection: text crafted to hijack a model's instructions; Jev resists it reasonably well in the demos.
• Function calling: a model choosing a tool and generating its arguments; Jev picks the tool but does not produce the arguments.
• BERT: a small encoder model long used for cheap text classification; Jev is pitched as a replacement for fine-tuning these.
• OpenRouter: a gateway that exposes many models through one OpenAI-compatible API, where the demo accesses Jev.