Skip to content
Skjld Labs

Jev and System 1 models: the fast brain AI agents have been missing

TypeSafe has launched Jev, a “System 1 model” that makes fast, typed decisions instead of writing text, and LangChain shows how to use it as a router and guard in the agent harness. We tested the open alternative Laya locally. Here is what it is, how it can be used, and what we saw, including in Norwegian.

9 min read Laget med AI-hjelp
Jev and Laya: a «System 1» model making fast choices such as billing, refund and urgency, next to an LLM

Daniel Kahneman split our thinking in two. System 1 is fast, automatic and intuitive. System 2 is slow, deliberate and effortful. As a dermatologist I know the distinction well: much of a day at the clinic is fast pattern recognition, and the difficult cases get a full workup. Giving every single case a full workup would be both slow and expensive.

Yet that is exactly how most AI agents are built today. Every small decision along the way goes to a large language model: Is this urgent? Which department should take it? Is this tool call safe? That costs seconds and tokens, and the answer comes back as free text that has to be parsed. This month brought one of the clearest answers to that problem so far: Jev.

What is Jev?

Jev was launched by TypeSafe AI on 15 September, currently in early access. The company calls it a System One model. It is not a language model that writes text, but a model that takes state in and returns typed decisions with probabilities. TypeSafe describes it as “unstructured state in, typed probabilistic decisions out”.

You give Jev two things:

  • State: the text or data to evaluate, for example an email.
  • Questions of three types: choice (pick one of several options), score (place on an ordered scale) and noul (yes or no, expressed as a probability between 0 and 1).

All questions are answered in parallel in a single query, so one more question costs almost nothing. And because the model can only choose among the options you have defined, you never get an answer that doesn't fit the schema. It can of course pick the wrong option, but it cannot invent a new one.

The numbers TypeSafe reports are ambitious: up to roughly 200 times faster and 400 times cheaper than comparable language models on classification tasks, 70-500 milliseconds end-to-end, and $0.042 per million input tokens. Output tokens are free. These are the vendor's own measurements.

The harness: where Jev earns its keep

Two days after the launch, on 17 September, LangChain published a walkthrough of using Jev in a harness: everything that surrounds the model in an agent, such as the loop, the tools, the rules and the checkpoints. The starting point is sober. LangChain puts it plainly: “Agents are still inherently untrustworthy.”

The integration is called langchain-typesafe and ships two ready-made middleware layers:

  • Model routing (ModelRouterMiddleware). Jev assesses each request and picks the cheapest model that can do the job. A simple lookup doesn't need the same model as a hard debugging session.
  • Auto mode (AutoModeMiddleware). Jev checks the agent's tool calls and blocks risky ones before the tool executes. It is the same pattern coding assistants use when they ask for permission before dangerous commands.
from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])
agent = create_agent("openai:gpt-5.6-luna", middleware=[guardrail])

LangChain also highlights three early projects: browser agents at Browserbase running “for fractions of a cent”, a live trading agent, and email triage at scale. Their summary is a good one: use a language model for open-ended reasoning and generation, and Jev for the fast, structured decisions along the way.

Architecture sketch: a System 1 router chooses between a small and a large model, and a System 1 guard classifies the agent's tool call as allow, ask or block.
System 1 in the agent harness: routing before the model is chosen, guarding before the tool runs. The pattern follows LangChain's ModelRouterMiddleware and AutoModeMiddleware.

How can a Norwegian business use this?

TypeSafe describes typed outputs as fuzzy decision rules that slot straight into ordinary software: classify, route, score, extract or branch where hand-written logic is too brittle. For the businesses we work with most, such as accounting firms, law firms and clinics, I see four uses in particular:

  • Inbox triage. Which department should get the email? Is it urgent? Is the sender asking for something specific? Is it phishing?
  • Document flow. Is this an invoice, a receipt or a contract? Does it look like a duplicate? Does a human need to look at the discrepancy?
  • Routing between models. Send the simple cases to a small, fast model and the hard ones to a large one.
  • Guarding. Stop risky tool calls, and ask “does this contain personal data?” before anything is passed on to an external service.

The probabilities are what make this useful in practice. You can let the system act on its own when the model is confident, and send the rest to a human. But that requires the probabilities to actually mean something. I'll come back to that.

Laya: an open alternative we can run ourselves

Jev has one property that makes it hard for many Norwegian businesses: it is a closed API. The text to be evaluated has to be sent to TypeSafe. For a clinic or a law firm, that is a real limit on which data it can be used for.

That is why we got curious about Laya from ConvAI Innovations: an open System 1 model on Hugging Face with the same three question types, licensed under Apache 2.0. Laya is built on ModernBERT-large (395 million parameters) with its own decision head on top, 421 million in total. There is also a multilingual variant of 322 million parameters that is meant to cover more than 100 languages.

The principle is elegant. Each answer option gets its own [MASK] slot in the input. The model scores every option in one forward pass, and a softmax per question produces the probabilities. Training rewards honest probabilities: ConvAI uses what they call “Reinforcement Learning for Calibrated Decisions”, where the reward is a so-called proper scoring rule. That makes it pointless for the model to pretend it is more certain than it is.

We run Laya in our lab on an RTX 4090, through the local playground that ships with it.

Screenshot of Laya's local playground at 127.0.0.1:8000 on an NVIDIA GeForce RTX 4090, with numbered annotations.
Laya running locally in our lab. The text being evaluated never leaves the machine.

The playground example is an email about a double charge on an invoice, with a threat to cancel the plan. Four questions, one forward pass, 301 tokens in and zero tokens out:

Laya answers four questions about an email in one forward pass: billing 0.94, urgency 1.50 of 2, refund requested 0.81 and churn risk 0.78.
Actual output from convaiinnovations/laya on the playground example. No free text to parse, just types and probabilities.

Department: billing, with 94 percent probability. Refund requested: 0.81. Churn risk: 0.78. The urgency score lands between “soon” and “hard deadline”. These are answers ordinary code can use directly, without parsing free text.

How ConvAI measures Laya against Jev

The model card compares Laya directly with Jev. Laya leads on three of four tasks, answers in 33 milliseconds against Jev's 236-276, and has a calibration error (ECE) of 0.081 against 0.246. Three caveats matter, though. The figures are ConvAI's own. Jev wins clearly on Banking77 with 77 classes, because Laya gets too little room per option in its short context. And the 0.081 calibration applies after temperature scaling. Out of the box the model is overconfident, and ConvAI tells you to calibrate on your own data before trusting the probabilities.

Bar chart comparing Laya and Jev on accuracy, latency and calibration error, based on ConvAI's own figures.
Self-reported figures from the Laya model card. Not independently verified.

What we saw when we tested it ourselves

Benchmarks are not your working day, so we ran a few small smoke tests of our own. This is not a scientific evaluation, just a few dozen runs to see how the model behaves. But they told us a lot.

1. As a guard, it is triage, not a lock

We gave the English Laya model ten bash commands, five harmless and five risky, and asked whether each call should be allowed, sent to a human or blocked.

Stacked bars showing Laya's probability of allow, ask and block for ten bash commands. All risky ones were blocked, and so were two harmless ones.
Our smoke test with the English Laya model, zero-shot. One run per command. It shows behaviour, not a benchmark.

All five risky commands were blocked, including rm -rf on the backup directory and the attempt to copy a private SSH key off the machine. But the model also blocked cat README.md and pytest, and none of the harmless commands got more than 52 percent “allow”. The multilingual variant did worse: it let both the SSH key copy and curl … | sudo bash through.

The lesson is not that the idea is bad. The lesson is that an unadapted System 1 guard has to be used with thresholds: allow automatically only when the model is very confident, and send everything else to a human. Then you adapt the model on your own logs. ConvAI itself notes that the base checkpoints are near chance on this kind of typed workflow without adaptation.

2. Norwegian is not English

Next, we translated the example email into Norwegian: “Vennligst refunder det dobbelte beløpet i dag, ellers sier vi opp avtalen.”

Comparison of Laya on English and Norwegian text: churn risk drops from 0.78 to 0.08, and the multilingual model with Norwegian questions got seven of eight.
Norwegian needs its own testing. Small samples, so read the numbers as an indication.

Both the English and the multilingual model found the department and the refund request. But both missed the churn risk. For the English model, the probability dropped from 0.78 in English to 0.08 in Norwegian. The conditional threat, “or we will cancel”, went straight past it.

On eight short Norwegian messages, four with cancellation risk and four without, the multilingual model did best when we also asked the question in Norwegian: seven out of eight correct. The English model with Norwegian questions got only three out of eight. On top of that, the built-in language detector in the laya package (version 0.3.10) classified the Norwegian email as English, so the automatic router would have picked the wrong model. The model card also doesn't say whether Norwegian is among the 51 languages tested.

Where we go from here

We don't have a System 1 model in production. Laya runs in the lab, and the findings above are why it will stay there for a while. But the direction is clear to me. A large language model on our own servers is System 2: it reasons, plans and writes. In front of and around it we need a fast layer that picks the model, sorts the inbox and stands guard. That layer has to be able to run locally too, or we have only moved the privacy problem one step out instead of solving it.

The way there runs through the unglamorous work: a Norwegian test set built from real, anonymised cases, calibration of the probabilities, adaptation on our own data, and thresholds that send the doubtful cases to a human. Open weights mean all of this can be done on our own hardware in Norway.

In summary

  • Jev makes System 1 thinking available as an API: typed answers with probabilities, in milliseconds and at a fraction of the price of a language model.
  • The harness is where it adds the most value: routing between models and guarding tool calls.
  • Laya shows the same can be run openly and locally. In our tests, though, it needs Norwegian data, calibration and thresholds before it deserves trust.

Considering AI agents in your own business, and wondering how to make them faster, cheaper and safer without your data leaving the building? Book a no-obligation call, or read more about the AI systems and agents we build.

Sources: LangChain: Building a harness with Jev (17 September 2026), TypeSafe: Introducing System One Models & Jev (15 September 2026), the convaiinnovations/laya model card and laya on GitHub. Smoke tests run by Skjld Labs with laya 0.3.10. Graphics: Skjld Labs.

From article to practice

Want to put this to work?

AI agents for businesses. We build agents that take on recurring tasks in email, customer service, sales and finance, within limits we agree with you.

Read about AI agents for businesses Book a free call
Agents and automation

Read on.

Newsletter

AI in practice, one email a month.

What we've tested, one tip you can use, and what's coming next.

You'll get the Skjld Labs newsletter once a month, and can unsubscribe at any time. Privacy

First step

Thirty minutes. Free.

A no-obligation conversation about what you are facing. We will say so if AI is not the right answer. We are happy to meet you at Langes gate 8 in Sandefjord, or on video.