What happened
Most companies don't need an AI that writes paragraphs. They need a decision model that picks an option.
Which department should handle this customer's message — billing or delivery? Should this expense report go to the manager or the finance director? Is this complaint urgent, or can it wait until Monday? Is this person owed compensation, and if so, how much?
The usual workaround is clumsy. You grab a big language model, paste in a prompt that fills half a screen, get a paragraph back, then use regex — pattern-matching code — to dig the actual answer out of the text. It works, sure. But it's expensive, it's slow, and here's the real problem: the model sounds exactly as confident when it's wrong as when it's right. You've got no way of knowing which answers you can trust without a human checking every single one.
Jev, and why TypeSafe AI calls it "System One"
In September 2026, TypeSafe AI released Jev and branded it System One. The phrase comes from psychology: System 1 is the fast, automatic thinking you do without effort; System 2 is the slow, deliberate reasoning you do when you're genuinely working something out. Big chain-of-thought models are System 2. Jev is built to be System 1 — fast, cheap, and mass-produced.
Here's the drill. You hand it a state — a customer email, a support ticket, a document, a product listing — plus a batch of questions. Each answer comes back as one of three shapes: a score from 0 to 1 (how negative is this review?), a yes or no (does this ad break our rules?), or one option out of N (which department does this belong to?). It never generates text at all. In a single pass it returns a probability for every allowed answer, and it does that in 70–500 milliseconds. The developer pays $0.042 per million input tokens, and the answer itself is free. TypeSafe's own examples include returns triage for online stores, sorting scientific papers, sentiment scoring, and routing inbound requests.
Inside the box: one pass instead of dozens of steps
Public breakdowns suggest there's no exotic new architecture hiding in there — it's an ordinary transformer decoder, the same engine that powers any LLM. What changes is what it does after reading. It takes in the state and the question once, then instead of generating words one at a time, it looks at the probabilities of only the permitted answers — say, the letters A, B and C. That's one operation replacing dozens of generation steps.
The training is the interesting part. Once a chat model is fine-tuned "to be helpful," its probabilities run systematically hot: it announces "99% sure" in situations where it's right 70% of the time. As a confidence measure, those numbers are junk. Jev was trained with a separate calibration method so that "0.8" really does mean "right about 80% of the time." For business processes that's the whole ballgame — those probabilities are what let you decide what to hand to automation and what to hand to a person. Jev picked up critics fast, though. The weights are closed, so it's a black box: you can't crack it open and see why it answered the way it did.
The experiment: a 4B model, one evening, one rented GPU
A Habr author writing under the handle GG1KENOBI decided to test the alternative himself. He took an open 4-billion-parameter model, fine-tuned it on Russian-language decision tasks on a rented graphics card over the course of one evening, and benchmarked it against OpenJev plus two small LLMs — YandexGPT and GigaChat — which aren't decision models at all. He just wanted to see how they'd do. Every model got identical calibration, and the test set included tasks none of them had ever laid eyes on.
The short version: on its home turf, his model pushes nearly two-thirds of the incoming flow straight to automation. On unfamiliar tasks it stays in the top group but doesn't win. He published the model and all the code openly, and picked up a whole collection of hard-won lessons along the way. The write-up takes 19 minutes to read and drew 4.6K readers.
What it means for you
This isn't just an engineering curiosity. Decision tasks are everywhere once you start looking, and here's what that could look like in your own week.
At home: stop being the family's router
Most of the mental load at home is really routing. Which school email needs an answer today, which bill is a duplicate you already paid, whether that delivery notice is a genuine problem or just noise. A decision model pointed at a yes/no question plus a 0–1 urgency score can tag all of it in under half a second per item — and because it's calibrated, a 0.9 urgency score actually means "deal with this now," not "the AI was feeling dramatic today."
At work: a queue that admits when it's unsure
If you run a support or ops queue, you probably already sort tickets by hand or by crude keyword rules. A decision model lets you route by department, flag urgency, and score frustration — then set thresholds so anything above 0.9 goes straight through and anything in the murky middle goes to a human. That last part is the unlock. Ordinary LLMs give you a paragraph with no honest confidence attached, so you either trust all of it or none of it.
In business: returns, refunds and where the money leaks
Online stores are the obvious fit, and it's where TypeSafe points first. Is this a refund or a replacement? Is the customer within the return window? Is this a complaint that needs a supervisor? Each of those is a closed question with a small set of answers, which is exactly what a decision model eats for breakfast. At $0.042 per million input tokens with free answers, triaging thousands of requests a day costs less than your office coffee run.
For study: sort the pile without reading the pile
Researchers and students drown in papers. A decision model can answer "does this match my topic?" and "is it a review or an experiment?" as yes/no and one-of-N questions across hundreds of abstracts, ranked by relevance score. You still read the important ones — you just stop reading the ones that were never going to matter. TypeSafe lists scientific paper sorting as one of the core use cases.
For creators: reading the room at scale
You can't read every comment. You can score them. Sentiment from 0 to 1, plus a yes/no on "does this contain a question I should answer?" and one-of-N on "is this praise, a bug report, or a feature request?" Now the loudest voices aren't the only ones you hear. If you'd rather not hand-code any of this, there's a free stack of AI tools at MyKreaTool you can use to test the idea before you spend a cent on infrastructure.
For income: sell the decision, not the chatbot
Here's the business angle. Clients don't want a chatbot — they want their inbox sorted. A tiny calibrated model that does one routing job well is easier to sell, easier to price, and far cheaper to run than piping everything through a large LLM every time. And since the author released the model and code openly, your starting point costs nothing but GPU rental.
How to try it right now
You don't need a machine learning background for the first three steps. Here's the order that saves you the most money and time.
1. Write the decision as a closed question. Fifteen minutes, zero cost. Instead of "summarise this complaint," write: "Is this urgent? Yes or no." Instead of "what does this customer want," write: "Billing, Delivery, or Other?" If you can't list the possible answers up front, no model will save you.
2. Start with the free, open option. The author's 4-billion-parameter model and all the code are open source, and OpenJev is open as well. Download, run locally, and see whether the approach fits your problem before anyone sends you an invoice.
3. Try the hosted route if you don't want to babysit hardware. Jev is the commercial one from TypeSafe AI: $0.042 per million input tokens, free answers, 70–500ms per pass. Remember the trade-off — the weights are closed, so you're renting a black box.
4. Fine-tune your own on a rented GPU. This is the evening project the whole article is about. Rent a GPU, take an open 4B model, fine-tune it on a few thousand of your own labelled examples, and you'll have a specialist by morning.
5. Calibrate before you trust it. This is the step people skip and then regret. Check whether your 0.8 scores are actually right about 80% of the time. If they aren't, don't wire the model into anything that matters.
6. Set your thresholds. Pick a cut-off — say 0.9 and up goes to automation, 0.4 to 0.9 goes to a human, below 0.4 gets dropped — and tune it against real traffic.
7. Test on data the model has never seen. In the Habr experiment, the model dominated on its own domain and only held its own on unfamiliar tasks. Replicate that honesty: hold back a slice of your data and find out where it really lands.
Upsides and what changes
Three things shift when you move from generating text to predicting an answer.
Speed and cost collapse. One pass instead of dozens of generation steps means 70–500ms and $0.042 per million input tokens. You can now afford to run a decision on every single incoming item rather than sampling.
Confidence becomes a number you can act on. Calibration turns "the AI said so" into "the AI is right about 80% of the time here." That's the difference between a demo and something your operations team will actually let into production.
No more regex archaeology. You get a value, not a paragraph you have to mine. The pipeline gets shorter, and shorter pipelines break less often.
And the barrier to entry is genuinely low. An open 4B model, fine-tuned in an evening on rented hardware, routed almost two-thirds of one author's traffic to automation — on his own task, yes, but that's a real result from a real weekend.
Limitations
Be clear-eyed about what this isn't. Jev's weights are closed, so you can't inspect or explain its reasoning, and reviewers flagged that immediately. On tasks outside its training distribution, the Habr model stayed in the top group but didn't lead — so a decision model is a specialist, not a generalist, and it'll stumble the moment you point it at something new. The comparison also isn't apples to apples across the board: YandexGPT and GigaChat aren't decision models at all, and the author says as much. Calibration is the hard part and the part most people skip, and if you skip it you get confident-sounding numbers that mean nothing. Finally, the entire one-evening result comes from a single author's published experiment — treat it as a promising signal worth reproducing on your own data, not as a universal benchmark.
Conclusion and one action for today
The interesting thing here isn't that a small model beat a big one. It's that we've been using text generators for decision jobs because that's what we had, and a purpose-built decision model — one that answers in probabilities, in a single pass, in milliseconds — is both cheaper and more honest about when it's guessing.
Your one action: open a note and write down a single recurring decision from your week as a closed question with a fixed set of answers. "Is this urgent? Yes or no." "Which team owns this? A, B, or C." That's it. No GPU, no subscription, no code. Fifteen minutes of thinking is the only real prerequisite — and it's the step that decides whether any of the rest is worth doing.
Comments 0