Classifiers used to be homework

The first classifier I ever trained was on Iris, as a student at EPFL. You call scikit-learn's load_iris(), get 150 flowers with four measurements each, fit an SVM, and spend the evening nudging C and gamma to claw back one more point of accuracy.

Then you leave school and find out that real problems run the same loop, only slower and with more meetings. Support tickets, emails, sensor logs, product photos: agree on a label set, argue about the label set, hand-label a few thousand examples, build features, fit, tune, deploy. It took weeks before you knew whether the thing was worth having.

Zero-shot learning ended that. It is the most important idea in AI of the last ten years: a model trained on enough of the world can do a task you only describe to it. So most teams stopped training classifiers. They paste the ticket into a frontier LLM, ask it to pick a category, and parse the answer out of whatever it writes back. It works, and it is also a little absurd. We went from hand-tuning an SVM on a laptop to sending "is this a refund request?" through GPT6-Sol, a model that can write a compiler, and waiting several seconds for one word.

Jev, released last week, sits in between. You still describe the task in plain English and label nothing. The answer comes back in a tenth of a second, at a price close to the classifier you would have trained.

A model built for fast thinking

TypeSafe came out of two years in stealth on September 15 with Jev, its first model. Its founder, Diogo Almeida, worked at OpenAI on the methods behind ChatGPT. The company calls Jev a "System One model", after Daniel Kahneman's Thinking, Fast and Slow. System 1 is the fast, automatic mode that reads anger in a face or answers 2 + 2 before you decide to. System 2 is the slow, effortful one you need for 17 × 24. Nearly all the LLM progress of the past two years went into System 2, with longer reasoning traces, bigger thinking budgets and bills to match. Jev is built for the other mode.

It doesn't write text. You send it some state (a ticket, an email, a JSON blob) with a set of typed questions, and it answers all of them in one parallel pass. There are three kinds of question:

• Choice picks one option from a fixed list of up to 255.
• Score places the state on an ordered rubric, like one to five stars.
• Noul gives the probability that a statement is true.

Every answer is one of the values you defined, with probabilities attached. You have nothing to parse and no invented label to catch.

{ "team": "billing", "urgency": 4, "threatens_to_leave": 0.82 }

Milliseconds instead of seconds

A Jev call takes 70 to 500 ms. The frontier LLMs TypeSafe measured on the same tasks took 3 to 329 seconds, so Jev is roughly a hundred times faster. It costs $0.042 per million input tokens, about two orders of magnitude less than those models, and output is free where an LLM charges about five times its input price. You can always find a fairer comparison, a smaller and faster LLM or a tighter prompt, but the order of magnitude holds.

Speed decides where a decision can live. At several seconds a call, classification belongs in a background job. At a tenth of a second it can sit inside a loop that is already running: a voice agent choosing what to do from a half-finished sentence, or a coding agent checking whether the command it's about to run is safe. Price does the same thing to volume. When a decision costs a fraction of a cent you stop rationing it, and you can put a check at every step of a process instead of one at the end. That is why the past week has felt so busy. A whole class of decisions that were never worth automating suddenly are, and people have been racing to find them.

What training still buys you

Zero-shot does have a cost, though, and it shows up in accuracy. Two independent comparisons, one on English benchmarks and one in Japanese, put Jev against classifiers people trained themselves, and they agree on the shape of the result.

Against the older zero-shot methods Jev wins easily. Against a small model trained on labeled data, it depends on the task. When the label is visible in the words, like a banking intent or a news topic, the small trained model still wins, often by more than ten points, and runs in milliseconds on a CPU. When the label is a judgment about the words, like whether a review deserves three stars or four, Jev holds its own and sometimes wins outright. The author of the Japanese test put it best: "if the label is visible in the words, train something small".

Where accuracy is paramount, training still earns its place. But most classification problems never got that far. They were yes-or-no calls and small judgments buried in code, too minor to justify a labeling project. Now there is something good enough to reach for on any of them, and it turns out there are a lot of them.

Asking the same question fifteen times

Accuracy tables miss something that matters more once a model is making decisions: whether it gives the same answer twice. Ask an LLM the same question fifteen times and the answers drift, even at temperature 0. TypeSafe's docs include two experiments on this, and I found them more convincing than the benchmarks.

In the first, a single insurance claim went through a 14-question rubric fifteen times with only a throwaway ID changed. Jev's probabilities barely moved, less than any LLM setup they tried, reasoning models included, and it answered in about a tenth of a second while the LLMs took up to fourteen.

The second points at a useful design. A borderline moderation post went through eight questions fifteen times, and on two of them Jev's top answer kept flipping. Those were exactly the questions where it was least sure. So they added a rule: below 0.60 confidence, a person decides. The flipping almost vanished, at the price of sending about a quarter of the answers to a human.

Both experiments are the vendor's, run on a single example, and being consistent is not the same as being right. The design holds up anyway. The model acts on the cases it is sure of, a person handles the rest, and the cutoff becomes a dial between cost and risk that you set with your own data.

Trust the interface, test the confidence

Jev has sharp edges, and the practical guides are upfront about them. It can't do arithmetic or compare dates, so you extract the values with it and do the math in code. It reads instructions literally, so a stray "not" or "only" changes the question, and accuracy drops as you pad the state with context the question doesn't need. These are limits you design around once.

Calibration is the one that matters, because everything above rests on it. The 0.60 rule only works if a confident answer is usually a right one, and in the English benchmark Jev reported 88% average confidence while landing around 80% accuracy. An open-weight rival shows how far this can go wrong: Laya, a 421M-parameter ModernBERT, scored 0.000 on Khmer at 95.2% confidence.

Laya is one of several open versions that appeared within days of the launch, alongside NanoJev and openjev-sglang, which puts TypeSafe's API shape in front of any open LLM. What is spreading fastest is the interface itself: state and typed questions in, probabilities out. That's good news, because you can build against the interface and swap the model behind it. It also shows a new reality: any release now has its core logic cloned and open-sourced within days, sometimes hours.

Code enumerates, Jev decides

The most interesting projects from the first week share a pattern. Code handles everything deterministic, lists the options available at that moment, and asks Jev to pick one.

The games show it most clearly. In jev-plays-pokemon-red, code walks the character around and Jev only chooses at branch points. jev-tetris enumerates every legal placement and lets Jev pick. JevPilot drives a car through a Three.js simulation the same way, and jev-drone flies a simulated quadrotor from its camera feed. A frontier LLM is far too slow to sit inside those loops.

Agents are where it gets useful. jev-guard scores every tool call an agent is about to make and answers allow, ask, or deny. That's the gate I most want to see in production: cheap enough to run on every call, with the ambiguous ones going to a person. Browser agents like jev-browser-use use it to choose what to click, and jev-canvas picks an action from a voice transcript before the speaker has finished.

That's the experiment I'd run first. Find a loop that currently runs on brittle rules or waits on an LLM, put a typed decision at each branch, and see what changes when the decision is fast and cheap enough to be everywhere. The awesome-jev list tracks what others are trying.

Trying is cheap now

When a classifier took weeks, you built one only when you were fairly sure it would pay off. When the first version takes an afternoon, you can try ten ideas, check the promising ones against a small labeled sample, and save the labeling and training for the one that earns it. I still like the Iris loop. I just don't have to start there anymore.