For a decade, progress in artificial intelligence has been measured in sentences. Every benchmark that mattered asked a model to produce text, and every demo that mattered ended with the model producing better text. Then, in the space of one September week in 2026, the two most interesting new models in the industry shipped with the same defining feature: they do not produce sentences at all. One is sold by a startup that spent two years in stealth. The other is a download. Both belong to a category the vendors call System One models, and understanding them means understanding the first genuinely new interface AI has offered since the chat box.

What a System One model actually is

The name borrows from Daniel Kahneman’s Thinking, Fast and Slow: System 1 is the fast, automatic, pattern-matching mind; System 2 is the slow, deliberate one that reasons in words. A large language model is a System 2 machine in this taxonomy. Ask it whether a support ticket is urgent and it will reason about it, token by token, and answer in prose that your code then has to read and interpret, at the price of a sentence per question.

A System One model, or decision model, does something smaller and stranger. You hand it a piece of text and a set of typed questions, and it returns a probability for every option of every question in a single forward pass. It never generates. There is no sentence to parse, because there is no sentence.

The questions come in three shapes. A choice question offers named options with descriptions, and the model picks one with a confidence. A score question offers ordered levels, from least to most, and the model returns a graded position on that scale. A yes/no question, which Laya calls noul, returns the probability that the answer is true. Ask all three about the same text and you get one answer object: a decision, not an essay.

Because the output grammar is fixed in advance, the model cannot answer off-schema. It cannot invent a fourth option, wander into a tangent, or dress up a guess as a paragraph. TypeSafe, the company behind the commercial model in this story, puts it plainly: while their model gives up string generation, it is optimized for structured outputs and cannot hallucinate, in the limited but real sense that every answer is a value from the schema with a probability attached.^[1]

Jev, the product

In mid-September 2026, TypeSafe AI came out of two years of stealth with Jev, its first public model, available in early access.^[1] The launch post is unusually quotable for a press release: “Think of Jev as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.” The claim attached to that metaphor is large. Jev, TypeSafe says, reaches similar intelligence on decision-shaped tasks as frontier LLMs while being two orders of magnitude faster and more efficient, with end-to-end latency between 70 and 500 milliseconds where a frontier model answering the same query in prose takes seconds to minutes.

The mechanism, as described, is the interesting part. Jev does not emit its answer one token at a time. It produces all of its outputs for a query in parallel, in a single shot, the way a classifier does. The model was trained with a method TypeSafe calls RLCD, reinforcement learning for calibrated decisions, which optimizes not for pleasing sentences but for probabilities that are epistemically honest: when the model says 80 percent, things should go as it says about 80 percent of the time. The pricing tells you what the interface is worth: input tokens at a fraction of a cent per million, and output tokens listed as free, “too cheap to meter,” because an output is a handful of numbers.^[1]

To their credit, TypeSafe prints the caveats next to the numbers. The workflow benchmarks showing gains of nearly two hundred times are “on the higher end of real world gains,” by their own admission, and on pricing: “We can’t prove it isn’t subsidized.” Jev is closed, API-only, and gated behind a waitlist. You send your text to their server, and you wait for their waitlist to reach you.^[1]

Laya, the weights

Three days after Jev’s launch, a repository called laya appeared on GitHub under the Apache-2.0 licence, published by Nandakishor M of Convai Innovations: a multilingual, non-autoregressive decision engine, 322 to 421 million parameters depending on the checkpoint, that answers the same three question types in a single forward pass.^[2] You install it with pip install laya, load the weights once, and it runs inside your own process, offline, on a laptop GPU, in tens of milliseconds. A decision costs you nothing and your data goes nowhere.

import laya

agent = laya.load("convaiinnovations/laya")
result = agent.predict(
    {"subject": "Charged twice", "body": "Refund the duplicate today or we cancel."},
    {
        "department": {
            "type": "choice",
            "instructions": "Which department should handle this request?",
            "criteria": {
                "billing": "invoices, payments, refunds",
                "technical": "bugs, outages, system errors",
                "other": "everything else",
            },
        },
        "churn_risk": {
            "type": "noul",
            "instructions": "Does the user threaten to cancel or leave?",
        },
    },
)

How does the open challenger compare to the funded incumbent? An independent benchmark run by a third party, not by either vendor, put both models through the same 500 labelled examples with no tuning. The verdict was two-sided and honest: Jev is more accurate out of the box; Laya matches it on simple questions, answers several times faster from an ordinary desk, about 21 milliseconds per decision measured on an Apple laptop, and is yours to run, inspect and fine-tune.^[3]

The same independent run mapped where the line falls, and the line matters. On clear-cut categories Laya is genuinely good: 96 percent on SMS spam, level with a hosted commercial model. On graded and subtle questions it is not: 35 percent on a five-level rating scale, where the hosted model reached 70 percent. Calibration error followed the same pattern, near-negligible on easy tasks, severe on hard ones.^[3] A decision model is not a small LLM. It is a different instrument, strong exactly where questions have clean answers and weak where they do not.

There is also a history here that the launch narrative flattens. Laya’s author had been publishing this line of work since March 2025, eighteen months before Jev launched; the open model did not chase the closed one, whatever the launch-cycle coverage implied.^[3] And where Jev’s architecture is undisclosed, Laya’s training method is documented, its fine-tuning notebook runs on free cloud GPUs, and fine-tuning on decisions from your own domain is where the numbers jump: from 0.362 to 0.766 on the model’s own benchmark for the specialized checkpoint.^[2]

The case against

The fair objections come in three layers. First, the metaphor is doing marketing work. Kahneman’s System 1 is a description of human cognition, not an architecture diagram, and a vendor that names its product after a psychology bestseller is selling intuition, not evidence. Treat the framing as a mnemonic, not a proof.

Second, giving up generation is a real loss, not a feature. Most workloads still need prose: explanations, summaries, drafts. The honest architecture is a cascade, the decision model answering what it can and escalating the hard tail to an LLM, which means you maintain two systems and measure the escalation rate, because that rate is what you pay frontier latency on.

Third, the benchmark evidence is early and thin. Five hundred labelled examples is a decent smoke test and a small foundation. The vendors’ own headline numbers come from self-selected evals. The category is one month old as I write this; anyone shipping on it should measure on their own data, which is exactly what the next article in this series does with a real moderation bot.

Why it matters

Strip the branding and the shift is simple to state. The industry spent years making simulated people better at talking. A second track has been quietly making small models better at deciding, and in September 2026 that track got a name, a closed flagship, and an open alternative in the same week. For anything between the two, the economics are not close: a typed decision with a probability costs fractions of a millisecond-cent and leaks nothing, where a prose answer costs a sentence, a second, and a round trip to someone else’s computer.^[4]

I built a Telegram moderation bot on exactly this trade, and it is the subject of the next article in this series. It runs a decision model on my own hardware, judges messages in any language, and never sends a byte of anyone’s conversation to a vendor. The most important sentence a model can produce, it turns out, is none at all.

---

1. TypeSafe AI, Introducing System One Models & Jev (September 2026). Quotes: “a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out”; “two orders of magnitude faster and more efficient”; latency 70ms to 500ms against 3 to 329 seconds for frontier models on the same queries; RLCD, reinforcement learning for calibrated decisions; output tokens “FREE (too cheap to meter)”; “We can’t prove it isn’t subsidized”; workflow gains of 193.6x faster and 444.6x cheaper described as “on the higher end of real world gains”; “While Jev gives up string generation, it’s optimized for structured outputs and can’t hallucinate”; Jev available in early access, closed weights, API only.
2. NandhaKishorM/laya, Apache-2.0. “Multilingual, non-autoregressive System 1 decision engine. Typed decisions over 100+ languages in a single forward pass.” Checkpoints convaiinnovations/laya (English, 421M parameters) and convaiinnovations/laya-multilingual (322M parameters); question types choice, score, noul; RLCD training against strictly proper scoring rules; Kaggle fine-tuning notebook; the typed-decisions checkpoint scores 0.766 against 0.362 for the base English model.
3. Laya: open-source alternative to TypeSafe Jev, the independent benchmark and playground by brain function collapse. Same 500 labelled examples, no tuning: “Jev is more accurate out of the box. Laya matches it on simple questions, answers several times faster from this desk, and is yours to run and fine-tune.” 21 ms per decision on an Apple M1 Max against roughly 4 seconds for a hosted LLM. Task detail: 96% on SMS spam and 93% on news topic classification for Laya, against 45% on six-way emotion, 65% on prompt-injection detection and 35% on a five-level rating, where the hosted model scored 53%, 71% and 70%; calibration error 0.05 to 0.06 on the easy tasks and 0.34 to 0.40 on the hard ones. Laya’s author had published this line of work since March 2025.
4. The Soft Target, on why capability keeps condensing into smaller models, and The Weights Were Always Free, on why open weights cannot be recalled.