Jev could change the architecture of AI agents — and here is why
@andre_dataist
Large language models taught agents to reason, write code and build plans. But today we also make them take hundreds of small decisions: which tool to call, whether there is enough data, whether to keep going, whether an action is dangerous. Jev proposes moving decisions like these into a separate layer that is fast and cheap.
On 15 September TypeSafe AI released Jev — the first public model of a class the company calls System One Models. It is not meant for writing articles, dialogue or long chains of reasoning. Jev takes a description of a situation and returns a decision of a predefined type together with probabilities. TypeSafe describes it as «unstructured state in — typed probabilistic decisions out».
Large language model
- builds a plan
- reasons
- writes text and code
- handles an ambiguous task
Decision model
- picks an action
- scores risk
- routes a request
- decides «continue / stop»
The idea looks simple, but it hits a sore spot in today's AI agents. GPT or Claude often get called not because complex reasoning is needed, but because the program has to make one small judgement call. It is rather like a maths professor being asked, every single time, which button to press.
The large model can stay the agent's «brain». Jev is trying to take over its reflexes.
Jev does not write an answer — it chooses one
You pass Jev the current state: an email, a document, CRM data, the agent's history of actions, a fragment of a page or any other text context. After that you can ask several questions. They are all evaluated against the same state in parallel.
A single request can ask at once which agent is needed, whether the internet is required, whether there is enough context, whether there is any risk and whether a human has to step in. It is exactly this parallelism — plus not generating a long string — that gives the model its economics.
TypeSafe also says Jev is trained with RLCD — Reinforcement Learning for Calibrated Decisions: instead of a pretty answer, the model has to produce probabilities a program can actually use. The detailed training recipe and the model's internals have not been published, so claims about a «new architecture» cannot yet be reproduced independently.
In effect, this is a new kind of if
Until now a developer usually chose between a hard rule and a large language model. Jev adds a middle option: the condition stays part of the program, but becomes a judgement call.
Dependable, as long as the condition can be formalised.
That makes it possible to use AI not only when a human asks, but on every event inside the program: an email arrives — score it; the agent takes a step — check it; a new lead appears — tag it; a document changes — judge the risk.
The most obvious use is taking micro-decisions out of the large model
Inside a single complex request an agent decides dozens of times: which tool to call, whether to keep searching, whether to retry, whether the evidence is sufficient, whether the action can run automatically. Vercel already lists tool and sub-agent selection, continue-or-stop, risk checks and result checks among Jev's main use cases. According to Vercel, almost 13% of paying AI Gateway teams used Jev in the first 24 hours — a record for a new launch on the platform.
plan→ Jev
picks the next step→ tool→ Jev
check
1000 emails and seven decisions on each
Nate Herk's test shows the idea well. He ran 1000 emails through seven rules — urgency, spam, whether a reply is needed and other signals. Once parallelised, Jev processed the set in roughly 6 seconds and $0.09. In his comparison GPT-5.6 Luna needed about 5 minutes and $0.62 for a narrower check. This is one author's test, not an independent benchmark, but it captures the economics of small decisions at scale.
The same test points at another area: Jev can sit between a person and an information stream. Posts on X, messages, comments, meeting notes or video fragments get labels such as «important», «news», «strong moment», «needs a reply». The large model is only brought in for the small part of the stream where a reply or a conclusion is genuinely required.
A browser agent can run without a generative model at every step
TypeSafe has already shown an experimental browser agent in which Jev picks an operation from a closed set: click, type, select an element, scroll, wait or finish. The code itself reads the page structure and performs the chosen action. In the official playground, two of the browser scenarios need no generative model at all.
That changes the whole scheme of driving a computer: the strong model can build the overall plan once, while the fast decision model carries out dozens of local steps and hands control back only when it gets stuck.
Jev as a cheap supervisor for AI agents
Before a dangerous action you can ask: is it destructive, is it reversible, does it match the task, does it need human confirmation. After it runs — is the task actually finished, is there evidence of the result, did the tests pass, is a retry needed.
LangChain has already tested Jev as a judge for agent output. In a small experiment it took 0.44 seconds on average and cost about $0.00035 per evaluation, while its results were noticeably more stable than repeated evaluations by language models. The authors warn separately that there were few source scenarios, so this is a signal rather than proof of across-the-board superiority. Jev is now available as a judge in LangSmith Evals.
AI starts embedding itself directly into software infrastructure
One of the more unusual projects is the PostgreSQL extension pg-jev. It lets you filter and rank rows with a condition written in plain language — with no separate vector database and no pre-trained classifier.
A similar idea has appeared in Home Assistant: Jev turns the state of a home into virtual semantic sensors. Instead of only «door open» or «temperature 27°» you can get «the house looks empty», «the laundry seems to have been forgotten», «something unusual is going on». The HA-Jev integration publishes answers like these as ordinary sensors.
From a knowledge graph to a living model of state
If signals like these are recomputed continuously, the knowledge graph stops being a mere archive of facts. It starts holding the current semantic state of things as well.
last contact = 4 days ago
message history = 126
dissatisfaction = .92
needs a human = .88
Some values can be computed by ordinary code, others by SQL, others by Jev, and the hard conclusions by a large model. The agent's memory then becomes not just storage but a continuously updated model of the world.
AI guesses — code verifies
The TypeSafe playground has a Jev + Z3 experiment: the model quickly judges whether a set of constraints is contradictory, and a mathematical solver then gives the exact answer. It is a good general principle for dependable systems.
Jev might, for instance, give a high probability that an invoice is suspicious, and ordinary code then checks whether the IBAN changed, whether the supplier is new, whether the limit was exceeded. We are not making AI the source of truth — we are using it as cheap semantic intuition on top of strict rules.
The marketing claims are striking, the independent tests calmer
For its own production scenarios TypeSafe reports figures as high as 193.6 times faster and 444.6 times cheaper than language models, and notes itself that this is the upper bound of the expected gain. In an independent test by AY Automate on 791 labelled decisions the difference turned out to be far more modest — but still useful.
The test's conclusion is simple: Jev behaves more like a good small model than like a cheaper substitute for a strong one. It was roughly 2–3.6 times faster and 4.7–7.5 times cheaper than the cheapest small models in the comparison; against Terra it was 40–49 times cheaper on these tasks. The code and the raw results of the test have been published.
The strongest use is a cascade of models
Jev's real value shows up not when it replaces GPT, but when it decides whether GPT needs to be called at all.
In the independent AY Automate test, high-confidence requests stayed with Jev and the rest were passed to Terra. On the 8-class task this cascade reached 90.0% against 89.4% for Terra, while only 19.4% of requests went to Terra and the cost came to about 25.7% of the all-through-Terra option. The sample is small and the threshold was tuned on the same data, so this is not a production guarantee — but the principle itself is very strong.
Even a very confident model can be wrong. The automation threshold has to be calibrated on your own labelled examples, not picked as «0.9» by eye.
A practical recipe: collect at least a hundred typical examples with correct answers, run them through Jev and your current model, pick the threshold on a separate validation set, and send the contested cases to a stronger model or to a human.
Jev does not replace planning and hard reasoning
The official documentation lists the weak spots itself: long chains of logic, arithmetic, comparing dates, large amounts of irrelevant context, contradictory instructions and adversarial input. The model is text-only — it does not «see» images or video.
The chess experiment in the playground marks the boundary well: picking a plausible next move is not the same as calculating a combination many moves ahead.
Jev must not return a value outside the given schema: if only «sales / support / finance» are allowed, a fourth department will not appear. But the model can pick the wrong option with high confidence. A type-safe result and a correct decision are different things.
A separate class of decision models seems to be forming
Open alternatives appeared within days of the launch. The Laya project, for instance, uses similar choice, score and probability primitives and publishes its weights. Its authors show it running locally on small models and supporting many languages. The project's own numbers still need independent checking, but the fact matters more: Jev has already created a category.
A semantic processor
An ordinary classifier usually solves one predefined task — «spam / not spam», say. Jev lets you formulate a new semantic question while the program is running: is the customer unhappy, is the action dangerous, is the document needed, has the agent finished, which tool to choose.
Once a single judgement call becomes cheap enough, AI can be run not «when a human asks» but on practically every event inside the system.
That is why Jev is interesting not as yet another competitor to GPT. It may be showing the next stage of AI architecture: the large model no longer has to be brain, dispatcher, supervisor, classifier and judge all at once. It can do what it is genuinely needed for — hard reasoning. And the fast local decisions move into a layer of their own.
