This website uses cookies

Read our Privacy policy and Terms of use for more information.

Welcome Back to XcessAI

The AI industry has been obsessed with models that can talk. Write an email, explain a document, generate code, reason through a problem, produce a report. Language models became extraordinarily good at turning an input into strings of human-readable text.

But software does not always need an essay. Sometimes it simply needs to know whether a request is urgent, which model should handle a task, whether an action looks dangerous, or whether an agent should continue or ask a human.

Today, we often answer those questions by calling a large language model, asking it to reason about the problem and waiting for it to generate an answer. A new AI model called Jev takes a very different approach.

Jev does not generate text at all.

You give it some context and a set of defined questions. It returns structured decisions and probabilities that software can use directly. Its creator, TypeSafe AI, calls this a System One Model: intelligence designed not primarily to communicate with humans, but to make fast decisions inside software.

That may sound like a niche distinction. The response from developers suggests otherwise.

Within 24 hours of appearing on Vercel's AI Gateway, Jev had reportedly been used by almost 13% of paid teams, more than twice the penetration of any previous model launch on the platform. Two weeks later, usage had reached roughly 35%. By October, decision models were processing around one in four requests through Vercel's gateway while accounting for only 0.53% of spending. Almost all of that decision-model traffic was Jev.

Then OpenAI launched its own Decisions API.

A category appears to be forming, and it points to an interesting possibility:

The future AI agent may not run on one model. It may run on an architecture of different models performing different kinds of thinking.

The Expensive Agent Loop

Consider how an AI agent works. The model receives a goal, decides what to do, uses a tool, examines the result and then decides what to do next. That cycle may repeat dozens or even hundreds of times before the original task is complete.

The problem is that many of those decisions are surprisingly mundane. Which database should I search? Does this result answer the question? Is this email urgent? Which model should handle the next step? Does this proposed tool call look dangerous? Should I retry or escalate to a human?

A frontier LLM can answer all of those questions. That does not necessarily make it the right tool.

Calling a large generative model for every micro-decision is a little like asking a senior consultant to approve every line in a spreadsheet. It works, but it is unnecessarily expensive and slow.

As agents become more autonomous, that problem compounds. A single user request may trigger dozens of model calls behind the scenes, meaning the economics of agents depend not simply on the cost of one intelligent response, but on the cost of thousands of small decisions.

A Model That Doesn't Talk

Jev was designed specifically for those decisions.

Instead of asking it to generate an unrestricted answer, software sends Jev a state, essentially the information relevant to the decision, and asks one or more predefined questions.

The answers come in three basic forms. A Choice selects between defined options. A Score evaluates something along an ordered scale. A Noul answers a yes-or-no question by returning the probability that a statement is true.

A customer-support system, for example, might send Jev an incoming message and ask whether it is urgent. Instead of generating several sentences explaining why the customer appears frustrated, Jev might simply return a probability of 0.999.

The application can then act on that number. Route the ticket. Escalate it. Ask another model. Or do nothing.

Several questions about the same state can also be evaluated together rather than requiring a sequence of generated responses.

That difference is more important than it first appears.

The output is designed for machines rather than humans.

Probabilistic If-Statements

The easiest way to think about Jev may be as a probabilistic if-statement.

Traditional software works beautifully when rules can be defined precisely. If an invoice exceeds £10,000, require approval. If a customer is located in France, apply the relevant French rules. Computers are extraordinarily good at decisions like these.

Real organisations, however, contain thousands of decisions that are too ambiguous to express as conventional rules.

Is this customer angry? Does this message look suspicious? Is this request routine or complex? Does this document appear relevant? Would this tool action create meaningful risk?

Humans answer those questions intuitively. LLMs can answer them too, but often by producing language first and forcing software to extract the underlying decision afterwards.

Jev tries to place intelligence directly inside the conditional.

If the probability of risk exceeds a threshold, stop. If the probability of complexity rises above another threshold, route the task to a stronger model. If confidence is low, ask a human.

That makes the model less like a chatbot and more like a software primitive.

Why This Matters for Agents

Model routing is an obvious example.

An agent does not need the most powerful AI available for every problem. Some requests are simple lookups. Others involve document extraction. A smaller number require genuinely difficult reasoning.

A decision model can assess the task first and route it accordingly:

Simple → cheaper model

Complex → more powerful model

This matters because the cost difference between models can be enormous. The decision about which intelligence to use therefore becomes part of the economics of intelligence itself.

Safety provides another example. Before an agent executes a terminal command or uses a powerful tool, a decision model can inspect the proposed action and estimate whether it looks risky or insufficiently authorised.

LangChain has already built this idea into experimental middleware around Jev. A classifier can sit immediately before selected tool calls and block them when the estimated risk crosses a defined threshold.

This creates an interesting architecture:

A generative model proposes. A decision model evaluates. Software executes or blocks.

The expensive model doing the work no longer needs to police every decision it makes.

A different model can watch it.

The Economics Are Hard to Ignore

TypeSafe claims Jev can perform suitable decision workloads 40 to 200 times faster than comparable frontier-model calls, with latency generally between 70 and 500 milliseconds. It prices Jev at $0.042 per million input tokens, with no charge for outputs.

Those are vendor figures, and the comparison depends heavily on whether the workload genuinely suits a decision model. But independent evidence is beginning to appear as well.

Researchers recently tested Jev across 37 datasets and more than 346,000 requests spanning classification, routing, reasoning, moderation and other decision tasks. The entire experiment reportedly cost less than $10.

Jev performed strongly across many of those tasks, beating one 27-billion-parameter Qwen model on 27 of the 37 datasets tested and outperforming the comparison Gemma model across all 37. Its probability estimates were also generally useful for determining when the model was confident enough to act automatically.

It was not universally superior. Performance deteriorated on some low-resource languages, fine-grained categories, noisy labels and subjective rubric-based judgments. Some binary tasks also required threshold calibration for the probabilities to be useful operationally.

That nuance matters.

Jev is not some magically cheaper replacement for frontier AI.

It is specialised.

And specialisation is precisely the point.

Not a Smaller LLM

This is where Jev differs from the small-model story we discussed recently.

A small language model is still fundamentally a language model. It generates tokens.

Jev gives up that ability entirely. It cannot explain a business strategy, produce a legal memo or hold a conversation.

That constraint is deliberate.

TypeSafe's marketing claim that Jev "can't hallucinate" therefore needs careful interpretation. It cannot hallucinate in the familiar generative sense by inventing a paragraph outside its defined output schema.

It can still make the wrong decision.

A model asked whether a transaction is fraudulent can return a perfectly valid structured answer saying no and still be wrong.

The advantage is not infallibility. It is constraint.

The model operates inside a predefined decision space and tells the surrounding software how confident it is. That can make its errors easier to manage than free-form generation.

The Category Is Already Spreading

Perhaps the strongest evidence that the idea matters is what happened after Jev launched.

OpenAI introduced its own Decisions API, offering the same broad categories of bounded output: probabilities that statements are true, choices between predefined options and scores against a rubric.

OpenAI's implementation is technically different. It currently uses one of its existing models rather than a completely separate architecture like Jev.

Strategically, however, the distinction may matter less than the market behaviour.

Developers identified a missing primitive. Jev demonstrated demand for it. Competitors responded.

Vercel's data also suggests decision models are particularly common among companies operating the largest AI workloads. Among teams processing more than 10 billion tokens, roughly seven in ten reportedly used a decision model during October.

That makes intuitive sense.

If your application makes ten AI calls per day, efficiency barely matters.

If it makes ten million, architecture matters enormously.

System One and System Two

The terminology TypeSafe chose comes from the familiar distinction between two styles of human thinking, popularised by Daniel Kahneman in Thinking, Fast and Slow.

System One is fast, intuitive and automatic. System Two is slower, deliberate and analytical.

The analogy should not be taken too literally. AI models are not human cognitive systems.

But as an architectural metaphor, it is useful.

Imagine an agent where a powerful reasoning model handles genuinely difficult or unusual problems. Around it sit much faster decision models continuously making small judgments: route this, allow that, retry this, reject that, escalate this, use the cheap model here, use the powerful model there.

Most decisions happen cheaply and almost instantly. Expensive intelligence is called only when necessary.

That looks surprisingly similar to how efficient organisations work.

A CEO does not personally approve every invoice. A portfolio manager does not manually validate every market-data field. A surgeon does not personally perform every hospital triage decision.

Organisations develop layers of decision-making so that expensive expertise is concentrated where it creates the most value.

AI architecture may be heading in the same direction.

The Decision Layer

For years, we have treated the language model as the fundamental unit of AI.

Pick the best model. Connect it to your application. Ask it to do everything.

That may turn out to have been the early architecture.

The emerging stack looks more specialised.

A frontier model provides deep reasoning. A smaller model handles routine generation. A decision model routes requests and evaluates states. Retrieval provides knowledge. Memory provides continuity. Tools provide action. Guardrails constrain behaviour. Software orchestrates the whole system.

In that world, the important question becomes less:

Which AI model does your company use?

And increasingly:

How is intelligence distributed across the system?

Jev matters because it makes one previously hidden layer visible.

Software contains an extraordinary number of decisions that are too ambiguous for conventional rules but too small to justify repeatedly calling the most powerful AI available. Until now, we have often solved that problem by throwing an LLM at it anyway.

Decision models offer another option.

They do not replace language models. They make it possible to use language models less often.

That may sound like a small optimisation.

At agent scale, it could become an architectural shift.

Because the future of AI may not belong to one enormous model thinking about everything. It may belong to systems that know which kind of intelligence each decision actually needs.

Until next time,
Stay adaptive. Stay strategic.
And keep exploring the frontier of AI.

Fabio Lopes
XcessAI

💡Next week: I’m breaking down one of the most misunderstood AI shifts happening right now. Stay tuned. Subscribe above.

Read our previous episodes online!

Reply

Avatar

or to participate