Jev: Why System 1 Matters for Reliable AI

We spent the last few years teaching AI to think. Now we need to teach it to decide.

About 18 months ago, I wrote about the idea that AI might start to resemble human thinking more than we expected. At the time, the exciting development was System 2 thinking: models that slow down, reason through a problem, reconsider intermediate steps and arrive at a better answer. Since then, reasoning models have become dramatically better.

But while building real software and agentic systems, I've become increasingly interested in the other side of the equation: System 1. I think we may have underestimated how important it is.

Most of an Agent's Work Is Small Decisions

A surprisingly large part of intelligent software isn't deep reasoning at all. It's lots and lots of small decisions. Is this information relevant? Does this evidence support the claim? Which route should this workflow take? Is this result good enough to continue? Should the agent retry, escalate, or ask for more context?

An agent may make hundreds of decisions like these while completing a single task. Using a large reasoning model for every one of them starts to feel a bit like asking someone to write an essay every time your software needs an if statement. Those decisions often need to happen constantly, quickly and reliably, and this is where simply calling a full LLM for everything starts to look like the wrong abstraction.

A general-purpose reasoning model is extremely powerful, but it also has a huge freedom of action. For a narrow decision, that flexibility isn't always an advantage. System 1 models are designed for a much more constrained job: make a specific judgment, stay inside a known decision space, and expose uncertainty around the result. That can make them more predictable and more reliable for exactly these kinds of decisions.

The fact that they are also much faster and cheaper matters enormously, because software may need to make hundreds or thousands of these judgments continuously. So the appeal of System 1 isn't simply efficiency. It's the combination of reliability, speed, cost and explicit uncertainty for decisions that don't need open-ended reasoning in the first place.

Enter Jev

We recently started working with Jev, TypeSafe's System One Model. What makes Jev interesting is that it isn't designed to write text or reason broadly. It is designed to make a specific decision well.

You define the decision the software needs (a yes or no, a choice between a number of options, or a score) and Jev returns a structured answer together with its probability and confidence. That gives software something quite different from a normal LLM response: a decision it can directly act on, together with an indication of how certain that decision is.

So rather than treating AI output as simply right or wrong, the surrounding system can decide what to do next. With high confidence, it continues. When it's not sure, it gathers more information. With low confidence, it falls back on deeper reasoning or involves a human. That feels like a very natural building block for agentic software.

And because Jev can make those decisions much faster and more cheaply than a full reasoning call, you can use that decision-making capability continuously without bogging down the application or making every workflow overly expensive.

“The goal isn't to use less intelligence.
It's to use the right kind of intelligence for each decision.”

System 2 → reasonSystem 1 → decide

We Integrated It into Core Almost Immediately

We made Jev available inside BlueCube Core, where agents can use it as part of their workflows. The same capability can also be used by external applications through the API or MCP.

That makes System 1 useful almost anywhere software needs a quick, robust judgment: classification, routing, scoring, relevance checks, guardrails, evidence verification, workflow decisions, and all the small choices between the bigger reasoning steps.

A Natural Fit for Knowledge-Grounded Agents

Diagram of System 1 and System 2 working together: a knowledge graph to navigate, a vector store to retrieve evidence, System 2 to reason, Jev as System 1 to verify claims against the evidence, and a final decision to continue, retrieve more evidence or escalate

We're experimenting with this in our knowledge architecture, where the underlying information exists in two complementary forms. A knowledge graph gives the agent a connected view of the domain. The agent first finds the relevant area through vector search and then traverses relationships to understand the surrounding concepts, rules and business context. The knowledge base, or vector store, then provides the original source material that can substantiate the answer.

A reasoning model can use that context and evidence to formulate the answer. Jev can then help verify whether the claims made in that answer are actually supported by the evidence. So the architecture starts to look like this:

Knowledge graph → understand
Vector store → substantiate
System 2 → reason
System 1 → verify and decide

Or even simpler: Navigate → Retrieve → Reason → Verify → Decide.

A Practical Example

To see how this works in practice, we loaded the European regulation on air passenger rights and the related court material into a knowledge graph, and loaded the legal text itself into the knowledge base. The goal is to help answer questions from travelers about their rights when their flight is delayed, cancelled or disrupted in some other way. We built the entire knowledge graph, the agent and the Jev integration in a couple of hours using BlueCube Core.

BlueCube Core graph view of the Rights of European flight passengers knowledge base, with the guide Delay of a flight linked to related concepts, court cases and regulation articles

When a traveler asks a question, the agent first uses the knowledge graph to find the relevant part of the domain and follows the links to the rules, concepts and court cases that apply to the situation. It then retrieves the exact articles of Regulation 261/2004 from the knowledge base as evidence. With that context and evidence, a reasoning model drafts the answer and supports each claim with a reference to the legal text or the case law.

BlueCube Core chat in which the agent answers a question about a delayed connecting flight, after ten tool calls to the knowledge graph and the knowledge base, with a short answer that cites Article 5(3), Article 7(1)(b) and the Sturgeon cases

Before that answer goes out, Jev checks it. Each reference in the draft becomes a small yes or no question: does this quoted text really state the claim it is used to support, with the same meaning, amount, distance, time limit or condition? Jev returns a probability for each one, here between 0.92 and 0.97, and also checks whether the conclusion follows from the supported claims and the facts. A reference that fails the check does not make it into the answer, so the traveler only gets claims that the legal text actually supports.

Details of the Jev verification step, with a request that asks per reference whether the quote states the claim, and a response with a probability for each reference between 0.92 and 0.97

Maybe Reliable AI Needs Both

For the last few years, much of the AI world has focused on making models better at reasoning, and rightly so. But I increasingly think reliable agentic systems will depend just as much on the intelligence happening between those reasoning steps. Not every decision needs deep thought. In fact, most probably don't.

Perhaps the future isn't one giant model doing everything. Perhaps it is a combination of different kinds of intelligence, each used where it is strongest: System 2 when we need open-ended reasoning, and System 1 when we need fast, constrained and reliable decisions.

And the most reliable AI systems may simply be the ones that know the difference.