Small AI decision models — Jev, Clef, Strands Decider, Nimble and Kev

What are AI decision models?

A regular language model (LLM) answers with text. Ask it “is this email a complaint?” and you get a sentence from which your program still has to extract “yes” or “no”. Sometimes the model adds a comment, changes the format or goes off topic. A decision model answers only with numbers, in a format fixed in advance.

Every request to a decision model has two parts: the state — the text to judge (an email, part of a contract, a ticket; some models also accept images) — and the questions, one or many at once, each of one of three types:

Values on the cards are examples.

TypeSafe calls these models “System One”, after System 1 in Daniel Kahneman's Thinking, Fast and Slow: fast, intuitive judgments instead of slow deliberation. Simon Willison, one of the best-known commentators on the AI market, prefers a simpler name, following Maggie Appleton: decision models. Write-ups also compare them to an “intelligent if” — a condition in code that understands text instead of comparing numbers.

One naming note: in business analysis, “decision model” also means something else — DMN (Decision Model and Notation), decision trees or decision tables. Here it means AI models built on top of language models.

How a decision model works and why it's so fast

Most open decision models are built the same way. The starting point is a regular open language model, most often from Alibaba's Qwen 3.5 or Qwen 3.8 family. Then:

1. the layer that generates the next words (the language-model head) is removed or skipped;
2. a small “pointer head” takes its place and compares the question with each allowed answer. In Strands Decider 2B it has just over a million parameters;
3. the model is fine-tuned with lightweight adapters (LoRA), while most base weights stay unchanged.

The model reads the text and the questions once, in a single pass, and scores every option at once. It doesn't generate an answer word by word and doesn't “think out loud”. That's where the speed comes from: Cloudflare reports a median of 38.8 ms per decision for Clef-flash, TypeSafe 70–500 ms for Jev, while large reasoning models need seconds for the same job. It also explains the pricing: you pay only for input tokens, because the output is a few numbers.

A second consequence: the model can't return an answer outside the list or break the format. TypeSafe calls this “no hallucinations”, but it's a promise about format, not accuracy. A decision model can still pick the wrong answer from the list, like any other model.

TypeSafe AI's Jev — the model that started the boom

Jev is a model from TypeSafe AI, unveiled on September 15, 2026. It runs only in the vendor's cloud. At launch there was a waitlist, and on September 20 TypeSafe announced open access for everyone; the access rules have changed several times since launch, so check them with the vendor. The company doesn't disclose the base model and doesn't publish weights. It only describes its training method, RLCD: reinforcement learning for calibrated decisions.

Key parameters according to the vendor:

• response time of 70–500 ms;
• $0.042 per million input tokens, output free (as of October 10, 2026);
• up to 255 options in a single choice question;
• according to TypeSafe, 40–200 times faster and up to several hundred times cheaper than frontier language models on decision tasks.

These are the vendor's numbers, measured on its own tasks. TypeSafe's documentation admits that Jev struggles with numbers, dates and text written on purpose to mislead it. The name refers to William Stanley Jevons and his paradox: when something gets cheaper, people use more of it. The company expects the same to happen with decisions made by AI.

Clef, Strands Decider, pplx-decider and Decisions API — a flood in two weeks

Jev runs only in the cloud and has no open weights. Competitors answered fast, and mostly in the open. On October 1, 2026, on a single day, Cloudflare, Amazon and Perplexity released their models. A few days later OpenAI opened its Decisions API to all developers.

AI decision models in three weeks

Sep 15

Jev

TypeSafe AI, the first decision model, cloud only

Sep 29

Ollama 0.35 · OpenAI

Nimble and Tev1 locally; OpenAI previews Decisions API at DevDay

Oct 1

Clef · Strands Decider · pplx-decider

Cloudflare, Amazon and Perplexity on one day, with open weights

Oct 6

Decisions API · pplx v1.1

OpenAI in public beta, Perplexity ships a new version

Oct 9

Clef-omni

Cloudflare adds audio and video, cuts the Clef-flash price

Cloudflare Clef and Clef-flash

• Two models: Clef (27B parameters, built on Qwen 3.8 27B) for the most accurate decisions and Clef-flash (9B, built on Qwen 3.5 9B) for tasks where every millisecond counts.
• Apache 2.0 license, weights on Hugging Face. They run on your own hardware or in Cloudflare's cloud (Workers AI).
• Clef also understands images. On October 9 Cloudflare added Clef-omni, which also accepts audio and video.
• Workers AI prices per million input tokens (as of October 10, 2026): Clef $0.24, Clef-flash $0.038 (cut from $0.09; at the same time Clef-flash's cloud context window shrank to 24K tokens), Clef-omni $0.15.
• According to Cloudflare, the median decision time at launch was 38.8 ms for Clef-flash, 209.3 ms for Clef and 524.1 ms for Jev, and Clef or Clef-flash had the best score in 7 of 10 tests of the Jev Decision Index suite. On October 9 Cloudflare said it had made Clef 1.7–2× faster through serving changes. These are Cloudflare's measurements, not yet independently reproduced.
• Cloudflare says it doesn't read, store or train on customer requests, unless the customer submits them for fine-tuning.
• Alongside the models Cloudflare launched a service to fine-tune Clef on company data with reinforcement learning. For now Cloudflare's engineers run it hands-on.

Amazon Strands Decider 2B

• A model from Strands Labs at AWS. The idea came from Marc Brooker, an Amazon engineer who built his own version after Jev launched. After polishing, Amazon released it officially.
• About 2B parameters (1.9B according to the repository), built on Qwen 3.5 2B with the text-generating layer removed. The model physically can't write a sentence. The repository also includes variants built on Google's Gemma 4 models.
• Apache 2.0 license. Next to the weights, Amazon published the training data and scripts — a recipe for reproducing the training.
• Designed to run on your own hardware: on an NVIDIA GPU, on a Mac, even on a CPU alone.
• According to AWS, the median response is about 115 ms on an RTX 3090, a consumer card a few years old.
• Use cases Amazon points to: picking a tool for an agent, routing a task to the right model or path, evaluating results, and safeguards (guardrails).

Perplexity pplx-decider-27b

• pplx-decider-v1-27b came out on October 1 together with Perplexity's Decisions API. On October 6 version v1.1 followed, with the same base model and the same way of calling it.
• 27B parameters, built on Qwen 3.8 27B, Apache 2.0 license, weights on Hugging Face. To run it yourself you need room for about 49 GiB of weights alone.
• Accepts text, JSON data and images. Up to 128 questions per request, up to 255 options per choice question, up to 10 levels on a scale.
• In Perplexity's cloud, v1.1 costs $0.02 per million input tokens (as of October 10, 2026) — less than half of Jev's price.
• According to the model card, v1.1 scores 61.56 on the Decision Index vs. 57.9 for Jev. These are Perplexity's numbers.
• It has its own API (endpoint /v1/decisions), not directly compatible with Jev, but with the same question types.

OpenAI Decisions API

• Previewed at DevDay on September 29, in public beta for all developers since October 6.
• Cloud only, and only one model: GPT-6 Luna. No weights.
• Three question types: predicate (the probability that a condition holds), choice and score. Text and images as input.
• $0.10 per million input tokens, no charge for output (as of October 10, 2026). OpenAI says it's up to 10 times faster than the regular API.
• For eligible customers: data residency in Europe (EEA and Switzerland) and Zero Data Retention.
• The model can refuse to answer a question, so your application has to handle that case.

Nimble, Tev1 and Kev — decision models locally, with Ollama

The easiest way to run a decision model on your own computer is Ollama, the popular free tool for running models locally. Since version 0.35 (September 29, 2026), Ollama supports decision models on a separate endpoint modeled on Jev's API.

Nimble (Bespoke Labs) has 9B parameters and is fine-tuned from Qwen 3.5 9B. In Bespoke Labs' test on 13 public datasets (3,880 human-labeled decisions) it averaged 75.7% accuracy vs. 76.0% for Jev 1.13. It did better than Jev on scale questions and worse on yes/no questions, for example comment moderation (70.3% vs. 81.0%). Limits: text only, and up to 8,192 tokens per request including the questions. Ollama reports 91 ms per decision on a MacBook Pro with an M5 Max.

Tev1 (Together AI) is a pair of experimental models, 4B and 0.8B, also available in Ollama.

Kev is an independent open project by Jared Palmer (Apache 2.0) in four sizes:

In the author's test, Kev-27B is within a percentage point of Jev on data it didn't see in training. In general knowledge (MMLU-Pro) it's clearly weaker: 0.675 vs. 0.840. The author warns that the order of options can change the answer and that the model is weak with dates. A practical note: Kev isn't on PyPI, and pip install kev installs a completely different package.

Comparison: small AI decision models in one table

As of October 10, 2026; our benchmark column: October 11–12, 2026. Cloud prices per million input tokens; output is free in every service.

“Our test”: average accuracy across three inboxes (hotel, bank, telecom), 600 Polish emails — details in the decision model benchmark.

Same API as Jev — can you swap the model?

Largely yes, and that's one reason for the flood. Kev, Strands Decider (in server mode), Ollama with Nimble and Tev1, and Clef accept requests in the same format as Jev. Kev says outright that TypeSafe's official Python library works with its local server, and Ollama shows the same in an example: you only change the server address and the model name. Perplexity and OpenAI have their own APIs with the same three question types, so switching takes a small rewrite.

The same format doesn't mean the same answers. Bespoke Labs cautions that models should only be compared on the same examples, run the same way, and that confidence thresholds have to be checked on your own data. In practice: before you replace Jev with Clef, Nimble or a local model, run both on the same few hundred real cases and compare. At prices of cents per million tokens, that test costs pennies.

What decision models are good for in a company

A decision model won't replace an assistant that drafts letters or summarizes contracts. It fits where a person answers the same closed question all day long, or where a large language model is too slow and too expensive for that question. Examples the vendors point to:

• Routing emails and tickets — which team, how urgent, is it a complaint. The first step in automating a shared inbox.
• Document classification — invoice, contract, official letter, offer. Models with image input (Clef, pplx-decider, OpenAI) also accept scans.
• A data guard before the cloud — “does this text contain personal data or company secrets?”, before it goes to ChatGPT or another external model. A local decision model can be the first line of control.
• Checking another model's answer — is the answer grounded in the document, or did the model make something up? Perplexity reports 88.8% accuracy here vs. 77.3% for Jev (RAGTruth, version v1, Perplexity's data).
• Re-ranking search results — a regular search engine picks a hundred candidates, and a decision model scores the relevance of each. Simon Willison is experimenting with this approach.
• Content moderation — comments, reviews, messages from web forms.

Decision models in AI agents

An AI agent is a program that carries out steps on its own: reads a ticket, checks data in a system, replies. At every step it makes small decisions: whether to call a tool, which one, whether the result is good, whether to hand the case to a human. Today a large model usually does this, “thinking” for a few seconds each time. Decision models are meant to take over exactly these small decisions and leave writing and planning to the large model. That's how Amazon explains its model: AWS customers didn't need a full language model for every step of an agent.

Limitations: what decision models can't do

• They don't write. No explanations, summaries or replies to customers. You also can't see why they chose an answer. Simon Willison notes that this is a step toward an even more opaque “black box” than a regular language model.
• They're weak with numbers and dates. Both TypeSafe (Jev) and Kev's author admit it. A question like “is the payment overdue?” is better answered by plain code.
• Multi-step reasoning isn't their strength. TypeSafe recommends splitting a complex decision into several simple, independent questions and combining the answers in code.
• A probability is not a guarantee. Bespoke Labs says plainly that Nimble's probabilities don't guarantee correctness. A decision threshold (e.g. “handle automatically above 0.9”) has to be set on your own data.
• The order of options matters. Kev's author noticed that reordering the answers can change the result, and TypeSafe admits that Jev leans toward the option listed first.
• Short context windows. Nimble takes 8,192 tokens, the small Kev models about 8K, Clef-flash in the cloud 24K. Longer documents have to be split. Clef (64K) and Perplexity's API (up to 262K) hold more.
• Vendor benchmarks. Almost every number on this page comes from the companies that released the models. Independent comparisons are still scarce.
• Languages other than English. Vendors publish almost no results beyond English (Bespoke Labs' public suite includes one German dataset), so we tested Polish ourselves: the leaders reach 85–87% accuracy on Polish emails, and missing diacritics change the decision in 2–6% of cases. The biggest problem is an injected instruction added to the email text — it lowers accuracy by 8–32 percentage points. Details: decision model benchmark.
• Bias and regulation. Willison warns against using such models to rank job candidates, because hidden bias is hard to detect. Under the EU AI Act, AI systems for recruiting and selecting candidates are high-risk (Annex III), with additional obligations.

Local or cloud? Hardware for decision models

Most of the new decision models have open weights, so the data doesn't have to leave your company. That matters for customer emails, HR documents or case files. Hardware requirements depend on model size:

In our benchmark we measured memory and time per email with 4 questions on one GX10: 27B models — 51.5–54.7 GB and 0.8–1.5 s; 9B — about 20–21 GB and 0.26–1.4 s; Strands 2B, d1 3B and Tev1 4B — 6.3–10.9 GB and 0.06–0.32 s; Kev 4B — 21 GB and 145 ms; K2-Type 0.9B — 3.6 GB and 43 ms; CLM 8B — 48 GB and 96 ms. (What else we run on GB10 hardware is described on our DGX Spark cluster page.) Cloud versions (Jev, OpenAI, Perplexity, Cloudflare) need no hardware and are easier to start with, but every request sends the content to an outside provider. With personal data you need a data processing agreement and a check of where the data is processed.

Bonsai 2 27B — the other way to make AI small

Decision models are one way to make AI smaller: narrow the model down to one job (in English this whole trend is often called small language models). The other way is to compress a regular language model until it fits on ordinary hardware — and that model still writes emails, summaries and analyses. We tested Bonsai 2 27B that way on eight classes of hardware: an NVIDIA GPU with 8 GB is enough, 16 GB is the sweet spot.

Decision models FAQ

How is a decision model different from a regular language model?

A language model (LLM) writes text word by word. A decision model reads the text once and returns numbers: the probability of “yes”, a chosen option from a list or a score on a scale. That makes it tens of times faster and cheaper, but it can't write a single sentence.

Do decision models hallucinate?

They can't return an answer outside the list or break the format, but they can pick the wrong answer. Check accuracy on your own examples and set the confidence threshold separately for each use.

Which decision models can I run locally?

Clef and Clef-flash (Cloudflare), Strands Decider 2B (Amazon), pplx-decider (Perplexity), Nimble, Tev1 and Kev have open weights. The easiest start is Ollama 0.35 or newer. Jev and OpenAI's Decisions API run only in the cloud.

Do decision models work in languages other than English?

Vendors publish almost no results beyond English, so we tested Polish ourselves: on 2,198 Polish documents the leading models reached 85–87% accuracy on emails. Missing diacritics changed the decision in 2–6% of cases, and English category names didn't improve the leaders' results. For other languages, test on your own examples.

What is TypeSafe AI's Jev?

Jev is the first decision model, unveiled by TypeSafe AI on September 15, 2026. It runs only in TypeSafe's cloud and, according to the vendor, answers in 70–500 ms and costs $0.042 per million input tokens, with free output (as of October 10, 2026).

Sources

• TypeSafe AI, Introducing System One Models & Jev — response time, price, up to 255 options, claimed speed-up and cost savings, RLCD, the origin of the name.
• TypeSafe AI docs: System One (Kahneman, splitting decisions into simple questions, text only) and Jev 1.13 known weaknesses (numbers, dates, adversarial text, option order; reviewed October 2, 2026).
• Crypto Briefing, TypeSafe opens Jev AI to public (September 21, 2026) — waitlist removed on September 20, 2026.
• Simon Willison, on Jev (September 21, 2026) — the name “decision models”, the black-box concern, bias in candidate ranking, search re-ranking.
• CodeRabbit, Intelligent If-Statements: Jev vs. LLMs — the “intelligent if” comparison.
• Cloudflare, Clef launch (October 1, 2026) and Clef-omni and new prices (October 9, 2026); Clef-flash model card.
• TechCrunch, Amazon releases its own Jev clone as decision models flood the web (October 1, 2026); Strands Agents, Introducing Strands Decider and the Strands Decider repository.
• Perplexity, pplx-decider v1.1 model card, Decisions API docs and community forum.
• OpenAI, Decisions guide and the public beta announcement.
• Ollama, decision model support (September 29, 2026) and the Nimble model page; Bespoke Labs, Nimble repository; Jared Palmer, Kev repository.
• Hackaday, A New Type Of LLM On The Block: Decision-Making Models (October 6, 2026).
• Regulation (EU) 2024/1689 (AI Act) — Annex III, point 4: employment and recruitment.