CLM-8B vs Jev

CLM-8B is an open-weight "System One" decision model from Stanford and NVIDIA researchers, released in October 2026 under Apache-2.0. It's a different design from Jev: a dual-encoder that embeds your state and your candidate actions in a shared space and picks the closest match, rather than a model that picks from criteria you describe. The authors report it running up to 9x faster than Jev. Here's the honest comparison with hosted Jev — architecture, benchmarks, and when a candidate-ranking model beats a hosted one.

CLM-8B and Jev both return a bounded, typed decision instead of prose, but they get there differently. Jev reads a state plus typed questions (pick one of these criteria, score, yes/no) and returns a calibrated answer. CLM is a reranker: you hand it a state and a list of candidate actions, and it scores how well each candidate matches the state. That difference — picks-from-criteria vs ranks-the-candidates-you-supply — is the whole decision between them.

What CLM-8B is

CLM stands for Contrastive Language Models, a line of work from researchers at Stanford and NVIDIA (project lead Jacky Kwok, Stanford). CLM-8B is a dual-encoder: a frozen Qwen3-8B backbone with two small projection heads — one for states, one for actions — that embed both into a shared space, trained with a bidirectional InfoNCE contrastive objective. Because action embeddings can be computed once and cached, repeated decisions over the same fixed action set get very cheap, which is where its biggest speedups come from. The released checkpoint (CLM-v0.1-8B) is on Hugging Face under Apache-2.0, alongside open code, fine-tuning tools, a TypeSafe-compatible API and an interactive playground.

How it decides (and the catch)

CLM supports the familiar shapes — choose among options, yes/no probabilities, score on an ordered scale, and ranking candidates. The catch that matters in production: it only scores the candidates you give it. If every candidate you supply is wrong, it still returns the best of a bad set — there is no "none of these" unless you add it yourself. Jev's choice works against the criteria you describe rather than a candidate list, and its noul type gives you a calibrated yes/no you can threshold on. Neither is strictly better; they fit different problems.

Specs, side by side

The CLM column uses the authors' published figures; the Jev column uses TypeSafe's. Every number here is vendor/author-reported and zero-shot unless noted — CLM's own card compares against Jev, so read the scores as 'close to Jev on these tasks', not an independent ranking.

Where CLM shines: verifying candidates from a bigger model

CLM's strongest reported results are as a verifier — ranking candidate solutions generated by larger models. The authors report fine-tuned verifier heads at 81.6% vs Jev's 71.1% on DeepSWE (38 tasks) and 87.6% vs 83.1% on Terminal-Bench 2.1 (30 tasks), at 4.1–5.7x lower latency than Jev. Note the setup: a larger model generates the candidate fixes; CLM picks the best one. It isn't solving those tasks from scratch — it's a fast, cheap ranker sitting in front of an expensive generator.

The real trade-off

CLM-8B is a genuinely different tool from a hosted decision API: open weights, runs on your own hardware, and near-free marginal cost once action embeddings are cached — excellent for high-volume reranking and verifying a big model's output. The costs are that you run an 8B encoder, you own the calibration (its contrastive scores aren't RLCD-calibrated, so validate before thresholding), and it only ever ranks the candidates you feed it. Jev is hosted and calibrated: no inference to run, a yes/no you can trust a threshold against, and decisions framed by criteria rather than a candidate list. For a fixed action set you rank constantly, CLM is compelling; for load-bearing calibrated judgment with no ops, Jev earns its keep.

When to pick which

• Reach for CLM-8B when you have a fixed, reusable set of candidate actions to rank at high volume, want open weights you can self-host and fine-tune, or need a fast verifier in front of a larger generator — and you can afford to run and calibrate an 8B encoder.
• Reach for Jev when you want a hosted, RLCD-calibrated decision with honest confidence and pinned versions, decisions framed by criteria (not a candidate list), a calibrated yes/no to threshold on, and no inference to operate — plus a free browser playground to try one call first.
• They compose: let CLM rerank or verify candidates locally, and escalate the low-confidence tail to hosted Jev — both take a state-plus-bounded-answer-space call, so the handoff is a transport change, not a rewrite.

Make one real decision on Jev

The fastest way to judge any decision model is to run your own decision through it. Jev's playground does it in the browser with no signup, and a jv_live_ key points your code at the hosted endpoint:

// Hosted, calibrated decision — criteria in, a typed answer with confidence out.
const res = await fetch("https://jevtypesafeai.com/api/v1/decide", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${process.env.JEV_KEY}`, // jv_live_...
  },
  body: JSON.stringify({
    state: { ticket: ticket.body },
    questions: {
      triage: { type: "choice", instructions: "First-pass triage.",
                criteria: { resolve: "answerable now", escalate: "needs a human", spam: "not a real request" } },
      urgent: { type: "noul", instructions: "Is it urgent?" },
    },
  }),
});
const { answers } = await res.json();
if (answers.triage.choice === "escalate") handoff(ticket, answers.urgent.noul);

• VentureBeat — Stanford & NVIDIA's open CLM-8B runs up to 9x faster than Jev in tests — Architecture, zero-shot benchmarks vs Jev, caveats (author-reported)
• Hugging Face — Contrastive-LM/CLM-v0.1-8B — Open weights, Apache-2.0, model card: frozen Qwen3-8B + projection heads, InfoNCE

FAQ

See also: Jev alternatives · Strands Decider 2B vs Jev · JevBench · Run Jev-like models locally · What is a decision model · Playground