CLM-v0.1-8B

CLM-v0.1-8B

Scores candidate answers, actions or tool names for a given state with a probability each, instead of writing text. A fast decision model on a frozen Qwen3-8B encoder, for agent and triage builders.

Made by Contrastive-LM on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: CLM-v0.1-8B is a Contrastive Language Model, built to make fast decisions rather than write text. Two small projection heads, one for states and one for actions, are added above the frozen Qwen3-8B encoder. They learn to match a state with the right action, using a bidirectional InfoNCE loss. You give it a state and options, and it returns a probability for each.

Who it suits: It suits developers who build agents or triage tools and need quick, scored decisions instead of generated text.

Industry | Who uses it | How they use it | Example
Customer support | Developers of support tools | Ask typed questions about a customer message | Urgency, team and frustration are scored for an invoice complaint
AI agents | Agent builders | Rank candidate tool names or next moves | The best tool name gets the highest probability
Software engineering | Teams that verify agent output | Score candidate solutions with fine-tuned heads | The card reports 81.6 on DeepSWE for fine-tuned heads

You can skip it if you need text written for you, since it only scores the candidates you supply.

Where to use it:

• Python, through the contrastive-lm package
• A vLLM server that serves Qwen3-8B embeddings
• A web playground that clm-serve runs on your own computer
• Windows, macOS or Linux with Python

Use case | Who | What they get back
Typed questions about a state | Support and product developers | Probabilities for yes or no, choice and score questions
Ranking free-form candidates | Agent builders | A ranked list with a probability for each candidate
Fine-tuning for a task | ML engineers | Heads trained cheaply, since only the heads change

How to set it up: You need Python, the package and a server for the encoder.

• Python with pip
• A vLLM server that serves Qwen3-8B as a pooling model
• Room for the CLM checkpoint, which clm-serve fetches into a cache folder on first run

1. Install the contrastive-lm package.
2. Start the encoder server with the vllm serve command.
3. Start clm-serve, which runs the API and a web playground and fetches the checkpoint.
4. Call the API from Python.

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

To download the model files yourself with the Hugging Face tools, use these two lines:

pip install -U huggingface_hub
hf download Contrastive-LM/CLM-v0.1-8B

How to use it: Create a client, then send a state with typed questions. Each answer carries a probability for every option. The card's example asks about a customer message:

from clm import CLMClient, Choice, Noul, Score

client = CLMClient()
r = 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"]),
    },
)
print(r.answers["department"].choice)         # billing
print(r.answers["department"].probabilities)  # {'billing': 0.93878, 'technical': 0.06122}

Tool | What it does
clm-serve | Starts the CLM API and a web playground, and fetches the checkpoint on first run
CLMClient | Python client that sends a state with typed questions
Choice, Noul, Score | Question types: pick one option, answer yes or no, or rate on ordered levels
Engine.rank | Ranks free-form candidates such as best-of-N solutions, tool names or next moves

Example: You send a message from a customer who was billed two times and cannot reach anyone by phone. You add three questions: is it urgent, which team should handle it, and how frustrated is the customer. The card shows the department answer as billing, with a probability near 0.94 against about 0.06 for technical.

For newcomers and experts: Think of it as a fast judge that picks among options you provide. A first small try is to run clm-serve and use its web playground with a short message and a few options.

Only the two heads are trained while the Qwen3-8B encoder stays frozen, so fine-tuning is cheap. Each state and each action goes through its own encoding step, so embeddings computed for actions can be reused later. The card reports that with about 1k candidates it is 13 times faster than Jev. Training used about 60M Nemotron Q&A pairs, about 30M synthetic hard negatives and about 1M agentic trajectories.

Encode the state with the Qwen3-8B encoder
Pass it through the state head
Encode each candidate with the action head
Match states to actions by similarity
Return a probability for each candidate

Good to know: Without any fine-tuning, the card reports results close to Jev on computer use, games and tool calling, at up to 9 times lower latency. The scores below come from fine-tuned heads, not from this checkpoint used as it is.

Title: Reported scores of fine-tuned heads
DeepSWE: 81.6%
Terminal-Bench 2.1: 87.6%

• Encoder-locked: the heads need embeddings from Qwen3-8B, taken from the last token
• No generation: it never writes text, and each probability is relative to the candidate set you supply
• Other versions: other people have published 9 quantized and 9 fine-tuned versions
• License: Apache 2.0, as listed on Hugging Face
• Cost to run: none named, but it needs a vLLM server for the encoder
• Data it reaches: the states and candidates you send to servers on your own computer, plus a checkpoint fetched on first run
• Not for: generating text

On Hugging Face, 13 November 2026

• Task: text ranking
• Library: contrastive-lm
• Downloads in the last 30 days: 1,092
• Likes: 794
• License: apache-2.0
• Languages: en
• Based on: Qwen/Qwen3-8B
• Quantized versions: 9
• Fine-tunes: 9
• Tags: contrastive-lm, contrastive-learning, verifier, reranker, agents, text-ranking

Links

• Model: https://huggingface.co/Contrastive-LM/CLM-v0.1-8B
• Files: https://huggingface.co/Contrastive-LM/CLM-v0.1-8B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Contrastive-LM/CLM-v0.1-8B

Then follow the usage in its model card. Nothing in this kit runs by itself.