CLM-8B: How Contrastive Language Models Speed Up AI Agent Decisions

Most of the models an agent calls are asked to write: a plan, a tool call, an answer. Many of an agent's decisions are not writing tasks at all. Which tool should run next? Which of four candidate patches is most likely correct? Is this ticket urgent? CLM-8B, released by Contrastive-LM in September 2026, is built for exactly those decisions. It does not generate text. It scores candidate actions against the current state and returns probabilities. This article explains how it works and what its published results show, drawing on the project's GitHub repository and Hugging Face model card, MarkTechPost's coverage and Superpower Daily's analysis.

What a "System One" model is

The authors describe a contrastive language model (CLM) as "a new class of System One model trained with a contrastive learning objective that connects states and actions". System One is their framing for fast, intuitive decisions, as opposed to the slower, deliberate reasoning of generating text step by step. CLM-8B is the first open model of this kind.

The comparison point throughout is Jev, TypeSafe AI's proprietary System One model, in limited early access since September 15, 2026. Jev returns typed values with probabilities, and CLM serves a TypeSafe-compatible API, so a request written for TypeSafe can be replayed through CLM's client.

The CLM authors are Jacky Kwok, Hangoo Kang, Tarun Suresh, Jon Saad-Falcon, Marco Pavone, Christopher Ré and Azalia Mirhoseini. The weights and code are released under Apache 2.0.

How CLM works

CLM-8B keeps a Qwen3-8B encoder frozen and trains two small projection heads on top of it, about 20M parameters each: a state head and an action head. The model card puts the head at about 75 MB. Training uses a bidirectional InfoNCE loss, which pulls each state towards the actions that fit it and away from the ones that don't.

Two consequences follow. There is no decoding loop, so a decision costs one encoder pass per new input rather than many generated tokens. And the probabilities are relative to the set you supply: CLM tells you which of your options fits best, not what option you forgot to list.

Why it's fast: disaggregated, cached embeddings

Because states and actions are encoded separately, their embeddings can be cached and reused. A fixed toolset, a list of routing destinations or a rubric only has to be encoded once. The project reports p50 latencies on an RTX 4090 with the vector cache:

The cache barely helps when every state is new, but for revisited states it makes scoring about 2.8x faster. The model card adds that with around 1,000 candidates, CLM is 13x faster than Jev.

The training recipe

Replay matters in the last stage. With 40% replay data, hard-negative accuracy barely moves (69% to 68.5%) while the model learns agent behaviour. Training on agentic data alone drops it to 56.2%.

Results vs Jev

The tradeoff: faster everywhere, not better everywhere

Superpower Daily's reading of the results is the right one: CLM was faster than Jev on all four tasks, but trailed it on two of them — tool calling on BFCL v4 and WikiRacing. On the two game tasks both models succeeded every time. If your decision is latency-bound and the options are clear, the speed is a straight win. If a wrong tool call is expensive, the accuracy gap on BFCL v4 matters more than the milliseconds.

As a verifier: picking the best of N

The strongest numbers come from using CLM as a verifier: generate several candidate solutions with a large model, then let CLM pick one. The authors fine-tuned the heads for this, evaluated on held-out subsets and ran on an H100.

Scaling laws

The authors report that the InfoNCE loss falls as a power law in compute, data, head size and encoder size, with encoder size giving the strongest gains. The optimal head size grows roughly in proportion to the data (∝ D^1.02), at about 310 tokens per parameter. A multimodal CLM-35B is announced for early October 2026.

How to run it

CLM needs one NVIDIA GPU under Linux. vLLM serves the Qwen3-8B pooling encoder on port 8090, and clm-serve exposes the CLM API and a playground on port 8700. States longer than 2,048 tokens are truncated by default.

pip install contrastive-lm
vllm serve Qwen/Qwen3-8B --served-model-name qwen3-8b --runner pooling --max-model-len 2048 --port 8090 &
clm-serve

The API has three question types: Noul (the probability a statement is true), Choice (pick one option, with probabilities) and Score (the expected level on an ordered rubric). The endpoints are POST /v1/systemone, POST /v1/rank, GET /v1/models and GET /health. The project's example routes a support message:

from clm import CLMClient, Choice, Noul, Score

# ... create a CLMClient pointed at clm-serve, then:
client.system_one(
    state="Customer: my invoice was charged twice and nobody answers the phone!",
    questions={
        "urgency": Noul(instructions="Is this urgent?"),
        "department": Choice(
            instructions="Which team should handle this?",
            criteria={"billing": "Charges, invoices, refunds", "technical": "Bugs and outages"},
        ),
        "frustration": Score(
            instructions="How frustrated is the customer?",
            criteria=["Calm", "Frustrated", "Very angry"],
        ),
    },
)
# department -> billing {'billing': 0.93878, 'technical': 0.06122}

Limitations

• Encoder-locked: CLM-8B depends on Qwen3-8B's last-token pooled embeddings.
• No generation: it only scores options you provide, and its probabilities are relative to that set.
• The state-of-the-art verifier numbers need fine-tuned heads.
• Text only for now; the multimodal CLM-35B is announced for early October 2026.

Where it fits in an agent

The repository lists four uses: ranking best-of-N trajectories, routing tools, shortlisting retrieval pools and making typed decisions. In an agent built as a graph, those map onto specific nodes:

The confidence gate is our recommendation, not part of CLM: because probabilities are relative to your options, a flat distribution is a useful signal that none of them fit. For how router and verifier nodes fit into a larger design, read what graph engineering is. The weights are on the Hugging Face Hub; our guide to Hugging Face for AI engineering uses the CLM-8B release as its worked example.