For the past few years, the AI industry has largely followed a simple principle: bigger models mean better AI. Large Language Models (LLMs) have increasingly been used for everything from customer support and document retrieval to safety checks, browser automation and tool selection.
However, as AI agents move into production, a problem is becoming increasingly difficult to ignore: not every decision needs a large generative model.
If an agent simply needs to decide whether a support ticket is urgent, whether a document is relevant or which button to click next, using a frontier LLM can be slow, expensive and unnecessarily complex. This is where Jev, a decision model developed by TypeSafe AI, takes a different approach.
What is Jev?
Jev is designed around a simple idea: separate thinking from deciding.
Rather than generating natural-language responses, Jev takes an application’s current state and answers specific, structured questions. Its outputs are strongly typed and include probabilities and confidence scores that software can act on directly.
That makes Jev less like a chatbot and more like a decision-making layer within an AI system.
System 1 vs System 2
The approach is based on the familiar distinction between fast and deliberate thinking.
In an AI agent architecture, the roles can be separated:
- System 1 – Fast decisions: routing, classification, safety checks, gating and tool selection.
- System 2 – Deep reasoning: complex planning, synthesis, coding and long-form generation.
- Deterministic code – Execution: carrying out the approved action within defined rules and permissions.
The idea isn’t to replace generative AI. Instead, it is to use a large model where it adds value and a specialised decision model where a fast, predictable decision is all that is required.
Three simple decision primitives
Jev is built around three core primitives:
| Primitive | What it does | Example |
|---|---|---|
| Choice | Selects from predefined options | Is this ticket billing, technical or sales? |
| Score | Rates something against an ordered scale | How urgent is this issue? |
| Noul | Answers a yes/no question | Does this action require human approval? |
Each returns structured information that can be used directly by software.
This is an important distinction from asking an LLM to return JSON and hoping the response follows the requested schema.
Why calibrated confidence matters
One of the more interesting aspects of the approach is its focus on calibrated probabilities.
Jev is described as being trained using Reinforcement Learning for Calibrated Decisions (RLCD), with the goal of producing probabilities that correspond more closely to actual decision accuracy.
This creates the possibility of building straightforward decision thresholds into an application. For example:
- 95%+ confidence: execute automatically.
- 70–95%: send for human review.
- Below 70%: escalate to a more capable reasoning model.
The result is a more deliberate architecture where confidence can determine what happens next.
Where could this make a difference?
The potential applications are particularly interesting in high-volume agentic workflows.
Browser automation
Instead of repeatedly asking an LLM which browser element to interact with, a decision model can evaluate structured page information and select the next action.
The source material describes a browser automation experiment that completed a flight-booking workflow in 7.1 seconds at a reported cost of $0.0039.
Desktop automation
The same principle can be applied to computer-use systems.
OCR can convert a screen into structured information, while Jev determines which UI element should be interacted with next. The example provided reports a reduction in decision cost from $0.032 using Claude to $0.0002 using Jev, alongside a reduction in step latency from 5.2 seconds to 0.13 seconds.
Robotics
The approach can also be applied to autonomous systems.
In the drone example, deterministic flight controls operate at high frequency while computer vision and Jev handle progressively higher-level decisions. Safety logic remains capable of overriding the model when predefined limits are breached.
Document classification
Another example involves processing large volumes of research papers.
The source describes a pipeline that classified 1,018 scientific papers using Jev’s parallel decision primitives, reporting a total API cost of $0.08 compared with an estimated $15–$30 using traditional LLM-based processing.
Jev vs traditional LLMs
The distinction can be summarised simply:
| Generative LLM | Jev Decision Model | |
|---|---|---|
| Output | Natural language / generated JSON | Typed decisions |
| Primary role | Reasoning and generation | Fast decisions |
| Typical use | Writing, coding, synthesis | Routing, classification, gating |
| Output confidence | Not inherently calibrated | Calibrated probabilities |
| Execution | Usually requires parsing/validation | Designed for direct programmatic use |
The two approaches therefore aren’t necessarily competitors.
They can form different layers of the same AI system.
What this means for AI agents
This is arguably the bigger architectural idea behind Jev.
Today’s AI agents can often rely too heavily on a single large model to perform multiple jobs: understand the situation, decide what to do, select a tool, check whether the action is safe and then generate the response.
A more modular architecture separates those responsibilities:
- Fast decision models handle frequent micro-decisions.
- Generative models handle complex reasoning and synthesis.
- Deterministic software controls execution, permissions and auditability.
That could become increasingly important as organisations move AI agents from demonstrations into production environments, where latency, cost, reliability and control matter just as much as model intelligence.
The bigger picture
The next stage of AI may not simply be about putting a larger model behind every decision; i may be about using the right model for the right job.
An LLM is extremely powerful when an application needs reasoning, synthesis or language generation. But asking a large generative model to repeatedly answer simple, structured questions can introduce unnecessary latency and cost.
Decision models such as Jev offer another architectural option: fast, typed and confidence-aware decisions sitting alongside more capable generative models.
For developers building production AI agents, that shift towards specialised AI components could be just as important as the next generation of larger models.
Ready to Build Next-Generation AI Agents?
Moving beyond slow, expensive LLM loops requires practical experience with modern, multi-layered AI architectures. If your engineering team is ready to build faster, more reliable AI agents using the System 1 and System 2 approach, let’s get building.
Join us for an immersive, practical workshop for technical leaders and developers. We’ll explore how to implement decision models like Jev, optimise your agentic architecture and reduce unnecessary API costs. Book Your Workshop Today.
Discover more from AI Ireland
Subscribe to get the latest posts sent to your email.
