I tested Jev, a new System One model from TypeSafe AI, against conventional generative LLMs on classification and sorting tasks. It does not output sentences or generate paragraphs, but it evaluates fixed options in parallel and returns structured decisions.
Software usually needs an answer, not a conversation. When an automated workflow needs to route a ticket or pick a category, waiting for a generative model to write out text and parsing that text back into structured data is slow. If you constrain the problem to choices, scores, or boolean checks, a decision model evaluates the whole set at once and gives you numbers software can use.
A decision model rings a bell instead of writing sentences
On September 15, Diogo Almeida, who is also the co-inventor of Chipt, posted about releasing Jev. He claimed it was 20 to 200 times faster and 40 to 400 times cheaper than normal models.
Those numbers caught my attention, but looking at the TypeSafe website did not immediately make the concept click for me. The model is not a generative large language model. It is a decisional model.
A meme made the rounds that explains the difference in one shot. A normal LLM is like Saul Goodman. It keeps talking and replies with lots of words. Jev is more like Hector Salamanca. You ask him something and you do not get words back.
The three outputs are Choice, Score, and Null
To understand what Jev outputs, take a simple customer situation: “My flight was cancelled. Can I get a refund?” Jev handles this through three distinct types of answers.
The first type is Choice. You supply the situation and a list of possibilities, and Jev picks the correct option. In the flight example, you ask for the main request and Jev immediately returns that the customer needs a refund. In the Choice mode, you can give it between 0 and 255 options to pick from.
The second type is Score. Given the same situation, you can ask how frustrated the customer is. Jev might return a score like 1.2, placing them between concerned and angry rather than calm.
The third type is Null. This is a direct verification question. You ask if the customer is requesting a refund, and it returns a probability like 0.96.
Parallel evaluation avoids the serial token bottleneck
Normal generative models work in serial. They generate tokens one after another, which takes time.
Jev evaluates options in parallel. You provide the situation along with all the possible answers, and it rates all of them in one go. In my own tests and in the examples I looked at, responses completed in roughly 100 to 200 milliseconds.
Other people on Twitter shared practical examples using this setup. One person used Jev to sort news items into categories and assign tags. Another designer built an interface where typing a prompt filtered a visual list: asking for things you wear in winter or things you need to lose weight filtered the choices immediately. A third project highlighted relevant articles in green based on a selected niche.
The sorting race against DeepSeek Flash
I set up my own test as a sorting race between Jev and DeepSeek Flash. The test itself was written with AI, so it is an informal benchmark rather than a scientific measurement.
The task was to take incoming situations and sort them into four priority buckets: the normal box, the today box, the emergency box, or ask a person. Sorting races like this do not show Jev at its best because Jev can evaluate multiple questions in parallel, but it shows raw speed on basic decisions.
Jev finished with a median response time of 256 milliseconds. It processed 30 questions in the time the other LLM took to process 8. Across the repeated runs I did, Jev consistently scored over 90% accuracy. The conventional LLMs varied wildly between runs, hitting 100% on some attempts and dropping down to zero on others.
The Spaceport Scanner kept a steady speed across 24 questions
My second experiment was a Spaceport Scanner interface. The test scenario gave the models a situation involving an arriving shipment, staff conditions, and damaged documents, then asked questions based on that data.
In round one, both models answered four out of four questions correctly, though Jev returned the result faster.
In round two, the test increased the number of questions. Jev scored 7 out of 12, while the conventional LLM scored 8 out of 12.
Round three pushed the test to 24 questions. Jev scored 22 out of 24. The speed looked quite consistent from round to round, despite the jump in question volume. The conventional LLM hit a one minute hard stop and scored zero because it did not return enough results in time. Across the test, Jev finished with an accuracy of 83%.
Where constrained decisions fit into software
Jev will not replace generative chatbots. You cannot use it to write draft replies, generate marketing copy, or hold a conversation.
Its role is making small, constrained decisions that software can consume directly. That fits workflows like routing incoming customer tickets, checking whether an LLM output contains errors, picking which tool an agent should call next, or filtering articles for business automation.
If you want to try it, TypeSafe has a waitlist on their website that usually approves access within a couple of hours or half a day. If you do not want to wait for that access, the model is already available through the Vercel AI Gateway and on OpenRouter.
What to copy, even if you never touch Jev
- Separate decision logic from text generation. If an automation only needs to pick a path, routing the data through a text generation prompt adds latency and parsing risk.
- Keep the candidate list bounded. Limiting choices to a fixed set between 0 and 255 items keeps the answers in a shape software can consume.
- Measure latency under load. A model that answers one question in 200 milliseconds should not slow to a crawl on twenty. Parallel evaluation keeps the execution time flat.
- Use simple numerical scoring for sentiment and urgency. Getting a single float back between categories is easier to route into an alert system than asking an LLM to explain why an email sounds upset.
Tools used
- TypeSafe AI: Decision model platform.
- Jev Announcement: Details on System One architecture and benchmarks.
- TypeSafe Documentation: Documentation for Choice, Score, and Null endpoints.
- Vercel AI Gateway: Hosted access to run Jev via API.
- OpenRouter: Alternative API provider hosting TypeSafe models.
- DeepSeek Flash: Generative model used as the baseline in the sorting race test.
Video chapters
00:00What is Jev?00:47Hector Salamanca vs Saul Goodman01:47Choice, Score, and Null03:26Parallel evaluation04:08Examples from Twitter06:06The sorting race07:25The Spaceport Scanner09:06Where Jev fits and how to access it