CLM-8B is an open-source contrastive language model from Stanford's Scaling Intelligence Lab and NVIDIA Research. It encodes agent states and candidate actions into a shared embedding space and selects actions by cosine similarity, bypassing autoregressive token generation for bounded decisions like tool selection or ticket routing.

How fast is CLM-8B compared to Jev?

The Stanford/NVIDIA team reports up to 9x lower latency in zero-shot tests where agent actions are cached. Independent evaluations note that this advantage narrows significantly when actions change dynamically, because CLM must run a full Qwen3-8B forward pass for each new action candidate.

What is a System One model for AI agents?

System One models handle fast, bounded decisions inside agent loops, such as routing a request to the right tool, ranking candidate outputs, or checking whether an action is safe. They complement large reasoning models that handle open-ended generation.

Where does CLM-8B work best in enterprise settings?

CLM-8B is strongest when the available actions are fixed or rarely change, such as an IT service desk with 50 approved tasks, a document router, or a best-of-N verifier that picks among outputs generated by a larger model.

Is CLM-8B ready for production?

CLM-8B v0.1 is an early release suited for experimentation and integration into existing agent pipelines. A larger multimodal CLM-35B-A3B is in training and expected in early October 2026. The team recommends pairing CLM with a frontier reasoning model for open-ended tasks.

Stanford/NVIDIA CLM-8B: Open System One Model for Agent Routing

Researchers at Stanford’s Scaling Intelligence Lab, Hazy Research, and NVIDIA Research released CLM-8B on September 23, 2026, under an Apache 2.0 license. The model represents a new design point for the routing and verification work that happens inside AI agent loops: instead of asking a generative model to produce the name of a tool or confirm a yes/no decision, CLM turns that choice into a vector similarity problem.

As of this writing, the CLM GitHub repository has 1,297 stars and includes weights, a serving engine, client libraries, and a TypeSafe-compatible API ready to drop into existing agent pipelines.

What CLM-8B does differently

Most agent frameworks today route requests by presenting the full list of available tools to a frontier model and letting it generate a function name. The mechanics work, but they are wasteful: the model processes every option as text, produces tokens, and the caller parses the result, even when the choice is deterministic given the context.

CLM-8B starts from a different premise. It trains a state encoder and an action encoder separately, using a contrastive objective (InfoNCE) that pulls correct state-action pairs together and pushes mismatched pairs apart. At inference time, scoring a candidate action requires only a dot product between the cached action embedding and a freshly computed state embedding.

The practical consequence is caching. When an enterprise agent works with the same 50 tools day after day, CLM can encode those 50 actions once and keep the results in memory. Every subsequent routing call encodes the current context and compares it to the pre-computed embeddings rather than reprocessing the full action list through a generative model.

Project lead Jacky Kwok (Stanford) frames the division of labor this way: “Use large reasoning models to generate and reason, and use CLMs to cheaply select, verify, and monitor their outputs.”

Benchmark results: what holds up and what to treat carefully

The Stanford/NVIDIA team reports two categories of results.

Zero-shot evaluation across computer use, gaming, and tool calling:

Benchmark	CLM-8B	Jev
BFCL v4 tool calling	95.2%	99.2%
WikiRacing (26/30 tasks)	86.7%	100%
T-Rex game	Comparable	Comparable
Latency vs. Jev (cached actions)	Up to 9x faster	Baseline

As a best-of-N verifier after lightweight fine-tuning (vs. Jev):

Benchmark	CLM-8B	Jev
DeepSWE (38 held-out tasks)	81.6%	71.1%
Terminal-Bench 2.1 (30 tasks)	87.6%	83.1%
Latency as verifier (H100)	4.1-5.7x faster	Baseline

The verifier results are particularly notable: Jev fails to serve as a best-of-N verifier on these long-horizon coding tasks at all, while CLM reaches new state-of-the-art numbers after only fine-tuning the small projection heads (not the frozen Qwen3-8B backbone).

Important caveats from independent evaluations: A detailed benchmark by Zenn developer null_teck found that CLM-8B’s real-world latency advantage depends heavily on two conditions. First, the 9x speedup partially reflects comparing local GPU execution against cloud API round-trip latency, not an architectural improvement per se. Second, when agent actions change dynamically (such as evaluating evolving hypotheses rather than a fixed tool list), the cache hit rate drops to zero and CLM must run full forward passes through its 8B backbone for every candidate, which is slower than dedicated decision models like Kev-4B on some hardware setups.

CLM also shows limited abstention behavior: in tri-state routing tests (certain/uncertain/impossible), it assigned less than 2% probability to the “uncertain” category versus 75% for Jev. Enterprises that need an agent to escalate ambiguous decisions to human review should be aware of this gap.

The official team’s recommendation is clear: CLM is best suited to tasks with large but stable action spaces and to best-of-N verification, not as a drop-in replacement for every decision a generative model currently handles.

The emerging System One model landscape

CLM-8B arrives alongside several projects clustering around what TypeSafe calls “System One” models: fast, bounded decision layers inside agent loops that do not require full autoregressive generation.

TypeSafe introduced Jev on September 15 as a proprietary System One model trained with Reinforcement Learning for Calibrated Decisions. CLM adds an open, contrastive alternative. Kev-4B (Jared Palmer) uses DeltaNet linear attention with dedicated multi-head decision architecture. CUA-S1 focuses specifically on form-filling and bounded web actions.

The architectures differ in one key way that matters at scale: CLM’s dual-encoder design lets it cache state and action embeddings independently. Jev and Laya primarily cache the state representation. For enterprise workloads with thousands of concurrent agent runs choosing from a stable set of internal tools, that difference in caching can mean meaningfully lower infrastructure cost.

Practical enterprise use cases

Internal IT and ITSM agents. An IT help-desk agent with 50 approved actions (reset password, provision access, open ticket, escalate) is an ideal CLM workload. Actions rarely change, so they are encoded once. The agent scores each incoming context against the 50 cached embeddings in milliseconds.

Document routing and triage. Enterprise document workflows often route items to one of dozens of queues or handlers based on content. CLM can score the document state against the handler embeddings and produce a ranked list without invoking a frontier model for every routing decision.

Best-of-N verification at scale. When a coding agent or document agent generates multiple candidate solutions, CLM can act as a cheap verifier that picks the best one. The Stanford team shows that Opus 5 generating candidates plus CLM selecting delivers 81.6% on DeepSWE, better than Jev as a verifier on the same task. This is a practical architecture for reducing the cost of best-of-N sampling in production.

Agent monitoring. The team reports that CLM scores show a clear separation between successful and failed agent trajectories. A CLM running alongside a long-horizon agent can flag when the trajectory score starts to deviate, providing an early signal for human review. This is a complementary layer alongside explicit guardrails, not a replacement.

What CLM is not suited for: open-ended creative or analytical tasks, decisions that require calibrated uncertainty or abstention, and workloads where the candidate actions change frequently per request.

Training data and architecture

CLM-8B uses a three-stage pipeline on a frozen Qwen3-8B backbone:

Pre-training: 60 million Nemotron question-answer pairs
Mid-training: 30 million synthetic hard negatives (contrasting similar actions)
Post-training: 1 million agentic trajectories from the Agent Data Protocol (ADP) dataset and terminal traces

Only the 20-million-parameter projection heads are trained; the Qwen3-8B encoder is never updated. This keeps fine-tuning costs low when adapting CLM to a domain-specific action space: you train the heads, not the full model.

The published scaling laws show that contrastive loss decreases predictably as a power law in training compute, model size, and dataset size, which gives the research direction a foundation for systematic improvement.

What comes next

The team has confirmed a multimodal CLM-35B-A3B checkpoint is in training with more data and more compute, targeting a release in early October 2026. That model is expected to handle image and structured-data inputs alongside text states, which expands the surface area for computer-use and document-processing agents.

A TypeSafe-compatible API is already shipping at /v1/systemone, alongside fine-tuning tutorials and a playground for testing state-action pairs interactively. For enterprise teams already using Jev, CLM is designed as a drop-in alternative at the same API surface.

For AI builders running agents at scale, CLM-8B is a well-timed open-source contribution to a part of the stack that most frameworks still handle with full generative calls. The caveats are real, but the pattern it introduces, particularly for best-of-N verification and stable-toolset routing, is worth evaluating now rather than waiting for the 35B release.

Sources: Contrastive-LM GitHub, VentureBeat, Ben Dickson, Sept 25, AlphaSignal, Sept 24, Independent benchmarks, Zenn