What Are AI Decision Models? A Look at Ten Products Including Jev, Clef, and Decider

Title

What Are AI Decision Models? A Look at Ten Products Including Jev, Clef, and Decider

Meta Description

Decision models are specialized AI models that return probabilistic judgments for AI agents without generating text. This article examines the principles, pricing, speed, limitations, and developer recommendations for ten products including Jev, Clef, and Decider.

Article Content

AI agents need to make a large number of small judgments frequently while executing tasks—whether to continue, which tool to choose, whether the output is compliant. Running these judgments through a chatbot is both slow and expensive. So a class of AI models specifically designed for decision-making has emerged.

Starting with TypeSafe's release of Jev in mid-September 2026, at least eight companies have launched decision models in just over a month, including Cloudflare's Clef, AWS Strands team's Decider, Perplexity's pplx-decider, Liquid AI's d1 series, OpenAI's Decisions API, and Microsoft-Decision-1. Their common goal is clear: make the "yes or no" and "which one" calls inside AI agents faster and cheaper than general-purpose chat models.

What's the fundamental difference between decision models and chat models

Chat models generate answers by writing out text token by token. Decision models don't write text at all. An application sends it an input (called a state), plus a set of questions with fixed answers, and the model returns a probability value for each allowed answer.

TypeSafe founder Diogo Almeida describes it as a single function call: "Unstructured state input, typed probabilistic decision output." "Typed" means the returned result always conforms to the expected format—the answer to a yes/no question can only be "yes" or "no," never an ambiguous sentence.

Most vendors currently offer three types of questions, just with different names: yes/no questions return the probability of "yes" (Cloudflare and Perplexity call this noul, OpenAI calls it predicate); single-choice questions return the probability of each option; rating questions return a scale value weighted by probability.

The speed advantage comes from skipping the text generation step. The AWS Strands team's approach is to remove the vocabulary-generating part of the model, so that Decider "always produces answers from selected options." Cloudflare's Clef reads the input once and scores all valid options in parallel. Liquid AI puts it most directly: the d1 model "does not generate tokens, and gives answers through a single forward pass."

Probability values are only useful when calibrated—when the model says it's 80% confident, the actual accuracy rate should be close to 80%. Applications can use this to decide whether to execute directly, escalate to a human, or hand off to a larger model.

What is probability calibration

Probability calibration is the prerequisite for making decision models practical. If a model outputs "80% confident" for 100 samples, then about 80 of them should be correct—that's what good calibration means. Poor calibration takes two forms: overconfidence (says 80% but is actually only right 50% of the time) and excessive conservatism (says 60% but is actually right 90% of the time). Calibration is usually measured using ECE (Expected Calibration Error) or Brier score. The aforementioned case where Laya scored 0% accuracy on Khmer text yet reported 95.2% confidence is a typical example of severe overconfidence.

Calibration failure can have serious consequences. If an agent blindly trusts the probabilities given by the model and treats "95% confident" as fact to execute directly, it could cause losses in high-risk scenarios (such as automatically approving refunds or releasing content). Common remediation measures in practical engineering include: temperature scaling (remapping probabilities using a batch of labeled data), using calibrated thresholds rather than raw probabilities for decisions, and setting up fallback paths where "when uncertain, escalate to a large model or human."

Ten decision models compared side by side

Current decision models on the market differ significantly in openness, underlying architecture, and pricing:

Open-weight camp: Convai Innovations' Laya is based on ModernBERT-large (421M parameters) and released under Apache 2.0. Cloudflare's Clef series is all open-weight—Clef is based on Qwen3.8-27B, Clef-flash is based on Qwen3.5-9B, and Clef-omni is a 30B mixture-of-experts model (with 3B active parameters). Perplexity's pplx-decider is also based on Qwen3.8-27B and released under Apache 2.0. AWS Strands Decider 2B is open-sourced based on Qwen3.5-2B. Liquid AI's d1-3B and d1-omni-600M are open-weight based on their own LFM2.5 models.

Managed service camp: TypeSafe's Jev is a managed service with no disclosed underlying model. OpenAI's Decisions API is based on gpt-6-luna and is in public testing. Microsoft-Decision-1 is deployed on the Foundry platform and based on Qwen3.5-9B.

In terms of pricing, managed input prices range from Perplexity's $0.02 per million tokens to Cloudflare Clef's $0.24—a twelvefold difference. TypeSafe, OpenAI, Perplexity, and Microsoft all state that output tokens are free and billing is input-only. Note that AlphaSignal reported a price of $0.04 when covering the pplx-decider release on October 1, which is inconsistent with Perplexity's official documentation of $0.02. You should verify the latest pricing before budgeting.

The battle between open weights and managed services

"Open weight" means the model parameters can be downloaded, and users can run, fine-tune, or even redistribute them on their own servers. The Apache 2.0 license used by Laya, Clef, pplx-decider, and others falls into this category. Managed services only provide an API, and users cannot access the model itself, such as TypeSafe's Jev and OpenAI's Decisions API.

Both paths have trade-offs. The advantages of open weights are that data doesn't leave the internal network, they're auditable, there's no per-call billing, and they can be fine-tuned on your own data; the cost is that you need your own compute, bear operational costs, and handle updates yourself. The advantages of managed services are out-of-the-box usability, elastic scaling, and continuous optimization by the vendor; the cost is pay-per-use billing, data leaving the internal network, and model behavior potentially changing at any time. For compliance-sensitive finance and healthcare scenarios, open weights are often the only viable option.

The parameter counts mentioned in this article (such as 421M, 2B, 30B MoE) determine hardware requirements: models of a few hundred M can run on consumer-grade GPUs or even CPUs, while 30B mixture-of-experts models require professional cards. When comparing pricing, also note the difference in what "token" means—the input to a decision model is usually a complete state (which may include a full ticket and a tool list), not a single word in a chat.

From one product to ten in a month

The expansion speed of this track is worth noting. TypeSafe was first to release Jev on September 15, followed by Convai Innovations launching Laya the same month. October 1 was a concentrated burst—Cloudflare Clef, Strands Decider 2B, and pplx-decider were released on the same day. On October 7, Liquid AI launched d1-3B and d1-omni-600M. On October 9, Cloudflare added Clef-omni and reduced the price of Clef-flash from $0.09 to $0.038. OpenAI and Microsoft's products also entered public testing or launched in October.

Input modalities are also expanding rapidly. Laya supports text only, while Clef has supported images since launch. According to Cloudflare's changelog, Clef-omni now accepts audio and video input. Liquid AI's d1-omni-600M supports text paired with images or audio. OpenAI says the Decisions API is expected to exit testing "in the coming weeks."

The truth about speed and cost

Speed is the core selling point of decision models, but all data comes from each vendor's own testing. Liquid AI says d1-3B takes 8 milliseconds per decision on an Nvidia RTX 4090. The Laya team reports 32.8 milliseconds on an Nvidia T4. The Strands team measured a median of about 115 milliseconds on an RTX 3090. TypeSafe gives a latency range of 70 to 500 milliseconds for Jev.

The cost per decision is extremely low. Based on Microsoft's data, InfoWorld estimates that $1 can cover more than 275,000 similar short decisions—though InfoWorld also notes that these are Microsoft's own claims.

Benchmark comparisons are even more difficult because each vendor publishes its own test tables. AlphaSignal reported that pplx-decider scored 85.71% on 11 benchmarks and Jev scored 84.51%, but did not specify who conducted the tests. These numbers should be treated with caution when comparing across models.

Why latency numbers are hard to compare across models

The 8ms, 32.8ms, 115ms, and 70–500ms reported by different vendors may look similar, but the actual measurement conditions vary greatly. First, the hardware differs: the RTX 4090, T4, and RTX 3090 differ by multiples in compute power. The T4 is an older inference card, so getting 32.8ms doesn't necessarily mean the model itself is slow. Second, the input length for a "single decision" isn't always the same—the longer the state, the longer the forward pass. Some tests use short inputs, while others use full tickets.

Third, whether network round trips and queuing are included: the 8ms for local inference is pure compute time, while the hundreds of milliseconds for cloud APIs often include network and batch-processing waits. Fourth, batch size has a huge impact—merging multiple requests for inference on the server side can dilute per-call costs but raises tail latency. Finally, there's the difference between "median" and "average," and between cold start and steady state.

Therefore, vendor-reported latency can only be treated as an order-of-magnitude reference. To evaluate whether it meets your business SLA, you must do end-to-end stress testing on your own target hardware and your own real input distribution, focusing on P95/P99 rather than the average.

Limitations: It can't explain itself, and it's not good at complex tasks

Decision models cannot explain their judgments, nor can they generate any text. The Strands team candidly admits that Decider is significantly weaker than reasoning models on complex problems and is not suitable for programming, chatting, or summarization scenarios. The Laya team recommends no more than 20 options per question, because accuracy decreases as the number of options increases. Their testing also found that Laya scored 0% on Khmer text but reported an average confidence of 95.2%—a typical case of calibration failure.

Analysts cited by InfoWorld also expressed similar concerns. Amit Kumar Jena, AI Development Manager at Kanerika, pointed out: "A seemingly precise probability may give an uncertain decision more authority than it deserves."

How developers should use it now

Use decision models for routine judgments inside agents: routing customer service tickets, choosing tools, checking guardrail rules, or scoring outputs. Scenarios that require reasoning or text generation should still retain a full language model. The Strands team recommends this kind of hybrid agent architecture.

Before trusting probability numbers, run calibration tests with your own data. Use several hundred historical cases with known answers to verify whether 80% confidence really corresponds to 80% accuracy. Analysts cited by InfoWorld recommend starting with reversible decisions.

Compare prices based on real traffic. The cost of a request depends on the number of input tokens sent, and managed prices range from $0.02 to $0.24 per million. Clef is also compatible with Jev's API, so migration cost may be as little as changing a URL.

If data must stay in-house, open-weight models are the only choice. Laya, Clef, Decider, pplx-decider, and Liquid AI's d1 series can all run on your own hardware.

Typical patterns of hybrid agent architecture

The so-called hybrid architecture layers "cheap and fast judgments" with "expensive and strong reasoning." A common approach is: at each step, the agent first calls a decision model to make lightweight judgments—whether to continue, which tool to call, whether the output is out of bounds—and only escalates to a full language model when the decision model gives low confidence or encounters a task requiring text generation or multi-step reasoning.

This lowers the cost of high-frequency small decisions (decision models can be as low as $0.02 per million tokens, with free output) while preserving the language model's ability to handle complex tasks. In engineering, a confidence threshold can be set: execute directly above the threshold, and hand off to a large model or human below it. Since some decision model APIs are compatible with each other (for example, Clef is compatible with Jev's interface), switching vendors often only requires changing an endpoint address, which facilitates A/B comparisons and multi-vendor redundancy.

Note that the split itself introduces orchestration overhead and state-passing costs. The judgment logic should not be nested too deeply, otherwise the inference savings will be eaten up by scheduling complexity.

One-line Summary

Decision models are designed for high-frequency small decisions in AI agents. More than ten emerged within a month—fast and economical, but they need calibration.

Paragraph Summary

Decision models are a class of AI models that do not generate text and instead return calibrated probabilities for fixed questions, specifically serving high-frequency small judgments inside AI agents such as "whether to continue, which tool to choose, and whether the output is compliant." Starting with TypeSafe's Jev in September 2026, at least eight companies launched more than ten products within a month, divided into two paths: open weights (Laya, Clef, Decider, pplx-decider, and the d1 series) and managed services (Jev, OpenAI Decisions API, and Microsoft-Decision-1). The speed advantage comes from skipping token-by-token generation, but vendor-reported latency varies widely and benchmarks lack unified standards. The limitations are also obvious: they cannot explain themselves, are not good at complex reasoning, and carry confidence calibration risks. Developers should adopt a hybrid architecture and verify calibration with their own data before putting it into production.