Stay connected with KayaToday, follow us on Instagram and Facebook for the latest news and reviews delivered straight to you.
Every time an AI agent picks a tool, routes a request, or checks whether a proposed answer is correct, it is burning compute. Most of today’s systems handle these bounded decisions by running a full generative language model, which processes a prompt and produces tokens one by one, even when the only output the application actually needs is a single choice from a known list. That mismatch between the architecture and the task is what a new model from Stanford and Nvidia is designed to fix.
The researchers have released Contrastive Language Models (CLM), along with an 8-billion-parameter model called CLM-8B, built specifically for the kind of selection and ranking decisions that appear constantly inside agentic workflows. In zero-shot tests across computer use, gaming, and tool calling, CLM-8B ran up to 9x faster than TypeSafe’s Jev, a competing decision-focused model released on September 15. It matched Jev’s success rate on two game tasks, though it gave up some accuracy elsewhere, scoring 95.2% against Jev’s 99.2% on the BFCL v4 tool-calling benchmark and completing 26 of 30 WikiRacing tasks compared to Jev’s perfect 30.
Turning Selection Into a Matching Problem, Not a Generation Problem
The core architectural idea is straightforward once you see it. CLM does not generate the name of an action token by token. Instead, it learns a shared embedding space where states and actions can be compared directly. A state is what the model currently knows about a task. Actions are the available choices. During training, CLM is taught to pull correct state-action pairs closer together in that embedding space while pushing incorrect pairs further apart. At inference time, it encodes the current state, compares that representation against the encoded candidates, and picks the closest match.
The training method behind this is called InfoNCE, a contrastive objective that presents the model with one correct state-action pair alongside several incorrect ones and rewards it for assigning the highest similarity score to the correct match. The researchers trained CLM-8B in three stages: roughly 60 million question-answer pairs for broad semantic matching, around 30 million synthetic hard negatives to sharpen discrimination between similar but distinct options, and approximately one million agent trajectories to adapt the model to real agent decision patterns. The backbone is a frozen Qwen3-8B, with separate trainable projection heads for states and actions.
That separation is where the practical speed advantage comes from. Because the state and action encoders are independent, a deployment can pre-compute and cache the embeddings for any fixed set of actions. An enterprise running an internal IT agent with 50 approved actions, such as resetting a password, provisioning access, opening a ticket, or escalating to security, can encode all 50 once and keep those representations ready. Each new request then only requires encoding the incoming state and scoring it against the cached action set, rather than reprocessing all 50 options as part of a generative prompt every single time.
Where the Speed Gains Actually Show Up
The largest speedups in the team’s tests appeared when the model could reuse actions across many states or choose from a large candidate set. That is a realistic description of most production agentic systems, where the available tools and workflows are relatively stable while the context changes with every user request.
Latency compounds in multi-step agents in ways that are easy to underestimate. A single routing call that takes a fraction of a second longer than necessary might be invisible to a user. But when an agent makes dozens of routing, ranking, and verification decisions before returning a final answer, those delays stack up. CLM’s inference pattern removes the autoregressive generation step entirely for these bounded decisions, which is where the latency reduction originates.
The researchers also tested CLM as a verifier for coding tasks, a use case that illustrates a different kind of value. In these experiments, larger frontier models generated candidate solutions: Opus 5 produced candidates for DeepSWE tasks and Fable 5 for Terminal-Bench 2.1 tasks. A fine-tuned CLM then ranked those candidates and selected one for submission. On held-out subsets, CLM reached 81.6% on 38 DeepSWE tasks and 87.6% on 30 Terminal-Bench 2.1 tasks, compared with 71.1% and 83.1% for Jev on the same subsets. CLM’s verifier latency was 4.1 to 5.7 times lower than Jev’s in these tests. The important caveat is that CLM did not solve the coding problems from scratch. It only selected among candidates that a larger model had already generated.
Project lead Jacky Kwok of Stanford described the intended division of labor to VentureBeat this way: “Use large reasoning models to generate and reason, and use CLMs to cheaply select, verify, and monitor their outputs.” The economic logic follows from that framing. If several cost-efficient open-source models generate candidate responses or actions and a CLM rapidly ranks them, the system avoids routing every decision through an expensive frontier model.
What CLM Cannot Do, and Who It Competes With
Kwok is direct about the model’s limits. “I would not use a CLM as a replacement for a general-purpose reasoning model on tasks that require substantial open-ended reasoning, such as solving a math problem, generating a long-form response, or doing high-level planning,” he told VentureBeat. CLM is suited to situations where the available choices are already known and the model needs to select, rank, or verify among them. Open-ended generation is not its job.
CLM also has an important structural limitation as a verifier. It only scores the candidates it receives, and its probabilities are relative to that candidate set. If every proposed action in the set is wrong, CLM still has to rank them and will still return a winner. That ceiling matters for any team considering it as a safety or monitoring layer.
The competitive landscape around this “System One” model category is taking shape quickly. TypeSafe introduced Jev on September 15 with a training method it calls Reinforcement Learning for Calibrated Decisions. Laya takes a different approach using smaller bidirectional encoders. CUA-S1 focuses narrowly on bounded action selection for form-filling tasks. CLM’s distinguishing claim, according to Kwok, is its dual-encoder architecture. “A key difference between CLM and models like Jev or Laya is the architecture,” he said. Jev and Laya primarily support caching the state representation, while CLM can compute and cache state and action embeddings independently, which becomes more valuable when both the context and the candidate actions are long.
The team has released CLM-8B weights under the Apache 2.0 licence alongside open-source code, a TypeSafe-compatible API, fine-tuning tools, and an interactive playground. Kwok confirmed that CLM-8B is one step on a scaling ladder the team is using to study how performance changes with model size. A multimodal CLM-35B-A3B is now in training with more data and compute, with a release planned for early October, and the team is adding substantially more agentic training data to improve integration with existing agent harnesses and workflows.
The broader significance of CLM is less about any single benchmark number and more about what it signals for how agentic AI systems will be built. The assumption that a single generative model should handle both open-ended reasoning and fast bounded decisions is increasingly being questioned. Specialised decision layers that sit alongside generative models, handling selection and verification at lower cost and latency, could become a standard part of enterprise AI architecture. For businesses in Malaysia and Singapore building or procuring agentic systems, the practical question is not whether CLM specifically wins this emerging category, but whether the architectural pattern it represents becomes the default way to keep multi-step agents fast and economical at scale.
Read More: OpenAI Cuts API Prices in Half With GPT-6 Sol and Luna, Forcing a Rethink of How Enterprises Buy AI
