Jev: The AI Model That Doesn't Write Text - It Just Decides

Video source: explanation and live demos of Jev

A new AI model is making the rounds right now because it works fundamentally differently from anything we're used to: it doesn't write text. Jev, built by a company called Typesafe AI, reads text and classifies it - it sorts, scores, and picks options, doing so in milliseconds, thousands of times in a row. According to Typesafe, it's up to 200x faster and up to 400x cheaper than a classic language model. That's a vendor claim, not an independently verified benchmark - but the underlying architecture is genuinely new and relevant for the Mittelstand, because it addresses exactly the kind of task that shows up in almost every automation: the small, fast decision between a handful of options.

Typesafe calls Jev a "System 1 model," referencing Daniel Kahneman's book "Thinking, Fast and Slow." System 2 is the slow, deliberate reasoning - exactly what the reasoning models from every major lab have been trained on for roughly two years. System 1 is the fast gut feeling, intuition without the detour through language. Jev is deliberately built as a pure System-1 model.

Who's behind Jev

Typesafe AI was founded by Diego Almeida, who previously worked at OpenAI and was one of the lead authors of the InstructGPT paper - the work that turned a raw language model into ChatGPT. The person who taught language models to "talk" is now building one that can't talk at all. His argument: ChatGPT and similar models were built for humans, which is why they respond with text. But in automations, AI is very often not used to write text - it's used to classify or score text. Is this a specific type of request? Is this email urgent? Is this spam?

For questions like these, an automation doesn't want a paragraph as an answer - it wants a decision that the next step can act on. Spam probability over 80 percent, move it to the spam folder. A language model can only output a decision like that as text. That's why prompts often include "respond with only one word" - hoping the model actually sticks to it. Jev is built exactly for this case: it doesn't write text at all, it returns the decision itself directly, in a structured format, along with a probability of how confident it is.

How Jev actually works - and why it's so much faster

To understand the difference, it helps to look at what happens inside a normal language model. Say an app asks whether an invoice looks fraudulent: the language model writes the answer token by token, one word after another. Even if you tell the model to answer with only "yes" or "no," that single word is generated the same way an entire essay would be. Current reasoning models additionally think through the problem in writing first, which is why the answer takes several seconds and costs money not just per input token but also per output token. Your own code then has to check afterward whether one of the allowed words actually came back.

Jev gets the same question framed differently - more like a function call. Two things go in: the state, meaning the text in question (an invoice, a support ticket, a chat transcript), and a list of questions where the shape of the answer is fixed in advance. Jev then simply runs through it and distributes probabilities across the predefined options. No text comes back - the values your code needs get filled in directly. Because nothing is written, this takes roughly 0.1 seconds according to the vendor, and the output itself is free - there are no output tokens to pay for, only the input, at roughly 4.2 cents per million tokens according to Typesafe.

Jev can answer essentially three types of questions:

• Choice - a selection from a list of up to 225 options.
• Score - a scale with steps described in words, e.g. "How upset does the customer sound? From calm to furious."
• Boolean - a yes/no question, e.g. "Is this request urgent?", returned as a probability for "yes."

Every answer also comes with a confidence value that indicates how clear-cut the distribution was - 88 to 7 to 5 percent is unambiguous, 40 to 35 to 25 is basically a guess. With a language model like ChatGPT, a self-reported confidence score is usually just made up and says little about actual accuracy. Typesafe says it specifically trained Jev so this number is meaningful - through a method called "Reinforcement Learning for Calibrated Decisions": 90 percent confidence is supposed to mean Jev is right nine times out of ten. Typesafe recommends letting anything above 0.9 run fully automated, routing anything below 0.5 to a human, and asking follow-up questions in between. Typesafe hasn't disclosed how the model is built internally - there's no paper and no architecture diagram.

What's actually new here

Classification models didn't start with Jev - spam filters, sentiment analysis, and document sorting ran on small, fast models long before ChatGPT. The catch: each of those models had to be trained on exactly one task, using thousands of labeled examples. Want to change a category? Retrain the model. A spam filter only ever recognized spam, nothing else.

Language models flipped that around: they've read so much text and been trained on so much data that they know something about almost everything, so you can ask them any question and get a reasonably good answer without fine-tuning them for that specific task first. That broad world knowledge now sits, for the first time, inside a classifier: Jev is a single model that can answer any classification question you phrase in words - is this invoice fraudulent, does the customer sound angry, does this paper belong to cancer research - at the speed and price of a small, specialized classifier. Until now, you had a choice between fast and cheap but locked to one pre-trained task, or universal but slow and expensive because a language model has to think and then write text. Jev combines both advantages.

When Jev is worth it for your automation

From this architecture, two clear use conditions follow: Jev pays off when you need to evaluate large volumes of data or when decisions need to happen in real time. In both cases, a language model is either too slow, too expensive, or both.

A real-time example: in a live chat with thousands of viewers, messages arrive every second, and each one needs to be checked before it's shown - spam, abuse, how confident is the assessment. A language model would need several seconds per message, which at this volume creates a backlog and quickly gets expensive. Jev delivers the decision, according to the vendor, in roughly 100 milliseconds for a fraction of a cent.

For the second case, processing large volumes of data, it's worth being honest about scale: with an inbox of 500 to 2,000 emails, the difference from a classic language model isn't dramatic - you might pay a few cents instead of roughly 2 euros and wait seconds instead of 5 minutes, which barely matters for a one-off cleanup. It looks different when hundreds of new emails arrive every day and each one needs to be sorted and routed the moment it lands, or when a database with hundreds of thousands of text entries needs continuous classification - in other words, for recurring, high-volume processing rather than a one-time task.

Guardrail and model router: two use cases for support bots

An obvious use case for the Mittelstand is deploying Jev as a safety layer before and after a support bot. If a support bot answers thousands of customer inquiries per day from your own knowledge base, there's a risk that an answer goes out that isn't backed by the underlying sources or promises something your policy doesn't allow. The usual fix is having a second language model score the answer ("LLM as a judge") - which itself costs time and money. Jev can perform the same check in a fraction of the time and cost.

Jev also works well as a model router: before an agent is invoked to, say, issue a refund or change an address, Jev can first assess whether this is a simple standard request or a complicated case. Simple ones go to a small, cheap model, complicated ones to the large one - which noticeably cuts costs. At the same time, Jev can act as a guardrail against prompt injections: if a customer tries to manipulate the bot with something like "ignore your instructions," Jev can detect and block that before the request proceeds. Jev can also check after the fact whether a proposed action from the bot should really be executed automatically or needs a human in the loop.

What early users built in the first week

In the first days after launch, a number of community projects already emerged that show what the model is good for in practice:

• A Chrome extension that scores every post in an X feed the moment it appears, highlighting interesting posts and hiding uninteresting ones - real-time content filtering.
• An ad blocker built on the same principle: the code collects every element on a page that looks like an ad, Jev answers the same question for each one - "Is this a paid ad?" - and everything above a threshold disappears live from the page.
• A browser-automation project called Jev Ultrafast, reported to have collected over 17,000 stars on GitHub in its first week. Unlike image-based automation models, Jev doesn't "see" the page - instead, the code numbers every clickable element in advance, and Jev just picks the matching number. Typing text is still handled by a small language model, since Jev can't write text itself. In one documented example, the system filled out a Google Flights search from Zurich to London in roughly 7 seconds for under half a cent.
• Data analysis: one user sorted 108 scientific papers into 24 topics for roughly 8 cents total. Summarizing the papers was handled by a language model; sorting them was handled by Jev.
• SEO use cases: an SEO agency uses Jev to classify thousands of search terms by purchase intent for clients and to check thousands of subpages for whether the headline still fits - noticeably cheaper and faster than a language model alone.
• Ad analysis: in one example, Jev evaluated 724 ads from 37 brands in 40 seconds for roughly 9 cents - scored by hook, format, offer, and call-to-action.

Short clip: Jev live in action

These examples come from publicly documented community demos and haven't been independently verified by Amazing Agents - but they give a good sense of where this kind of model is heading. A consistent pattern shows up throughout: a language model writes the text, Jev decides, and your own code executes the decision. Anything that actually does something - sending an email, deleting a file, triggering a payment - stays in your code with clearly defined thresholds. Jev only decides; it never executes anything itself.

What Jev can't do - and where to be careful

Just as important as the strengths are the model's clear limits, which matter for production use in a Mittelstand business:

• No multi-step reasoning: reasoning models remain far better suited for complex, multi-step deliberation.
• No math or counting: according to Typesafe's own documentation, Jev isn't a calculator and can't reliably compare dates - that logic still belongs in your own code.
• No built-in domain knowledge: Jev doesn't automatically know what "urgent" means for your company - such criteria need to be defined explicitly in the state you pass in.
• Vulnerable to injected instructions in the input: since Jev takes everything in the passed text literally, a spam email claiming "urgent deadline!" can accidentally get classified as important. Criteria should be actively defined, and instructions found inside the input text should be explicitly marked as not authoritative.
• No image or audio understanding: Jev only reads text.
• Limited context window: around 64,000 input tokens is the cap - very long documents need to be split beforehand.
• Trained mainly on English: Jev was trained predominantly on English-language data and is likely to perform noticeably worse on German text than on English - something you should verify with your own German test data before deploying it in production.
• No guaranteed protection against misjudgments: the output format is always correctly structured, but the underlying probabilities can still be wrong - "hallucination-free" only applies to the structure, not to the content of the decision.

Data privacy: why Jev is only a partial fit for personal data right now

Typesafe AI is a US provider. Data you process through Jev is routed through American servers, and the assurance that nothing is stored applies, according to the documentation, only to enterprise customers. For businesses in the DACH region, that means: without an appropriate data processing agreement and a verified legal basis, you should not process personal or otherwise sensitive data through Jev - for example, unredacted customer data from email inboxes or job applications.

If that's a dealbreaker for you, there's now an alternative: a few days after Jev launched, an open model called Laya appeared, which can be self-hosted on your own server or machine, available for instance via Hugging Face. That means no request ever leaves your own system. The catch: unlike Jev, Laya isn't universal out of the box - like classic classifiers before Jev, it first needs to be trained on your specific task using a few thousand labeled examples. After that, it's reportedly even more accurate than Jev and responds in around 30 milliseconds, but only for the one task it was trained on. Two hard limits also apply: Laya handles significantly more than 20 categories poorly, and the context window is only 512 to 1,024 tokens - roughly the length of a short email. For narrowly scoped, recurring classification tasks involving sensitive data, the training effort can still be worth it.

Criterion	Jev (Typesafe AI)	Laya (open model)
Server location	USA	self-hosted
Use case scope	universal, no training needed	only after custom training
Categories	up to 225 options	up to ~20
Context window	~64,000 tokens	512-1,024 tokens
Personal data	only with a DPA / enterprise contract	unproblematic (self-hosted)

How to try Jev yourself

The most pragmatic entry point is OpenRouter, where Jev is available alongside numerous other AI models - without needing a separate contract with Typesafe AI. For a first prototype, it's enough to ask a coding assistant like Claude Code to wire up Jev via your own OpenRouter API key for a concrete classification task - for instance, automatically pre-sorting incoming requests by urgency. That lets you quickly check whether the accuracy holds up for your specific use case before larger data volumes or production processes depend on it.

Before going to production, clarify three things: first, which categories and criteria you need to define explicitly in the state so Jev doesn't make assumptions that don't fit your industry; second, whether the text you're processing contains personal data that requires a different provider or a self-hosted model like Laya; third, at what confidence threshold a decision may run automatically and when a human needs to be looped in. In practice, these three questions decide the success of a project far more than the model's raw speed.

Bottom line: a second type of model for a different type of task

Jev won't replace language models - Typesafe doesn't claim that either. It's a second type of model for a different type of task: the many small decisions embedded in practically every automation workflow, for which a language model is simply too slow or too expensive to deploy everywhere. Several similar projects have already launched since Jev's release, suggesting that the idea of a pure "System-1 classifier" alongside established "System-2 language models" is likely to establish itself as its own model category. For Mittelstand businesses with a high volume of recurring classification decisions - email sorting, content moderation, lead qualification, guardrails for support bots - it's worth looking at this architecture now, regardless of whether you end up using Jev, a competitor, or a self-trained local model.