The fast half of intelligence is getting its own models

For three years the industry has been obsessed with making models think slower. Chain-of-thought, test-time compute, reasoning tokens, “thinking” modes. The results were real: a model that writes out its reasoning can solve problems that a model answering on reflex cannot. But the pendulum swung so far that we started paying reasoning prices for decisions that never needed reasoning at all. In 2026 that is being corrected, and the correction has a name borrowed from psychology: System One models.

Kahneman’s split, applied to software

Daniel Kahneman described two modes of human thought. System 1 is fast, automatic and intuitive. You read a word, recognise a face, sense that a sentence is hostile, without any awareness of steps. System 2 is slow, effortful and sequential. You multiply 17 by 24, plan a route, check an argument.

Large language models map onto this split with surprisingly little distortion. A model that answers in a single forward pass, with no intermediate tokens, is System 1. A model that generates a chain of reasoning before committing, or that searches over candidate answers, is System 2. The o-series of reasoning models, DeepSeek-R1 and every “thinking” toggle shipped since are System 2 behaviour bolted onto a System 1 substrate.

The problem is cost. Most decisions inside real software are not maths olympiad problems. They are: is this support ticket about billing? Does this query contain a named entity? Is this response grounded in the retrieved document? Should this agent call the refund tool or the escalation tool? Each one is a bounded choice from a known set of options. Routing them through a reasoning model means seconds of latency and cents per call for a decision that a well-trained classifier makes in milliseconds for a fraction of a cent.

The research trail

The academic community saw this coming before the products did.

Distilling System 2 into System 1 (Yu, Xu, Weston and Kulikov, Meta, July 2024) showed that the outputs of slow methods such as chain-of-thought, rephrase-and-respond and branch-solve-merge could be compiled back into a model that answers directly, without intermediate tokens. The distilled model beat its own System 1 baseline and ran at a fraction of the System 2 cost. The authors framed it as the way a continually learning system should work: spend deliberation only on what it cannot yet do on reflex, then fold the result back into reflex.

Dualformer (Meta, October 2024) trained one Transformer on randomised reasoning traces, with parts of each trace dropped during training, so the same model can run in fast mode, slow mode, or decide for itself. Coconut (December 2024) went further and let the model reason in continuous latent space, feeding its hidden state back as input instead of emitting words. DynamicMind (June 2025) added a lightweight router that chooses between fast, normal and slow modes per question.

By early 2026 the question had shifted from “can we switch modes?” to “can we blend them?”. Dynamic Model Interpolation (January 2026) interpolates the weights of an instruct checkpoint and a thinking checkpoint at inference time, with a per-query intensity parameter, and reports accuracy above the thinking model alone on five maths benchmarks at lower cost. The finding that matters for practitioners is that the trade-off curve between fast and slow is smooth and convex. You can choose a point on it.

The product: Jev

On 15 September 2026, TypeSafe AI, founded by Diogo Almeida, released Jev and called it the first public model in a “System One” class. The design choices are worth listing because they define what the category means:

• Input is unstructured text plus a set of typed questions you define at call time: a choice among options, a numeric score against a rubric, or a yes/no.
• Output is a probability distribution over the values you allowed. Nothing else. The model cannot emit a string outside the schema, so the structured-output error rate is zero by construction.
• The answers are produced in parallel in a single query, not token by token.
• The probabilities are trained to be calibrated. TypeSafe calls the method Reinforcement Learning for Calibrated Decisions. A confidence of 0.8 is meant to be right about 80 percent of the time, which lets code act on thresholds.
• Latency is 70 to 500 milliseconds end to end. Input is priced at $0.042 per million tokens and output is free.

Those are vendor numbers on vendor tasks, and the company itself says it does not know whether the pricing survives the end of its subsidy. The limitations are also stated plainly: no explanation of a decision, no open-ended generation, no use where a regulator wants a rationale.

What is new here is not the idea of a fast classifier. It is the packaging: a general model that accepts arbitrary typed questions without fine-tuning, returns calibrated probabilities, and is sold as a distinct category rather than as a cheaper tier of a chat model.

Three weeks later, a category

What settles whether a product is a one-off or a category is whether competitors copy the interface. Within three weeks of Jev, they did.

On 29 September 2026, at its DevDay keynote, OpenAI announced a Decisions API: a constrained version of GPT-6 Luna that answers developer-defined questions with finite answer sets in about 150 milliseconds, against 1.6 seconds for a normal Luna call. It is in limited preview. As of early October, OpenAI has published no request schema, no pricing, and no statement about whether it returns calibrated probabilities. It is a System One product by shape, built by narrowing a generative model rather than by training a new one.

On 1 October, Cloudflare released Clef and Clef-flash, the first models trained by its Workers AI team: 27 billion and 9 billion parameters, post-trained from Qwen checkpoints, open-sourced under Apache 2.0, with a vision encoder and a 64k context window. Cloudflare reports median latencies of 209 and 39 milliseconds, claims the top score on seven of ten decision benchmarks, and, most tellingly, made both models drop-in compatible with Jev’s request format. The three question types Jev introduced, yes/no, choice and score, are now an interface other vendors implement.

In between came Upstage’s Solar Decide and meraGPT’s Decider 1 (22 September), Together AI’s Tev1 with its training recipe (23 September), Fastino’s GLiNER2.5-Decide, a 340-million-parameter encoder (24 September), Liquid AI’s d1 (29 September), Inception’s Mercury Decide (30 September), and Perplexity’s pplx-decider. Several are open weights. The cheapest list prices sit at two to four cents per million input tokens. The most interesting entrant is academic: on 23 September, Stanford and NVIDIA Research released CLM-8B, an open-source contrastive language model that treats a decision as a similarity match between a state and each candidate action, and reports inference up to nine times faster than Jev. Distribution moved just as fast: Vercel, OpenRouter and Databricks added access to Jev within ten days of launch.

The first independent evaluation arrived the same week. Rafe and Das (29 September 2026) benchmarked decision models against trained classifiers and generative models on workflow, intent and social-science tasks. Their findings are the ones a platform team should read before buying:

• Where labelled data exists, a small trained classifier still wins on accuracy. Decision models win where there are no labels.
• Calibration degrades as the number of options grows. Temperatures fitted on small option sets over-trust the model on large ones.
• Out-of-scope inputs are the weak point. At a five percent risk threshold, Jev still accepted 31 percent of requests that belonged to none of the offered options.
• A two-stage design, a cheap intent classifier escalating to a decision model, matched the decision model’s accuracy at 43 percent of its cost.

None of that undermines the category. It defines how to use it: as a general zero-shot layer with explicit out-of-scope handling, not as a replacement for a classifier you have the data to train.

Under the hood: not one architecture but three

“Not decoder-based generation” is the claim that defines the category, so it is worth being precise about what it means, because the vendors are not all doing the same thing.

A chat model answers a classification question by generating text: it predicts the next token, appends it, and predicts again until it has written {"category": "billing"}. Every token is a full pass through the network. Structured-output modes and JSON schemas constrain which tokens are allowed; they do not remove the loop. A System One model removes the loop. It reads the input once and produces, in that same pass, a probability over each allowed answer. No sampling, no decoding, no output tokens to bill. There are three ways to build that.

A. The encoder classifier. This is the pre-2022 design: a bidirectional encoder such as BERT or DeBERTa reads the whole input at once, pools it into a vector, and a linear head maps that vector to a fixed set of labels. It is cheap, fast and well calibrated after a temperature fit. Its limit is that the label set is baked in at training time; a new routing option means new data and a new training run. The GLiNER family escapes that by writing the candidate labels into the input and letting the encoder match spans to them, which is how Fastino’s GLiNER2.5-Decide offers dynamic questions on a 340-million-parameter DeBERTa encoder that runs on a CPU.

B. The decoder with its logits read once. Prompt an ordinary language model with the text and lettered options, run a single forward step, and read the next-token probabilities for the letters A, B, C. No text is generated, so it is fast, and the label set is dynamic because it lives in the prompt. But it is still an autoregressive model being stopped early. Its probabilities are likelihoods of the next character under a text-prediction objective, not estimates of being right, and they are known to be poorly calibrated and sensitive to option order. Together AI’s Tev1 is this, openly: a LoRA fine-tune of Qwen3.5-4B that keeps the standard language-model head and emits one letter. The open-source Jev clones (OpenJev, mini-jev) do the same with a frozen base model. OpenAI’s Decisions API, a “constrained version” of GPT-6 Luna, is almost certainly in this family too, which is why it has not said whether it returns probabilities at all.

C. The purpose-built decision model. This is what TypeSafe means by System One and what makes Jev different from a clever prompt. The state is encoded once by an LLM-scale backbone whose text-generation head is never used. Every declared question, and every option inside it, is scored in parallel by a separate output path, what TypeSafe calls its parallel sampler, so a request with twenty questions costs about the same as one. Calibration is not a post-hoc temperature; it is the training objective. TypeSafe’s Reinforcement Learning for Calibrated Decisions rewards probabilities that match long-run accuracy and penalises confident errors asymmetrically. TypeSafe has not published the architecture, parameter count or training data, so beyond the interface and these claims the internals are inferred.

Stanford and NVIDIA’s CLM-8B is the first open model to show one concrete way to build C. It keeps a frozen Qwen3-8B as a pure encoder, pooling the last token, and adds two 20-million-parameter projection heads, one for the state and one for each candidate action. A decision is the similarity between the state embedding and each action embedding, normalised into a distribution. It is trained contrastively, on 60 million Nemotron question-answer pairs, 30 million synthetic hard negatives and a million agent trajectories, to pull each state toward its correct action and away from the others. Because the options are embedded independently, they can be precomputed and the model scales to large option sets without re-reading the prompt, which is where the reported speed advantage over Jev comes from.

Model by model

Put side by side, the vendors’ own disclosures show how little the category shares beyond the output contract.

So the honest answer to “is it decoder-based?” is: Jev and CLM are not, in the sense that matters, because no decoding happens and the text head is dropped. Several of the models now sold under the same label are decoders with the loop cut after one step. The difference shows up exactly where the independent benchmark said it would: in calibration, in behaviour on out-of-scope inputs, and in cost as the number of options grows.

This is older than it looks

Anyone who built NLP systems before 2022 will recognise the shape. Encoder classifiers, cross-encoders for ranking, natural-language-inference models used for zero-shot labelling: all of them were single-pass, bounded-output, calibratable models. The industry abandoned them because generative models were more general, then rediscovered the cost of that generality.

One of my own models is a small example. The query well-formedness scorer I published on Hugging Face takes a sentence and returns a single calibrated score for whether it is grammatical and complete. No reasoning, no tokens, one pass. It has passed 65 million downloads, peaked at 8.5 million in a single month, and was recently used as the query filter in the GaRAGe retrieval benchmark published at ACL 2025. People did not download it because it is clever. They downloaded it because it answers a bounded question quickly and its score can be thresholded.

System One models are that pattern, generalised and productised.

What this means for enterprise AI

I lead AI platforms for a large group, and the pattern I see in every agentic system is the same. The expensive reasoning model is doing two jobs. One is genuinely hard: planning a multi-step task, writing code, synthesising a document. The other is a stream of small, bounded decisions: which tool, which route, is this safe, is this done, is this grounded. The second job is where latency and cost accumulate, and it is where tool-calling failures concentrate.

A System One model is the right component for the second job, and I expect agent frameworks to grow a dedicated slot for one. The practical rules I would apply:

1. Route by decision shape, not by difficulty. If the answer space is enumerable in advance, it is a System One call. Difficulty is irrelevant; a hard classification is still a classification.
2. Act on calibrated probabilities, not on labels. The value of a System One model is a number you can threshold. Below the threshold, escalate to System 2. That is the whole design.
3. Keep System 2 for what needs a trace. Anything a human or regulator will audit needs the reasoning written down. Do not put a reflex model there.
4. Distil continuously. The 2024 Meta result is the operating model: let the slow model handle novel cases, log them, and fold the resolved ones into the fast model.
5. Build to the interface, not the vendor. With Cloudflare, Together and others implementing Jev’s question format, the request shape is becoming a standard. Keep the decision layer behind an adapter so an open-weight model can replace a hosted one when the subsidised prices end.

The last three years taught models to think slowly. The next few will be about knowing when not to.

Sources

1. Yu, Xu, Weston, Kulikov. Distilling System 2 into System 1. arXiv:2407.06023, July 2024.
2. Su et al. Dualformer: Controllable Fast and Slow Thinking by Learning with Randomized Reasoning Traces. arXiv:2410.09918, October 2024.
3. Hao et al. Training Large Language Models to Reason in a Continuous Latent Space (Coconut). arXiv:2412.06769, December 2024.
4. Li et al. DynamicMind: A Tri-Mode Thinking System for Large Language Models. arXiv:2506.05936, June 2025.
5. Yang et al. System 1&2 Synergy via Dynamic Model Interpolation. arXiv:2601.21414, January 2026.
6. TypeSafe AI. Introducing System One Models and Jev. 15 September 2026.
7. DataCamp. Jev: TypeSafe’s System One Model Explained. 2026.
8. GaRAGe: A Benchmark with Grounding Annotations for RAG Evaluation. Findings of ACL 2025.
9. OpenAI. Decisions API, announced at DevDay, 29 September 2026. Summary via Firecrawl; no official schema or pricing published as of 5 October 2026.
10. Cloudflare. Introducing Clef: Cloudflare’s first open-source decision models, now on Workers AI. 1 October 2026.
11. System One Models catalogue. Retrieved 5 October 2026.
12. Willison, S. Jev introduces a new shape of LLM. 21 September 2026.
13. Kwok, Ré, Mirhoseini, Pavone (Stanford, NVIDIA Research). Contrastive Language Models, CLM-8B. Open weights on Hugging Face, 23 September 2026.
14. Together AI. Tev1: open-weight, Jev-inspired decision model fine-tuned on Qwen3.5-4B. 23 September 2026.
15. Fastino. GLiNER2.5-Decide. 24 September 2026.
16. Cloudflare. Introducing Clef: our open-source decision models, and new RL fine-tuning platform. 1 October 2026.
17. Perplexity. pplx-decider-v1-27b model card. 1 October 2026.
18. Upstage Solar Decide, meraGPT Decider 1, Liquid AI d1, Inception Mercury Decide and Respan Span-01: vendor announcements and OpenRouter listings, retrieved 5 October 2026.
19. TypeSafe Jev technical deconstruction and open-source reimplementations. Kevnu, 2026. Used for the catalogue of clones; TypeSafe’s internals remain undisclosed.
20. Rafe, Das. Benchmarking System One decision models against trained classifiers and language models for automated decision gates. arXiv:2610.00346, 29 September 2026.