Last week, TypeSafe AI released Jev , an AI model that does not write emails, generate code or hold conversations. Introduced by a startup founded by former OpenAI researcher Diogo Almeida, Jev instead focuses on providing a model that can make decisions that software and agents can act on directly.

It classifies information, assigns scores and returns probabilities without generating the paragraphs that conventional large language models use to communicate their answers. It also is very fast and very cheap, with an advertised price is $0.042 per million input tokens, and no separate output charge. For developers accustomed to paying language models to produce a few words of structured information, Jev presents an intriguing proposition. Why generate a conversation when the application only needs a decision?

The economics have caught developers’ attention. Vercel engineer Pranit Sharma reported that replacing a conventional language model with Jev for command safety classification produced responses five to 18 times faster, with improved accuracy in his test. Another developer found that Jev classified business emails at a fraction of the cost of Google’s Gemini, though Gemini was slightly more accurate.

TypeSafe briefly struggled to serve demand through its API following the launch, according to TechCrunch. For businesses running automated systems that make thousands of decisions every hour, those early experiments suggest a way to reduce the expense of routine AI tasks without rebuilding the software that handles them, but building a dependency on third-party models for decision making can prove to be tricky.

The larger question concerns how much intelligence an application actually needs. Technology companies have spent years improving language models that reason, write and converse with humans. TypeSafe is pursuing the narrower objective of building a model that is only focused on making rapid, structured judgments inside existing software.

Jev’s arrival has prompted developers to examine which tasks genuinely require a sophisticated conversational model and which could be handled by a cheaper specialist. Its early performance figures are striking, but questions about accuracy, security and the reliability of automated decisions remain unresolved.

What Jev Actually Does Differently

Let’s use a simple example as a way of understanding how Jev differs from an LLM such as Claude or OpenAI’s GPT models. For example, let’s say a customer is chatting with an online support bot and types: “I was charged twice for my subscription. Can you refund me?”

A conversational bot needs to determine whether the message concerns billing, technical support or sales. A conventional language model works by reading the complaint like it’s any other language input, then works to identify the relevant department and generate a written explanation. The LLM has to do all the heavy lifting to understand the chat, reason through the steps, and then generate an appropriate response or output. This can take a lot of tokens, many steps, and also result in responses that aren’t always predictable.

Jev shortcuts the decision-making steps. It receives the message and a list of permitted categories, then returns a defined selection accompanied by probability estimates. The inputs and outputs are more predictable, and it can operate much faster with less token usage.

The distinction becomes more meaningful when the retailer receives 100,000 such messages. The application does not need a written explanation for each routing decision. It just needs a result its existing software can process.

Jev supports three types of questions. Choice selects an answer from predefined options. Score evaluates information against a numerical scale or rubric. Noul, TypeSafe’s name for its third question type, estimates the probability that a statement is true. Multiple questions can be evaluated in parallel using the same input.

TypeSafe calls Jev a System One Model, borrowing its terminology from psychologist Daniel Kahneman’s distinction between fast, intuitive thinking and slower, deliberate reasoning. The company says Jev uses a new architecture and a training method called Reinforcement Learning for Calibrated Decisions (RLCD), designed to make its probability estimates reflect uncertainty more accurately.

Almeida described the ambition in TypeSafe’s launch announcement.

“Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.”

The model’s output is structured from the outset. Developers do not need to request a written explanation, extract a decision from it and discard the remaining text.

Since Jev is just focused on three types of decisions, that means it is not suitable for the range of problems that LLMs are being applied to solve. It cannot draft a customer response, invent a new category when existing options are inadequate or independently execute a complicated business process. Developers must still provide the relevant information, define the available actions and write the systems that interprets the result.

The underlying concept of structured AI responses predates Jev. OpenAI introduced Structured Outputs in August 2024, allowing developers to require model responses to conform to predefined JSON schemas.

Jev approaches the problem through a different model design, prioritizing typed decisions and parallel evaluation rather than generating conversational responses. Whether the architecture offers sufficient advantages over existing alternatives will require further comparative testing.

Why Jev Has Developers Rethinking The Cost Of AI

TypeSafe named Jev after nineteenth century economist William Stanley Jevons, whose work examined how improvements in resource efficiency could stimulate greater consumption.

The company expects a comparable effect in AI. Lower inference costs could make it economically feasible to introduce intelligent decisions into software processes that currently rely on rigid rules or require human intervention.

TypeSafe reports response times of 70 to 500 milliseconds and advertises Jev at $0.042 per million input tokens, and no cost for output tokens. At that rate, processing one billion input tokens would incur just $42 in charges, excluding other infrastructure and operating expenses.

The equivalent input volume would cost approximately $4,000 using Anthropic’s Claude Opus 5.5 or OpenAI’s GPT-5.6 Sol, $5,000 using Claude Opus 5, and $10,000 using either Claude Fable 5.1 or GPT-6 Astra. Those figures exclude output tokens, which introduce additional expense.

The company claims that its internal workflow evaluations found Jev approximately 194 times faster and 445 times cheaper than selected frontier language model comparisons. TypeSafe acknowledges that these figures represent the upper end of the performance gains it expects customers to encounter.

But fast and cheap doesn’t always mean accurate. TypeSafe’s own published results reveal an accuracy tradeoff. Explainx.ai independent testing showed an aggregate score of 67.8% accuracy for Jev compared with 74.1% for the strongest comparator in the company’s evaluation.

This accuracy deserves as much attention as the price difference. An application sorting low priority customer messages might accommodate occasional classification errors. A system authorizing financial transactions or destructive software commands has much less room for mistakes.

Developers Are Finding Uses Beyond Customer Service

Jev has attracted interest from companies building the infrastructure used by AI agents. Vercel engineer Pranit Sharma tested Jev as a replacement for a language model that classified whether commands were safe to execute. TechCrunch reported that the substitution improved response speed by five to 18 times and increased accuracy in the test.

According to reporting in TechCrunch , Bryo AI CTO Nikhil Mudholkar tested Jev on classifying business emails. His experiment found Google’s Gemini slightly more accurate, but with costs approximately 10 to 20 times higher than Jev’s.

The findings offer two concrete examples of the economic tradeoff. A specialized model may deliver sufficient accuracy at much lower cost, but its suitability depends on what happens when it gets a decision wrong.

LangChain has found a separate application: evaluating the behavior of other AI agents. Developers commonly use language models to inspect an agent’s work and judge whether it completed a task correctly. Those evaluations can introduce substantial cost when an application runs thousands of times each day.

In a September 20 experiment, LangChain tested Jev against three conventional language models using five recorded weather agent responses. Each evaluator reviewed the same responses repeatedly, allowing researchers to compare accuracy, consistency, speed and expense.

Jev matched the human reviewer’s binary judgments on all 500 repeated decisions. It averaged 0.44 seconds and $0.00035 per evaluation. Its continuous quality scores showed substantially less variation than the competing models in this test. The caveat in this test is that LangChain’s experiment covered one agent and a limited collection of tasks. Consistent judgments are not necessarily correct judgments.

Jev Can Return A Valid Answer That Is Completely Wrong

TypeSafe’s assertion that Jev cannot hallucinate has generated considerable debate among developers.

The company’s claim refers to Jev’s inability to generate responses outside a predefined structure. In other words, if an application asks the model to select from five categories, Jev cannot invent a sixth. It can, however, select the wrong category or assign a high probability to an incorrect answer. TypeSafe’s guarantee concerns the structure of the response, not the factual accuracy of the decision.

More critically, in a September 21 investigation, VentureBeat described an experiment involving a potentially destructive computer command. Jev initially assigned a 0.76 probability to blocking the command. After an engineer added a fabricated authorization message to the information presented to the model, its blocking probability fell to 0.48.

The experiment involved a single command and cannot establish how frequently such attacks would succeed. But it demonstrates that malicious information introduced into an application’s input can influence Jev’s judgments. A security system that approves an unauthorized command has not become more reliable simply by reaching its decision in 70 milliseconds.

The topic became a prominent subject of discussion in the Hacker News launch thread , where developers challenged the accuracy of TypeSafe’s description of its resistance to hallucination. Some questioned whether Jev’s capabilities justify comparisons with language models that can generate code and perform open ended tasks. Others argued that conventional language models already support constrained outputs, making Jev’s speed and cost its more meaningful differentiators.

Jev’s Biggest Opportunity Is The Work AI Does Behind The Scenes

Almeida’s dissatisfaction with conventional language models helped shape TypeSafe’s approach.

“We have lightning in a bottle, and yet it is not useful,” he told TechCrunch, describing his frustration with the limitations of conversational AI for software automation.

The statement reflects a particular problem in enterprise software. Many automated processes need an application to inspect information and select an action. Generating a sophisticated explanation of that action may add latency and expense without improving the outcome.

The opportunity extends beyond replacing an expensive model with a cheaper one. Developers could use Jev to evaluate an agent’s proposed actions, determine when a more capable language model is needed or inspect completed tasks before allowing an automated workflow to proceed.

Such systems would combine different forms of machine intelligence, assigning each model work suited to its capabilities rather than relying on a single conversational model for every operation.

Jev’s early experiments provide evidence that this approach can reduce costs and response times on certain tasks. They leave open questions about performance under sustained production workloads, accuracy on unfamiliar data and the operational consequences of incorrect decisions.

For companies evaluating Jev, the most consequential metric may be neither speed nor price. It is the cost of a wrong decision. A routing error might send a customer to the wrong department. An incorrect security classification could authorize a destructive command. Those are very different risks, and the same model may not be appropriate for both.

TypeSafe has made the experiment unusually inexpensive. Whether Jev becomes a fixture of enterprise software will depend on what developers discover after the promotional pricing and early benchmarks give way to sustained production workloads.