Watch a production AI agent run and you'll notice something. Most of its steps aren't writing anything. They're decisions: route this ticket, classify this document, is this input safe, which tool do I call, should a human see this?

We've been handling those micro-decisions with large text-generation models, paying the latency, token cost, and parsing overhead every time. Sometimes we also get a hallucinated tool name that doesn't exist.

A new model called Jev takes a different approach, and I think it's worth understanding if you build agents.

Part 1: What Is Jev?

Jev is a probabilistic decision model developed by TypeSafe AI, designed for situations where software needs AI intelligence but does not actually need a paragraph of generated text. It entered early access in mid-September, and its founder, Diogo Almeida, came from OpenAI.

TypeSafe calls it a "System One" model. The name borrows Daniel Kahneman's distinction between fast, intuitive System 1 thinking and slower, deliberate System 2 reasoning.

The mental model is simple:

  • Frontier LLMs (Claude, GPT, etc.) are System Two. They reason slowly and deliberately, and they write.
  • Jev is System One. It makes fast, intuitive judgments and returns a decision.

This makes Jev less like a chatbot and more like an AI-powered decision function for software.

Part 2: Inputs, and Why It's Fast and Accurate

What goes in

Every Jev call has two parts:

  • State: the context you want judged. That can be an email, a log line, a support ticket, or a JSON blob.
  • Questions: the typed questions you want answered about that state.

There are three question types:

  • Choice: pick from a set of options, returning a probability for each option and an overall confidence score.
  • Score: rate an input against ordered levels such as low, medium, and high, returning a continuous score, the underlying distribution, and a confidence value.
  • Noul (yes/no): answer a yes-or-no question, returning the probability that a statement is true.

A simplified request looks like this:

``` state: "Deploy failed twice, customers seeing 500s. Need help now." questions: is_urgent -> yes/no team -> choice: [infra, backend, frontend, billing] severity -> score: [low, medium, high, critical] ```

Why it's fast

A normal LLM produces its answer token by token, sequentially. Jev doesn't generate text at all, so that bottleneck disappears.

It also handles multiple questions efficiently. System One models evaluate every question in a request in parallel, so adding questions barely changes response time and only costs the tokens for the extra questions.

The vendor's numbers are notable: 40 to 200 times faster than frontier LLMs on comparable tasks, at roughly $0.042 per million input tokens with free output.

Why it's accurate, and reliable in a different way

Two design choices matter here.

Calibrated training. Jev is trained using reinforcement learning for calibrated decisions (RLCD). The aim is for the probabilities to mean something. If Jev says 0.9, it should be right about 90% of the time.

A bounded answer space. You define the possible answers, so Jev can't invent a new one. When a text model answers "which tool should I call," it can invent a tool that doesn't exist, because it's generating tokens and any token is fair game. Jev can only choose among options you supplied.

On raw accuracy, keep expectations measured. Early analysis puts Jev roughly where mid-tier frontier LLMs are on accuracy, while beating them on cost and latency by one to two orders of magnitude. These are vendor-reported numbers, and no large-scale independent reproduction has surfaced yet.

Part 3: What Comes Out

Jev returns typed decisions with probabilities. It doesn't write a paragraph explaining itself; it returns the decision and how confident it is.

For the example above, the output would look roughly like:

``` is_urgent -> 0.99 team -> infra: 0.82, backend: 0.14, frontend: 0.03, billing: 0.01 severity -> high (confidence: 0.87) ```

This matters because your code can act on it directly. There's no regex parsing, no "please respond in valid JSON" retries, and no drift between what the model wrote and what your control flow expects.

It also lets you branch on confidence:

  • Confidence above your threshold: act automatically
  • Confidence in the gray zone: escalate to a bigger reasoning model
  • Low confidence on a high-stakes action: route to a human

That confidence signal is arguably Jev's most useful feature.

Part 4: Why It Matters for Coding Agents and Agentic Workflows

Jev is not a replacement for Claude or GPT. It's a complement to the model driving your agent: use an LLM for open-ended reasoning and generation, and Jev for fast, structured decisions along the way.

Here's where it fits.

1. Model routing. A simple file lookup doesn't need the same model as an architectural refactor. Jev can assess a request and choose a model based on criteria you define: fast and inexpensive for straightforward tasks, more capable for complex ones. Across thousands of agent runs, that's a large cost saving.

2. Tool-risk gating ("Auto Mode" for any agent). This is the use case I find most interesting. Coding harnesses like Claude Code, Codex, and Cursor have shipped ways to classify dangerous actions before they're taken, but that classifier step has been locked away in the closed-source parts of those harnesses. With a cheap, fast classifier available, any team can add a pre-execution check. For example: is this bash command destructive? Does this touch production?

3. Triage and classification at scale. Support tickets, incident alerts, invoices, email. TypeSafe's own evaluation covered security incident response, agent-trace observability, invoice processing, and customer service. These are high-volume decisions that currently eat frontier-model budget.

4. Guardrails and verification. Is this input a prompt injection? Does this output meet the acceptance criteria? Should this PR get human review? Each of these can be a yes/no check with a probability, run inline without slowing the loop.

5. Escalation logic. TypeSafe's build guidance says to keep deterministic work in code, ask narrow atomic questions, send only relevant state, and route uncertainty to a person or a more expensive reasoning model. That's a solid architecture for agents in general.

A Word of Caution

Two things to keep in mind before wiring Jev into production.

Decisions are not permissions. Jev can supply a routing decision, but your code determines whether to act on it. Keep authority, validation, and side effects in your application layer.

Typed is not deterministic. The interface is typed, but the judgment remains probabilistic. Build an eval set for your specific decisions, test against your own data, and don't trust launch benchmarks alone.

The Bigger Picture

For the past few years, the default has been to use one large model for everything because one interface was convenient. Jev challenges that. The agent architecture I expect to see more of looks like this:

System Two (LLM) for thinking and writing. System One (Jev-style models) for fast decisions. Deterministic code for everything else.

That combination is faster, cheaper, and easier to inspect. If you're building agents in production, find your highest-volume internal decision, run it through a System One model alongside your current setup, and compare the results.

Are you building agentic workflows? Which decision in your pipeline would you offload first? I'd like to hear about it.