Jev Is an AI Model That Makes Decisions, Not Text

On September 15, 2026, TypeSafe AI announced Jev, a new AI model for making structured decisions.

I first saw it in a post from TypeSafe founder Diogo Almeida. The numbers immediately caught my attention:

• nearly 200x faster
• more than 400x cheaper
• $42 per billion input tokens
• free output tokens

Those are vendor claims, and big ones.

My first thought was that this was another small, fast LLM competing with models from OpenAI, Anthropic, Google, and others.

But Jev is not a drop-in LLM competitor. It is not built to generate free-form text.

And I think that is the important part.

Traditional language models generate text sequentially. Jev returns bounded, typed decisions that software can use directly.

Jev does not talk

Most general-purpose AI assistants we use today are built around text generation.

You give ChatGPT, Claude, Gemini, or another model some input, and the model generates tokens one after another.

Even when we use these models inside software, we are still asking them to generate something.

For example:

User request
    ↓
LLM
    ↓
"category": "billing"

Then our application needs to parse that response, validate it, and decide what to do next.

Jev approaches the problem differently.

You define the possible decisions first.

Something closer to:

State:
Customer says they were charged twice.

Question:
What type of request is this?

Options:
- billing
- technical
- account
- other

Jev does not write an explanation.

Instead, it returns a typed decision. For a Choice question, the response includes the selected option, a probability distribution across every option, and a confidence score derived from that distribution.

Conceptually, it is closer to:

billing: 0.96
technical: 0.01
account: 0.01
other: 0.02

Your code can immediately do something with that result.

That difference sounds small.

I don’t think it is.

Think of Jev as an intelligent if statement

Normal software is already very good at making decisions when the rules are clear.

if (total > 100) {
  applyDiscount();
}

The problem starts when the decision requires understanding meaning.

if (customerSoundsAngry) {
  escalateToHuman();
}

What exactly is customerSoundsAngry?

This is where we normally reach for an LLM.

But using a large reasoning model for every tiny decision can be expensive and slow.

Jev seems designed specifically for this gap.

Instead of asking a general-purpose model to generate a judgment, format it as JSON, and return it to the application, Jev provides the structured result directly.

State in. Decision out.

That makes it less like ChatGPT and more like an AI primitive that you put inside normal code.

TypeSafe calls this a “System One Model”

TypeSafe calls Jev the first public System One Model.

The name comes from the System 1 and System 2 distinction popularized by Daniel Kahneman’s Thinking, Fast and Slow. System 1 represents fast judgments; System 2 represents slower, more deliberate reasoning.

Modern reasoning models are moving heavily toward the second category: give the model a difficult problem, let it reason and use tools, give it more compute, then wait for the answer.

Jev goes in almost the opposite direction. It gives up arbitrary text generation in exchange for fast, structured decisions.

TypeSafe says it trained Jev with a new method called Reinforcement Learning for Calibrated Decisions, or RLCD. The goal is not to produce answers humans like reading, but to produce probabilities useful enough for software to act on.

That enables a pattern like this:

confidence > 0.95
→ continue automatically

confidence 0.70–0.95
→ run another check

confidence < 0.70
→ ask a human

Those thresholds are only illustrative. TypeSafe recommends choosing them based on the consequences of a mistake, then testing them against your own data.

That is a very different relationship between AI and software.

And this explains the crazy price

TypeSafe lists Jev at $0.042 per million input tokens, or $42 per billion. Output is free.

The company’s published workflow evaluations report speedups approaching 200x and cost reductions above 400x on some System One workloads.

I would be careful with those numbers for now. Jev launched on September 15, and these are TypeSafe’s own evaluations rather than independent benchmarks. TypeSafe also says the largest gains are probably at the high end of what real workloads will see—and that it cannot yet prove the listed price is not subsidized.

Still, avoiding autoregressive prose and evaluating multiple questions in parallel gives Jev less work to do for this narrow class of problem. That makes the direction of the latency and cost claims plausible, even if the exact numbers remain unverified.

Jev does not need to generate a paragraph like this:

Based on the information provided, I believe this
customer request should be classified as billing
because the customer mentioned...

when the application only needs:

billing

More importantly, TypeSafe says in its announcement that Jev samples its structured outputs in parallel rather than generating them token by token. Its documentation also says every question in a request is evaluated independently and in parallel against the same state.

When you imagine millions of tiny AI decisions running inside an application, those differences start becoming important.

I immediately thought about coding agents

This is where Jev became especially interesting to me.

I use coding agents heavily.

A coding agent makes a surprising number of small decisions.

Should I run this command?

Is this operation dangerous?

Which model should handle this task?

Does this code need another review?

Should I continue or ask the user?

Is this change risky?

Today we often use the main LLM to make those decisions.

That feels wasteful.

Imagine using a strong reasoning model to implement a feature while Jev handles small decisions around it.

                    ┌── Jev → safe?
Agent → tool call ──┤
                    └── yes → execute

Or model routing:

User task
    ↓
   Jev
  /   \
simple  complex
  ↓       ↓
fast     strong
model    model

Developers are already experimenting with exactly this.

There is a Claude Code router that uses Jev to choose a model tier for each turn. Clean Code Review uses it to evaluate files against a fixed set of code-quality questions. LangChain has also published middleware examples for model routing and tool-risk gating.

And there is an experimental Pi extension that classifies the risk of bash, write, and edit calls. It warns by default, can ask for confirmation in enforce mode, and fails open if Jev is unavailable.

These projects appeared within days of Jev’s launch. That pace is probably the part I find most interesting.

It could become the cheap model beside the expensive model

For some time, I have liked setups with more than one model.

You don’t need your most capable and expensive model for everything.

A coding agent might use a strong model for implementation while a cheaper model handles simpler tasks.

Jev pushes this idea much further.

Instead of:

Strong LLM
   +
Cheap LLM

we could have:

Reasoning model
      +
Decision model
      +
Normal code

Each component does what it is good at.

The expensive model thinks.

Jev makes fast judgments.

Code controls the workflow.

That architecture is much more interesting to me than trying to make one huge model responsible for everything.

But “zero hallucinations” needs some explanation

TypeSafe says Jev cannot hallucinate. The narrower, verifiable guarantee in its announcement is that Jev cannot produce a type error or return a value outside the schema.

It cannot suddenly return:

category: "banana"

when banana was never one of the available options. It also cannot decide to write three paragraphs instead of returning the expected type.

But that does not mean Jev cannot be wrong.

If the choices are:

safe
dangerous

Jev can still classify a dangerous operation as safe.

The difference is that it cannot invent an answer outside the defined structure.

For production software, that constraint is still valuable. But I would describe Jev as schema-safe, not incapable of making incorrect decisions.

Jev also has a very obvious limitation

Jev is not trained for free-form generation. TypeSafe says you could force it to produce text by chaining choices, but the result would be poor and slow. If you need code, an article, an explanation, a conversation, or deep reasoning, it is the wrong model.

There are other limits too. TypeSafe’s own model notes warn that Jev 1.13 struggles with counting, numerical precision, date comparisons, indirection, irrelevant context, and adversarial input. Their advice is refreshingly conventional: keep exact computation in code and use the model only for the judgment.

But that is exactly why I find it interesting.

For the last few years, AI development has mostly been about making LLMs capable of doing more things.

Bigger context.

More reasoning.

More tools.

More modalities.

More autonomy.

Jev asks a different question:

What if we make an AI model that does fewer things, but does those things extremely efficiently?

That feels surprisingly aligned with normal software engineering.

I want to test this with my own coding-agent workflow

This is still a first impression, not a hands-on review. Most of what we know about Jev comes from TypeSafe’s announcement, documentation, and very early developer experiments.

So I am not ready to say whether it will actually change how we build AI applications.

But I already have several things I want to try.

Model routing is probably the obvious one.

Permission handling for coding agents is another.

And because I use Pi, the new Jev-based auto-mode extension immediately caught my attention.

I am especially curious whether putting Jev around a powerful coding model can reduce the number of expensive model calls without making the agent feel slower or less capable.

That is probably where my next experiment starts.

The bigger idea is more interesting than Jev itself

Maybe Jev succeeds.

Maybe another model eventually does this better.

It is too early to know.

But I think the idea behind it matters.

We have spent years putting LLMs everywhere.

Maybe not every intelligent operation inside software needs an LLM.

Sometimes we don’t need AI to write.

We just need AI to decide.

And if those decisions can really be made in milliseconds for almost nothing, AI agents could start looking quite different.