Jev AI: the model that decides instead of writing, and Laya, its open-source alternative

In short: Jev and Laya in thirty seconds

Jev is an AI model from the Californian start-up TypeSafe AI, released on 15 September 2026. It writes nothing. You give it a piece of data, an email for instance, along with closed questions: “which team should handle this message?”, “is it urgent?”. It returns a probability for each possible answer.

That specialisation makes it very fast and very cheap. TypeSafe quotes response times of 70 to 500 milliseconds and a price of $0.042 per million tokens, with output free of charge.

• What Jev does well: sorting, classifying, scoring, checking. Repetitive, high-volume decisions your code can act on directly.
• What it does not do: writing, summarising, conversing. It is not a ChatGPT competitor; it is a different tool.
• What it is not: open source. Access is through an API hosted in the United States.

Laya, released three days later by Convai Innovations under the Apache 2.0 licence, takes up the same idea. You download the weights, install it on your own server, and your data stays put. The trade-off is real: it has to be trained on your own examples before it becomes reliable.

The rest of this article covers how both models work, what their figures actually show, and where they fit in a company’s systems.

---

What is Jev AI?

TypeSafe AI is a San Francisco company founded in 2024 by Diogo Almeida, a former OpenAI researcher who worked on ChatGPT, together with Erik Gafni and Sasha Sheng. After two years in stealth and a $40 million round led by DCVC, the company unveiled Jev on 15 September 2026. The model is in early access, through a waiting list.

Its starting point is an observation Diogo Almeida shared with TechCrunch: LLMs are remarkably capable, but they speak the language of people, whereas software needs answers it can process. When an application asks an LLM to classify a ticket, it gets back a sentence that then has to be parsed, with the risk that the answer falls outside the expected categories.

Jev turns the problem around. The answer is always one of the options you defined, together with its probability.

A name borrowed from an economist, a concept from a psychologist

Left, William Stanley Jevons (1835-1882), who gave Jev its name: unknown author, University of Manchester Libraries, CC BY-SA 4.0. Right, Daniel Kahneman (1934-2024), who popularised the System 1 / System 2 distinction: photo by nrkbeta, CC BY-SA 2.0. DPLIANCE composite under CC BY-SA 4.0.

The name pays tribute to William Stanley Jevons, the economist who observed in the nineteenth century that more efficient steam engines increased total coal consumption rather than reducing it. The nod is deliberate: if an automated decision costs almost nothing, far more of them will be made. The Register turned the argument around, asking whether this efficiency gain will genuinely reduce compute consumption.

The term “System One” comes from Daniel Kahneman’s book Thinking, Fast and Slow. The psychologist distinguishes two modes of thought: one fast and intuitive, the other slow and deliberate. LLMs, with their chains of reasoning, play the part of System 2. Jev claims System 1: the immediate judgement that settles a question without writing anything.

How Jev works: deciding instead of writing

An LLM generates its answer one token at a time. To write “this email is about billing”, it runs the model once per fragment of a word, each step depending on the previous one. This is called autoregressive generation, and it is what takes time.

Jev reads the data and all the questions in a single pass, in parallel. It has nothing to write: it computes a probability distribution over the options.

Same email, two approaches. DPLIANCE diagram.

Three practical consequences follow.

Speed. TypeSafe quotes response times of 70 to 500 milliseconds, where a frontier LLM often takes several seconds. In a demonstration where Jev plays Doom, it answers in 0.114 seconds against 8.566 seconds for GPT-5.6 Terra, according to The Register.

Output that always fits. Because Jev can only answer with the options supplied, it never produces an invented category or a broken format. TypeSafe describes a model that “cannot hallucinate”. The claim deserves a caveat: Jev can obviously pick the wrong option. What disappears is the out-of-bounds answer, not the error.

Probabilities that mean something. Jev is trained with a method TypeSafe calls RLCD, for Reinforcement Learning for Calibrated Decisions. The goal is calibration: when the model reports 90% confidence, it should be right roughly nine times out of ten. That is the most useful property in production, because it lets you set a threshold above which decisions are automated without review. The method itself is not published, and TypeSafe says Jev was trained exclusively on synthetic data. Nor is the exact architecture: according to TechCrunch, Jev may be built on an existing open-weight language model, retrained to decide rather than write.

A decision model, not a forecasting model

Jev returns probabilities, like a scoring or forecasting model. The two do different jobs all the same.

A forecasting model (payment default risk, future demand, a match result) learns from a numerical history of your business: it picks up statistical patterns to estimate what is likely to happen. Jev does not forecast anything. It reads a situation described in text and judges which option fits it best, much as a person reading the message would.

Reliability therefore depends on the problem. To anticipate a payment default from payment data, a model trained on your own history will do far better. To understand an email or spot an incomplete file, a conventional numerical model cannot even read the text: that is Jev’s ground.

How to use Jev: the API in practice

A Jev request holds two elements. The state is the data to be judged: a string, a JSON object or a list. The questions are the decisions you expect, each of a specific type.

The three question types and what the model returns. DPLIANCE diagram based on the TypeSafe documentation.

• Choice picks one option from a list you define, up to 255 options.
• Score places the data on an ordered scale: severity, priority, quality.
• Noul gives the probability that a statement is true, for instance “this message conveys urgency”.

Here is the example from the documentation, using the Python SDK (pip install typesafe-sdk, Python 3.10 or later):

from typesafe_sdk import Choice, Noul, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY
r = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={"billing": "Payment issues", "technical": "Bugs"},
        ),
        "is_urgent": Noul(instructions="The message conveys urgency"),
    },
)

r.answers["department"].choice   # "billing"
r.answers["is_urgent"].noul      # probability between 0 and 1

Each Choice or Score answer returns the selected option, the probability of every option and a confidence value between 0 and 1. A JavaScript SDK is also available (@typesafe-ai/sdk), and Jev is listed in the Cloudflare Workers AI catalogue.

The limits to know before writing a line of code

Parameter	Documented value
Model	jev-1.13.0 (alias jev-latest)
Context	64,000 tokens per request, of which 32,000 for the state plus the longest question
Inputs	Text only: no image, audio or video
Languages	English first; other languages “handled but not equally well”
Options per question	255 at most
Throughput	250,000 tokens per second, 1,200 requests per minute, adjusted to demand
Price	$0.042 per million input tokens, output free
Data	No training on your requests; zero data retention reserved for enterprise contracts

What a decision really costs

The price is easier to read with an example. Classifying one million emails of 500 tokens each comes to 500 million input tokens, or about $21. The same volume handled by a general-purpose LLM priced between $0.20 and $10 per million tokens, output excluded, costs between $100 and $5,000.

TypeSafe puts forward an average of 193 times faster and 444 times cheaper than reference LLMs across its own scenarios. The company itself acknowledges that those scenarios were designed by its team, measured from the US West Coast, and sit “on the higher end” of real-world gains. It also admits it cannot prove the price is not subsidised. These are figures to check against your own data, not to paste into a business plan.

Is Jev open source? No, and that is where Laya comes in

Jev is not open source. The weights are not published, nor is the exact architecture, and the service runs on TypeSafe’s servers. Searches for “Jev GitHub” or “Jev Hugging Face” lead to third-party projects, not to the model.

On 18 September 2026, three days after TypeSafe’s announcement, Convai Innovations released Laya, presented as an open alternative. The code is on GitHub and the weights on Hugging Face, all under the Apache 2.0 licence: commercial use permitted, modification unrestricted.

Laya does not copy Jev, whose weights are closed. It adopts the same interface contract, typed questions in and calibrated probabilities out, on a different technical base: bidirectional encoders from the BERT family, far smaller than an LLM. Its authors have worked on this approach since 2025 and described it in two research papers (arXiv:2503.23303, arXiv:2510.01237).

Three models, three uses

Model	Base	Parameters	Context	Intended use
laya	ModernBERT-large	421M	512 tokens	English: classification, email triage, guardrails
laya-multilingual	mmBERT-base	322M	1,024 tokens	More than 100 languages
laya-typed-decisions	ModernBERT-large	421M	1,024 tokens	Agent oversight, customer service, invoicing

Installation takes one command, pip install laya, and the interface deliberately mirrors Jev’s:

from laya import Router

router = Router(preload=True)  # loads the models into memory at start-up
state = {"from": "client@example.com", "subject": "Charged twice"}
questions = {
    "department": {
        "type": "choice",
        "instructions": "Which team should handle this message?",
        "criteria": {
            "billing": "invoices, payments, refunds",
            "technical": "bugs, access, outages",
        },
    }
}
result = router.predict(state, questions)
print(result["answers"]["department"]["choice"])

Laya runs on a single entry-level GPU, and even on CPU for modest volumes. The preload=True setting avoids a 7 to 10 second loading delay on the first request.

Jev versus Laya: reading the benchmarks honestly

Convai Innovations publishes a direct comparison with Jev. The figures flatter Laya; they call for a careful reading.

Latency and accuracy published by Convai Innovations. DPLIANCE chart based on the official Laya page and Flowtivity’s analysis.

The latency figures compare two different things. Laya’s 32.8 milliseconds are measured on a local GPU. Jev’s 236 to 276 milliseconds go through a remote API, network round trip included. The 7.8-fold gap is real for a European user calling a Californian server, but it measures distance as much as the model.

Laya’s typed-decisions accuracy comes from a model trained on that set. The 0.766 score belongs to a version fine-tuned on the benchmark’s training split. The base model, untrained, scores 0.362, below an answer that always picks the most frequent category (0.461). Laya is a base to specialise, not a ready-made model.

Beyond about twenty options, Jev pulls clearly ahead. On Banking77, which has 77 categories, Laya drops to 0.425 while Jev reaches 0.870. Laya’s authors themselves recommend staying under 20 options per question.

Laya’s calibration is tuned by hand. Its calibration error falls to 0.081 against 0.246 for Jev, but only after a per-question “temperature” adjustment. Out of the box it stands at 0.466: the model is overconfident.

In the end, each has its own ground. Jev works from the first call and handles long option lists. Laya is faster on your own hardware, free to run and fully auditable, provided you invest in training.

What about languages other than English?

For English-language workloads, both models are on home ground. For anything else, the answer is the same for both: they work, without it being their reference territory.

TypeSafe states that English is Jev’s primary language. Other languages are supported, with no guarantee of equivalent quality, and no per-language results are published.

On the Laya side, the English model breaks down as soon as the text leaves English. You need laya-multilingual, which scores well above chance on 45 of the 51 languages tested on the MASSIVE benchmark. Here too, no isolated score is published for any single language.

The practical consequence: before handing a French, Spanish or mixed-language flow to either model, build a sample of a few hundred real examples, labelled by hand, and measure. Half a day of work avoids months of silent bad decisions.

Where these models fit in a business

Jev and Laya do not replace an LLM. They take over the most voluminous and repetitive part of the work, the part where an LLM is expensive and slow for a simple decision.

The strongest use cases are those where the question is closed and the volume high:

• Sorting and routing messages. Sending each email or ticket to the right team, spotting urgency, detecting a data subject access request. We cover this in our guide to AI email triage.
• Guardrails for an AI agent. Checking at every step that an AI agent stays within scope, blocking an attempt to hijack it, deciding whether an action needs human sign-off. At a few milliseconds per check, you can place them everywhere.
• Filtering. Spam, phishing, off-topic content: Laya reports 0.993 accuracy on spam and 0.980 on phishing in its own tests.
• Routing between models. Deciding whether a request deserves an expensive LLM or whether a lighter model will do.
• Pre-qualification. Scoring the completeness of a file, the priority of a complaint, the validity of a supporting document before human review.

The architecture that works: the cascade

In production, we do not recommend handing every decision to a model of this kind. We recommend using it as the first filter.

The fast model handles most of the load; ambiguous cases move up a level. DPLIANCE diagram.

The principle rests on calibration. Above a confidence threshold set from your own data, the decision is applied automatically. Below it, the request goes to an LLM able to reason, or to a person. Corrections made on those ambiguous cases feed back into training and refine the threshold.

This architecture concentrates spending where it adds value, and it keeps a record of every decision with its probability, which supports the traceability the AI Act requires for some uses. It does, however, call for ongoing monitoring: data drift, regular recalibration, error tracking. That is the whole subject of MLOps.

Jev or Laya: how to choose

The decision depends less on raw performance than on three questions: where your data goes, how many categories your problem has, and who will maintain the system.

Your situation	Lean towards Jev	Lean towards Laya
You want a first result this week	✅ Works without training	⚠️ Fine-tuning required
More than 20 options per question	✅ 0.870 accuracy across 77 categories	⚠️ Accuracy drops sharply
Personal, health or legally privileged data	⚠️ Transfer to the US to be governed	✅ Nothing leaves your server
Very high, stable volumes	🟡 Very cheap, but billed per use	✅ Fixed server cost, whatever the volume
No in-house data team	✅ Managed service	⚠️ Training, calibration and hosting to handle
Need to audit or pin the model	⚠️ Closed model, versions managed by TypeSafe	✅ Open weights, pinned version, full audit
Text not in English	🟡 Supported, to be tested	🟡 Multilingual model, to be tested and trained

Two criteria deserve particular attention for a UK or European organisation.

The legal framework. Jev is hosted in the United States. TypeSafe offers a data processing agreement and commits not to train its model on your requests, but any personal data you send is still a transfer outside the UK and the EU, with the obligations that follow under UK GDPR and the EU GDPR. We cover the mechanics in our guide to GDPR-compliant AI. Laya, hosted on your own infrastructure or with a UK or European provider, removes the question.

Control over the model over time. With an API, the provider can change the model, its price or its terms. Jev itself briefly buckled under demand on launch day. With open weights, you pin a version, test it, and it does not move until you decide otherwise. That is the reasoning we develop in our article on local LLMs.

In practice, the two are not mutually exclusive. Prototyping on Jev to validate the taxonomy and measure the gain, then moving to a fine-tuned Laya once the need has settled, is often the shortest route to a system you control.

---

What we will not promise

“Jev is never wrong.” It never leaves the frame you set, which is not the same thing. It can pick the wrong option, and it will on part of your data. What matters is measuring that share and deciding what to do with uncertain cases.

“444 times cheaper, so worth it everywhere.” That figure comes from TypeSafe’s scenarios, on tasks chosen to show the model at its best. On your flow, the gain may be smaller. And a project’s cost lies mostly elsewhere: defining the categories, labelling examples, connecting the model to your tools, monitoring its accuracy.

“Laya is Jev for free.” Laya is free to run, not to set up. Without fine-tuning, on its own benchmark, it does worse than a naive rule that always answers the most frequent category. Training and operating time are part of the price.

“Everything should move to these models.” No. They excel at closed questions. As soon as you need to draft, summarise, extract free-form information or reason over several steps, an LLM remains the right tool. The value lies in combining them.

Both models are less than a week old. Their figures will be confirmed or corrected by independent testing in the coming months, and we will update this article accordingly.

DPLIANCE is an AI agency: we help organisations choose, integrate and run this kind of model in their processes. If you are wondering whether a decision model could take on part of your workflows, a scoping conversation lets you check it against your own data.

FAQ

What is Jev AI?

Jev is an artificial intelligence model from the American start-up TypeSafe AI, founded in 2024 by Diogo Almeida, a former OpenAI researcher. Released on 15 September 2026, it belongs to a category TypeSafe calls System One models: instead of generating text, it answers closed questions by returning a probability for each possible option. It is built to sort, classify, score or check data at very high speed, inside a piece of software.

Is Jev an LLM?

Not in the usual sense. TypeSafe does not publish its architecture, but Jev most likely rests on a language model retrained for a different task: instead of generating text, it picks among fixed options and returns a calibrated probability for each. It reads the data and the questions in a single pass, which makes it much faster and cheaper than an LLM. That is also its limit: it cannot draft, summarise or hold a conversation.

How much does Jev cost?

TypeSafe charges $0.042 per million input tokens, or $42 per billion. Output tokens are free. As an order of magnitude, classifying a million emails of 500 tokens each comes to 500 million tokens, roughly $21. The model is in early access: you have to join a waiting list to get an API key.

Is Jev open source?

No. Neither Jev’s weights nor its detailed architecture are published: the only access is through TypeSafe’s API, served from the US West Coast. There is no official Jev repository on GitHub or Hugging Face. The most advanced open alternative is Laya, published by Convai Innovations under the Apache 2.0 licence.

What is Laya?

Laya is a family of decision models released on 18 September 2026 by Convai Innovations under the Apache 2.0 licence. It follows Jev’s principle (typed questions in, probabilities out) using encoders of 322 to 421 million parameters, installable with pip and able to run on a single GPU. Its main limitation: without fine-tuning on your own data, its results stay close to chance.

Which languages does Jev support?

English is Jev’s primary language. TypeSafe’s documentation states that other languages, including CJK scripts, are handled but not equally well, and no per-language results are published. On the Laya side, the laya-multilingual model covers more than 100 languages, while the English model breaks down outside English. For any language other than English, test on a sample of your own data before going to production.

Should I choose Jev or Laya?

Jev suits teams that want to start quickly, without machine learning staff, and questions with many options: it holds 0.870 accuracy across 77 categories where Laya falls away. Laya suits cases where data must not leave your infrastructure, where volumes are high and stable, and where you can spend a few days on labelling and fine-tuning. Many projects benefit from prototyping on Jev, then moving to Laya once the need has settled.

Sources

• TypeSafe AI, Introducing System One Models & Jev, 15 September 2026
• TypeSafe AI, model documentation
• TechCrunch, A new kind of AI model from a ChatGPT inventor is thrilling developers, 18 September 2026
• The Register, TypeSafe AI debuts model for machines that plays Doom, 16 September 2026
• MarkTechPost, TypeSafe AI Releases Jev, 19 September 2026
• Convai Innovations, official Laya site, GitHub repository and models on Hugging Face
• Flowtivity, Laya: The Open-Source Jev Alternative, Benchmarked Honestly