Laya vs Jev: The AI Models That Never Write a Word

Count what your AI agent actually does in a typical run: read a ticket, set a priority, pick a route, decide whether a tool call should be allowed. Each of these judgments is far too small to justify a frontier model — yet the most common implementation today is still one LLM call followed by a regex that scrapes "billing" or "true" out of the returned prose. Slow (hundreds to thousands of milliseconds), costly, and fragile the moment the model decides to be chatty.

Mid-September brought two new answers to this old problem. On September 15, San Francisco startup TypeSafe AI released Jev — a model that generates no text at all and returns only structured judgments with probabilities. Three days later, on September 18, the open-source community responded in kind: Laya, published by Convai Innovations under Apache 2.0 with weights on Hugging Face. Seventy-two hours apart, one closed and paid, one open and free — and a category that until recently existed only in papers (non-autoregressive decision models) suddenly became a real market.

This article takes both apart: what a "System One model" actually is, how the three primitives work, how Laya gets roughly 8x faster than Jev, and the failure modes neither marketing page will tell you about but that only show up when you read the repo and the docs.

System One: A New Row in the Taxonomy

The name borrows from Kahneman's Thinking, Fast and Slow: System 1 is fast, intuitive pattern-matching; System 2 is slow, deliberate reasoning. TypeSafe's definition: a model that reads a state and returns typed answers with probabilities that software can consume directly — not prose for humans.

The split is entirely on the output side. LLMs and decision models read natural language about equally well, but an LLM generates text token by token — structure can only be coaxed via prompts and constrained via structured outputs, and correctness is never guaranteed. A System One model's answer space is defined before the request is sent (one option, one score, one probability), so the model structurally cannot return anything outside the schema. It doesn't hallucinate a paragraph; it misclassifies with a confidence attached — and a misclassification with a threshold is something your code can gate on.

A naming aside: Jev is named after the 19th-century economist William Stanley Jevons, of Jevons paradox fame — efficiency gains in resource use expand consumption. CEO Diogo Almeida's reading: cheaper machine intelligence will lead to far wider deployment. Almeida spent roughly four years at OpenAI working on RLHF, InstructGPT, ChatGPT and GPT-4 before leaving in 2024.

Three Primitives: choice, score, noul

Both models share nearly the same request shape: a block of state (string, JSON, or array of text) plus a set of typed questions, all evaluated in parallel in a single round trip. Every question is one of three primitives:

Primitive	Purpose	Returns
choice	Pick one from a predefined set (up to 255 options on Jev)	Selected option + per-option probabilities + confidence
score	Rate on an ordered 2–10 level scale	Score (can land between levels) + distribution + confidence
noul	Boolean judgment	A probability between 0 and 1

In Laya's routed mode it looks like this (example adapted from the official repo):

import laya
from laya import Router

router = Router(preload=True)

questions = {
    "department": {"type": "choice", "instructions": "Which department should handle this?",
        "criteria": {"billing": "invoices, payments, refunds",
                     "technical": "bugs, outages, system errors",
                     "sales": "pricing, new contracts",
                     "other": "everything else"}},
    "urgency":  {"type": "score", "instructions": "How urgent is this?",
        "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]},
    "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel?"},
}

res = router.predict({"subject": "Duplicate charge on invoice #4411", "body": "..."}, questions)
print(res["answers"]["department"]["choice"])   # -> billing (confidence: 0.94)

Seasoned engineers will recognize this instantly — it's classification/regression/binary-classification wearing a natural-language skin. The real change is economic: previously this meant either brittle if-else trees or waiting two seconds for a $0.02 LLM call. LangChain already ships a TypeSafeClassifier integration for Jev; Laya provides LangChain, LangGraph and MCP adapters. Both treat "embedding into the agent loop" as the primary use case — a natural complement to the worker-designs-nothing division of labor in Anthropic's multi-agent orchestration patterns.

Jev: Fast by Architecture, Closed by Design

There is a conspicuous blank in Jev's public footprint: no paper, no weights, no architecture details. TypeSafe says only that it's transformer-based, trained exclusively on synthetic data, using RLCD — Reinforcement Learning for Calibrated Decisions, where probabilities are optimized against outcomes rather than human rater preference. Outside observers suspect an open-weight LLM underneath; nobody can verify.

What you can verify is the interface and the bill: Jev 1.13 has a 64k-token context, costs $0.042 per million input tokens with output free, quotes 70–500ms end-to-end, and allows 1,200 requests per minute. Per OpenRouter's measurement, a typical three-question call uses ~450 tokens — about two thousandths of a cent. TypeSafe claims 40–200x faster and 40–400x cheaper than frontier LLMs, peaking at 193.6x and 444.6x — but those numbers come from TypeSafe's own technical notes, and the company itself acknowledges the test workflows were written by its own team and the gains "likely sit at the high end of real-world results." Launch day also brought a $40M seed round led by DCVC at a $200M valuation (Forbes, Sept 15, 2026).

What the money buys besides hosting: the current category ceiling on large-option-set classification. That fact will matter twice more in this article.

Laya: The Open Answer, 72 Hours Later

Laya (Convai Innovations, Sept 18, Apache 2.0) shares Jev's lineage but pushes the architecture further: non-autoregressive, encoder-only. It isn't an LLM that can't talk — it's a bidirectional encoder (ModernBERT-large, 421M parameters, or mmBERT-base, 322M) fine-tuned into a classifier: one forward pass reads the whole input and emits the whole answer. No token-by-token generation; that's where 33-millisecond latency comes from. Developer NandhaKishorM's Dev.to write-up notes he published papers and weights for this architecture back in March 2025 — Jev's launch gave the obscure niche a name overnight.

Single checkpoints have weaknesses, so Laya ships three specialized checkpoints plus a sub-millisecond router:

Checkpoint	Backbone	Params	Context	Best at
laya (default)	ModernBERT-large	421M	512	English classification, guardrails, email triage
laya-multilingual	mmBERT-base	322M	1024 (up to 8k)	100+ languages, 2.2x faster
laya-typed-decisions	ModernBERT-large	421M	1024	The four typed-decisions workflows

Why the router? Because the English checkpoint fails confidently on non-Latin scripts — in the repo's benchmark it scores 0.000 accuracy on Khmer at 0.952 confidence. Confidence gating cannot save you there; the text must be intercepted before the forward pass by script detection (pure Python, 0.09–0.73ms). Routed, Laya is usable in 45 of 51 tested languages (>3x random baseline).

pip install laya gets you local inference, laya-serve (a self-hosted Jev-compatible HTTP server), an MCP server, ONNX export, and LangChain/LangGraph integrations. For teams where data cannot leave the building — healthcare and finance ticket classification — open weights on your own hardware is an answer Jev structurally cannot offer.

Head to Head: Numbers, and Where They Come From

The summary table — data from Laya's own benchmark (17,416 questions, one T4 GPU, identical questions per model), i.e., a Laya-led comparison. Read it with that in mind:

Metric	TypeSafe Jev 1.13	Laya (routed)	Gap
typed-decisions accuracy	0.727	0.766	Laya +3.9%
Calibration error (ECE)	0.246	0.081	Laya 3x better
P50 latency (single question)	236–276ms	32.8ms	Laya ~8x faster
P50 latency (10 questions, batched)	~1,500ms	72.3ms	Laya ~20x faster
Large option set (Banking77, 77 classes)	0.870	0.425	Jev wins by 2x
Cost	$0.042/M input tokens	$0 (self-hosted, GPU on you)	Structural
Open source	Closed, hosted	Apache 2.0	—

Real workflow numbers (Laya repo): email spam filtering 0.993 accuracy, phishing detection 0.980, LLM output guardrails 0.755–0.762 — exactly the quality band AI input/output guardrail infrastructure needs. For high-stakes agent gating (approving destructive operations), Jev's managed availability and large option sets still buy peace of mind — a footnote to the "don't build your own safety layer" lesson from the Agent Harness showdown.

The Fine Print Neither Will Tell You

The most useful part of this article — both models' real limits live outside the marketing pages.

Laya's pitfalls (from its own issue tracker — this candor is a point in open source's favor):

• ECE 0.081 is the calibrated number. Out of the box, Laya's mean ECE is 0.466 — far worse than Jev's 0.246. Getting to 0.081 requires temperature refitting per (question type × option count) on your own data. That "3x better" row has homework attached.
• Performance collapses past ~20 options. Banking77: 0.425 vs Jev's 0.870 — not a narrow loss but unusable. The official advice: hierarchical option splitting.
• Score is the weakest primitive (SST-5 five-way sentiment: 0.372), and noul has a label-anchoring trap (issue #156) — the docs themselves teach you to rewrite it as a two-option choice.
• Confidence and action probability are different things: act_probability reads ~1.0 for nearly every input with no discriminative power (issue #185, AUROC 0.30); gate on confidence instead (AUROC 0.77).

Jev's pitfalls (from what it doesn't say):

• No reproducibility. Every performance claim is self-tested with no third-party verification path; even the parameter count is unknown. Independent coverage (TechStock²) ran the headline "still self-tested" on the 445x claim.
• Text only. State accepts strings/JSON/arrays of text; images and audio must be preprocessed. Context is 64k — and the docs note that stuffing in irrelevant context lowers accuracy.
• Confidence ≠ correctness. OpenRouter's explainer is explicit: confidence measures how concentrated the probability distribution is, not whether the answer is right. Confidently wrong is structurally the same failure as Laya's Khmer problem.

My Take: Two Roads, Opposite Directions

Put side by side, this isn't "who replaces whom" — it's a clean market split:

• Self-hosted, privacy-sensitive, multilingual, high-volume batching → Laya. Runs on a single T4, 100+ language routing works out of the box, and Apache 2.0 means you can fine-tune it onto your exact workflow (official Kaggle notebook, ~4 hours on a free GPU tier). The price: you own the temperature calibration, the option-count discipline, and the ops.
• Large option sets, zero infrastructure, managed SLA → Jev. Picking correctly from 255 options has no open-source peer today, and $0.042/M tokens is cheap enough to put inside any loop. The price: your most critical judgments route through a black box you cannot audit, with performance claims you cannot check.

And one meta-observation worth keeping: 72 hours after Jev launched, the open-source community shipped an Apache 2.0 peer. In the LLM era, the closed-source lead over open source is now measured in days — this new category never enjoyed a monopoly premium, not even on day one.

Conclusion

System One models turn the class of judgments that are "too fuzzy for if-else, too small for an LLM" into millisecond-level, gate-able, calibrated components. If I could give only one piece of advice: pick one high-frequency small decision in your agent stack — ticket routing or tool-call gating — and trial Laya locally for a week. It's free, reproducible, and runs on your own hardware, so the cost of being wrong is near zero. If it holds, decide whether 255-way classification and managed availability are worth Jev's invoice; if it doesn't, you'll know precisely why.

References

1. Convai Innovations — Laya model card (Hugging Face) (Sept 2026; all benchmark data and known limitations)
2. NandhaKishorM — Laya GitHub repository, incl. Issue #156 and Issue #185
3. TypeSafe AI — Introducing System One Models & Jev (Sept 15, 2026)
4. Wikipedia — Jev (AI model) (citing Forbes/TechCrunch/The Register, Sept 2026)
5. OpenRouter — What Is Jev? TypeSafe's Decision Model Explained (Sept 21, 2026; pricing and confidence semantics)
6. LangChain — What Is Jev? A Guide to TypeSafe AI's System One Model (Sept 2026)
7. Tom's Hardware — TypeSafe AI's Jev claims to be 193x faster and 445x cheaper (Sept 2026)
8. TechStock² — TypeSafe AI Raises $40 Million for Jev, but Its 445x Cost Claim Is Still Self-Tested (Sept 17, 2026)
9. Vignesh Prajapati / Pingax — What Is Laya AI? Open-Source Decision Model Explained (Sept 23, 2026)
10. ZAKER — 开源模型 Laya 发布：推理速度快 Jev 近 8 倍 (Sept 20, 2026)