Jev: most agent steps do not need an LLM

01. TypeSafe released a model for machines

TypeSafe released Jev on September 15 after two years in stealth. Its founder, Diogo Almeida, worked on the research behind ChatGPT. He started the company with a question: if chat models are so capable, why have they automated so little work?

His answer is that chat may be the wrong interface.

An LLM is trained to produce a useful response for a person. Jev is trained to return a decision that software can use directly. TypeSafe calls it a System One Model.

Almeida says Jev is 20 to 200 times faster and 40 to 400 times cheaper than language models on this kind of work. These are TypeSafe's early results, not independent benchmarks. But the mechanism behind them is worth understanding.

02. How Jev works

Suppose an application receives this support message:

state:    "I changed plans and my invoice doubled."
question: route_to
choices:  billing | technical | sales

An LLM generates a string one token at a time. Even in JSON mode, the application receives generated text and then parses and validates it.

Jev does not generate a string. The application defines the possible answers first. Jev scores them in parallel and returns a typed result with probabilities.

billing:   0.94
technical: 0.04
sales:     0.02

The application can route the ticket immediately. It can also ask for human review when the confidence is too low.

Language model	Jev
Generates text	Returns a typed decision
Samples tokens in sequence	Scores possible answers in parallel
Can produce an unexpected value	Must return one of the allowed values
Confidence is usually another generated claim	Probability is part of the result

Matija Šošić explains the distinction in this video. Jev behaves like a classifier, but it accepts unstructured text and does not need a new training run for every use case.

The same structure works for an agent controlling a browser or an operating system. The software defines an action map:

click(button_12)
scroll_down
go_back
ask_for_help
stop

Jev reads the current state and chooses among actions that exist. It does not spend time writing an explanation or inventing a command outside the map.

This is the promise: Luna-level judgment for a bounded question, without paying a general model to reason and write its way to the answer. TypeSafe reports response times between 70 and 500 milliseconds and a price of $0.042 per million input tokens.

Jev is not a replacement for Luna. It cannot take an open-ended goal, plan a project or write the code. It is useful once the software already knows the question and the possible actions.

03. What to do with Jev

The obvious use case is workflow automation. Route a request, classify a transaction, extract a field, score risk or decide whether something needs review.

Agents make the idea more interesting. A general model can plan the unfamiliar work while Jev handles frequent decisions around the plan:

• Is this action allowed?
• Did the page change as expected?
• Should the agent retry or stop?
• Does this result need human review?
• Did the agent complete the task or only claim that it did?

Rafal Wilinski used Jev in a massively parallel browser-testing system that tries to break each release. The browser sessions create the state. Jev judges whether each flow worked, recovered or needs investigation.

The price changes what is practical. You can run a decision after every click, tool call or state change. You can inspect thousands of agent traces instead of sampling a few. You can put intelligence into a latency-sensitive product without waiting several seconds for every answer.

04. Why it matters

We have been using one general model for everything because it was the only useful primitive available. It plans, writes, classifies, routes, checks and decides.

That is convenient, but expensive. It also gives the model freedom where the application needs a narrow answer.

I think the better split is simple. A general model handles goals, planning and unfamiliar work. Jev handles bounded decisions. Deterministic code executes the action, enforces permissions and records what happened.

Cheap decisions will not only reduce AI bills. We will add them to places where a model call never made economic sense. Every action can be checked. Every result can be scored. Low-confidence cases can go to a stronger model or a person.

There is one claim I would treat carefully. TypeSafe says Jev cannot hallucinate. Jev cannot return a value outside the schema, but it can still select the wrong valid answer. Type safety guarantees the shape of a decision, not its truth.

That does not weaken the main idea. Most software does not need another paragraph. It needs a decision it can afford to request and safely use.

Coda

Jev matters because it turns model intelligence into a component of software. The program defines the choices. The model handles ambiguity. Code remains responsible for the consequences.