# CLM-8B makes System One decision models open and locally deployable

Stanford Hazy Research and NVIDIA researchers have released CLM-8B under Apache 2.0, giving builders a self-hostable model that ranks bounded actions instead of generating prose and can cache reusable action representations.

CLM-8B targets the same narrow decision layer as Jev, but with open weights, local deployment and a contrastive architecture that separates state and action representations. The headline speed and coding results are researcher-produced and need careful interpretation.

- Status: Active
- Published: 2026-09-26T14:36:20+12:00
- Updated: 2026-09-26T14:36:20+12:00
- Categories: Artificial Intelligence, AI Models, AI Agents, Open Models, Inference & APIs
- Tags: CLM-8B, Contrastive Language Models, decision models, open models, Qwen3-8B, System One models
- Canonical HTML: https://beyondthe.news/dossiers/clm-8b-open-system-one-decision-model-action-caching

## What changed

Researchers associated with Stanford Hazy Research and NVIDIA Research released CLM-8B, the first public Contrastive Language Model in their new System One model family. Instead of generating free-form text, CLM scores a supplied set of candidate actions against the current state and returns relative probabilities. The reference implementation uses Qwen3-8B as a frozen encoder with small trainable projection heads, is released under Apache 2.0, and can be served locally with vLLM. The project also exposes a TypeSafe-compatible API, making workloads written around Jev's decision interface easier to compare directly.

## Why it matters

Jev made the case that software often needs a fast bounded decision rather than another generated paragraph. CLM-8B makes that architectural idea inspectable and self-hostable. Its separate state and action encoders also create a practical optimisation: action embeddings can be cached and reused when the candidate set is stable, potentially reducing repeated decision latency. For builders routing tools, ranking options, verifying agent work or making policy decisions, this creates an open alternative to proprietary decision APIs rather than forcing every bounded judgement through a general-purpose generative model.

## It scores candidates instead of generating an answer

CLM encodes the current state and each candidate action separately, then scores their compatibility in embedding space. The model therefore assumes the application already knows the allowed action set. That is a narrower job than open-ended reasoning, but it maps cleanly to routing, tool selection, classification, ranking and verifier workloads.

## Caching is the architectural trick

Because states and actions are encoded independently, stable action embeddings can be cached rather than recomputed for every decision. The project reports its largest speedups when candidate sets become large. Those measurements are produced by the CLM team and should be validated on the target hardware and workload before being treated as production expectations.

## The open release is more than a hosted endpoint

The repository provides serving code, a local playground, evaluation tooling and fine-tuning instructions. The published CLM head is about 75 MB, but deployment still requires the Qwen3-8B encoder, so the small head size should not be confused with the total runtime footprint.

## The coding benchmark numbers need qualification

The project reports 81.6% on DeepSWE and 87.6% on Terminal-Bench 2.1 when CLM is fine-tuned as a verifier. Those are not the zero-shot numbers of the base checkpoint and do not mean CLM-8B is itself a standalone coding agent. The useful claim is that a specialised decision model can cheaply rank or verify candidate agent outputs.

## Key details

- CLM-8B was publicly released in September 2026 by researchers associated with Stanford Hazy Research and NVIDIA Research.
- The weights and reference code are released under Apache 2.0.
- The model uses a frozen Qwen3-8B encoder plus trainable contrastive projection heads.
- The reference head checkpoint is about 75 MB, but the Qwen3-8B encoder is also required.
- CLM scores supplied candidate actions rather than generating free-form text.
- State and action representations are separated so either side can be cached and reused.
- The project exposes a TypeSafe-compatible API for direct comparison with Jev-style decision workloads.
- The team reports up to 9x lower latency than Jev on selected tasks; this is researcher-produced benchmarking.
- Fine-tuned verifier results of 81.6% on DeepSWE and 87.6% on Terminal-Bench 2.1 do not describe zero-shot base-checkpoint performance.

## Builder takeaways

- Consider a bounded decision model when your application already knows the legal choices and only needs ranking or probability rather than generated prose.
- Benchmark CLM locally against Jev and against your existing classifier or LLM call on the same labelled decisions; do not transfer headline latency claims blindly.
- Exploit cached action embeddings when the candidate set is stable across many requests, because that is where the architecture has a structural advantage.
- Keep a generative or reasoning fallback for cases where the correct action is not present in the supplied candidate set.
- Treat verifier benchmark scores as evidence for a specialised pipeline component, not as evidence that CLM replaces a coding agent.

## What to watch

- Independent latency, calibration and accuracy comparisons with Jev on production-style routing and tool-selection workloads.
- The planned larger multimodal CLM model and whether the caching advantage survives at larger scale.
- Adoption of the TypeSafe-compatible interface by agent frameworks and inference providers.
- Whether fine-tuned CLM verifiers improve end-to-end agent success enough to justify the additional model in production pipelines.

## Uncertainties

- Most performance numbers currently come from the model's own researchers rather than independent replicated benchmarks.
- CLM only ranks the candidate actions supplied to it; it cannot invent a missing action.
- The published verifier benchmark results require task-specific fine-tuning and should not be attributed to the base checkpoint zero-shot.
- Real-world cost and latency depend on GPU choice, serving configuration, candidate count and cache reuse.

## Sources

- [Contrastive Language Models](https://github.com/Contrastive-LM/CLM) — Contrastive-LM · primary_repository · 2026-09-23T00:00:00+12:00. Primary code release, architecture, serving path, training description and benchmark claims.
- [CLM-v0.1-8B model card](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) — Hugging Face / Contrastive-LM · primary_model_card · 2026-09-24T00:00:00+12:00. Model requirements, licence, limitations, caching claims and distinction between zero-shot and fine-tuned verifier results.
- [Stanford and Nvidia's open CLM-8B caches reusable agent actions and runs up to 9x faster than Jev in tests](https://venturebeat.com/technology/stanford-and-nvidias-open-clm-8b-caches-reusable-agent-actions-and-runs-up-to-9x-faster-than-jev-in-tests) — VentureBeat · secondary · 2026-09-25T00:00:00+12:00. Independent specialist reporting on the release and its comparison with Jev.
- [CLM-8B Chooses the Next Action Instead of Writing the Next Sentence](https://egoistai.com/articles/contrastive-language-models-action-selection/) — EgoistAI · secondary · 2026-09-25T00:00:00+12:00. Independent technical framing that explicitly distinguishes fine-tuned verifier results from a standalone coding agent.