CLM vs Jev: The System 1 Decision Model Comparison

CLM and Jev are both System 1 decision models. Each takes a typed input and returns a typed decision, a choice, a score, a yes/no, instead of generating text. Jev is a proprietary, API-only model from TypeSafe AI. CLM is an open-weights model you can download, run locally, and fine-tune. For narrow internal logic like routing and classification, Jev beats a generative LLM on speed and cost. CLM often beats Jev on both, and you get to keep it.

Why generative LLMs are the wrong tool for routing decisions

Most internal software logic isn't a conversation. It's a lookup: which queue does this ticket go to, is this transaction fraudulent, should this agent call the refund tool or the escalation tool. Running that question through a generative LLM means paying for token-by-token generation, then parsing prose back into a structure your code can use. Frontier LLMs answer these questions in 3 to 329 seconds depending on the model, at input prices ranging from $0.20 to $10 per million tokens, plus roughly 5x that for output.¹²³ That's a lot of latency and spend for what's functionally a smart if-statement.

What is a System 1 decision model?

TypeSafe AI named the category when it launched Jev on September 15, 2026, calling it the first public "System One model."¹ The training method, Reinforcement Learning for Calibrated Decisions, skips text generation entirely and returns typed probabilistic outputs: a Choice among discrete options, a Noul (yes/no), or a Score.¹ Simon Willison picked up the framing fast, noting Jev charges only for input tokens, at $0.042 per million, undercutting even OpenAI's cheapest model on price.³ LangChain's engineering team found the architecture evaluates every question in a request in parallel, so stacking more questions into a call barely moves the response time.⁴ That split matters just as much for GUI and form-filling agents as it does for text routing, a distinction we cover in System 1 models vs. Jev. For a deeper walkthrough of what separates the category from a normal LLM call, see our explainer on Jev-class models.

Jev: the proprietary System One pioneer

Jev comes from TypeSafe AI, founded by ex-OpenAI RLHF researcher Diogo Almeida.¹ The pricing is aggressive: $0.042 per million input tokens, nothing for output.¹ TypeSafe reports end-to-end response times of 70 to 500 milliseconds, and its own workflow evaluations claim gains as high as 193.6x faster and 444.6x cheaper than frontier LLMs, figures the company itself frames as the top end of four selected tests, not a universal number.¹⁵

Adoption backs up the interest even if the multiples are cherry-picked. Within 24 hours of launching on Vercel's AI Gateway, Jev reached roughly 13% of paid Gateway teams, more than double the adoption rate of any previous model launch, about 2x GPT-5.6's share and 6x Fable 5.1's.⁶² Incresco's enterprise comparison puts Jev's model fees at roughly $38,000 a year for a team running 5 million decisions a day, with Jev automating 70% of those decisions while holding error rates at or under 5%.⁷ That's the economics of renting a narrow, well-tuned decision engine instead of a general-purpose LLM.

CLM: the open-weights, self-hostable challenger

CLM, short for Contrastive Language Models, is an Apache-2.0 model built specifically as a drop-in, API-compatible alternative to Jev.⁸⁹ Instead of RLHF-style training, CLM uses a bidirectional InfoNCE contrastive loss across three stages:

1. Pre-training on roughly 60 million Nemotron question-answer pairs.
2. Mid-training on 30 million synthetic hard negatives generated by Gemini 2.5 Flash-Lite.
3. Post-training on about 1 million agent trajectories.¹⁰⁹

The whole thing runs as a 75MB projection head sitting on top of a frozen Qwen3-8B encoder.⁸

The architectural difference that matters most: CLM disaggregates state and action into separate embedding heads. Jev evaluates the current state and every candidate choice jointly, in one pass. CLM embeds the state once and embeds each possible action separately, so a persistent tool or action set can be cached and reused across calls instead of recomputed every time.⁸⁹ In an agent loop that repeatedly checks the same handful of tools against a changing state, that caching is where the speed advantage comes from.

How do CLM and Jev compare on speed, cost, and ownership?

On interactive benchmarks like the T-Rex game, Super Mario, and browser or tool-calling agents, CLM-8B matches Jev's task success rate while running up to 9x faster zero-shot.¹⁰⁸ When roughly 1,000 candidate actions can be cached and reused, that gap widens to 13x.⁸

The bigger separation shows up once you fine-tune. On long-horizon coding benchmarks, a fine-tuned CLM sets new state-of-the-art verifier accuracy: 87.6% on Terminal-Bench 2.1 and 81.6% on DeepSWE, running 4.1x to 5.7x faster than Jev in the same tests.¹⁰⁸ Jev, evaluated zero-shot as a verifier on the same benchmarks, scored 71.1% on DeepSWE, below the pass@1 baseline of 73.7%, meaning it performed worse than just picking one random sample.¹⁰ Jev has no user fine-tuning path beyond prompt-level instructions. CLM's projection heads are small enough to fine-tune on a company's own agent trajectories, which is the whole point of running it yourself.¹⁰⁸

Ownership showed up fast in the wider ecosystem too. Within days of Jev's launch, Vercel co-founder Jared Palmer released Kev, an Apache-2.0 family of decision models reproducing Jev's API, built on Qwen3.5 for about $95 in H100 compute plus three cents in Jev API calls used for comparison data.¹¹ Kev-9B landed at 0.837 accuracy on a locked test set against hosted Jev's 0.857, close enough to prove the category doesn't require a proprietary lab to reproduce.¹¹

Where Jev still wins

The comparison isn't one-sided. On the Berkeley Function Calling Leaderboard v4, Jev scores 99.2% against CLM-8B's 95.2%.¹⁰ On WikiRacing, Jev goes 30 for 30 versus CLM's 26 for 30.¹⁰ Jev's broader zero-shot knowledge and calibration approach still edge out CLM on raw accuracy for open-domain tasks a self-hosted model hasn't seen fine-tuning data for.

Context window is the other gap. Jev is tested and calibrated up to 32K tokens on OpenRouter, with TypeSafe citing calibration to 64K.² CLM-8B is only tested and calibrated at 2K to 8K tokens, even though its Qwen3 backbone could technically accept more.² If your routing decision needs a long document in context, Jev currently has more runway.

Structured output isn't a security boundary

A typed decision model still reads whatever text you hand it, and that text can still carry an attack. Check Point's security research tested Jev against prompt injection embedded in documents it was asked to evaluate, and every attacker and difficulty combination flipped Jev's verdict, at an average cost of about $0.50 per successful break.¹² Marking the input as untrusted made no measurable difference.¹² The most effective defense Check Point found wasn't structural at all: turning on reasoning mode in a comparable LLM cut successful attacks from up to 100% down to 19% and raised the cost per break roughly eightfold.¹² Jev has no reasoning setting to enable, and neither does CLM in its current form. If you're routing agent actions through either model, treat the decision layer as a target, not a shield.

Why this matters for locally-owned AI routing

Jev proved the economics of the System 1 category: cheap, fast, typed decisions beat a generative LLM for the routing and classification work most software actually needs.¹⁶ CLM proves those economics don't require renting anyone's API. You can run the model on your own GPU, cache its action embeddings across your own tool set, and fine-tune the whole thing on your own agent logs. That's the difference between metered access to someone else's decision engine and owning the decision layer outright. The same shift shows up in running frontier-class models locally for enterprise workloads: past a certain call volume, a self-hosted router stops being a curiosity and starts being the cheaper, more auditable option. The same logic applies to the routing layer itself, whether you build it in-house or evaluate a gateway, as we lay out in our comparison of multi-model orchestration approaches. It's also the premise behind platforms built to help teams stand up and manage that kind of owned routing layer, like Remy, rather than defaulting to a vendor's black box for every decision.

How to evaluate a decision model in your own stack

Before you swap a generative LLM call, or a Jev subscription, for a self-hosted CLM deployment, run a structured evaluation rather than a gut check:

1. Pick a bounded task. Choose a decision with a small, stable set of outcomes, like ticket routing or a yes/no fraud flag, not an open-ended judgment call.
2. Set a real baseline. Measure your current system's accuracy, latency, and cost per decision before touching anything, using actual production traffic.
3. Run in shadow mode. Let the decision model score live traffic alongside your existing logic without acting on its output, and compare the two over at least a few thousand decisions.
4. Fine-tune on your own data. If CLM's zero-shot accuracy trails Jev's on your task, that gap is exactly what the fine-tuning path exists to close, since Jev has no equivalent lever.
5. Keep a fallback path. Route low-confidence scores to a human or to the slower, more capable model you were using before, so a wrong decision doesn't ship silently.

That sequence mirrors HatchWorks' enterprise framing of decision models as filling a specific niche between deterministic code and full generative LLMs, not replacing either outright.²⁵ The niche is real. Whether you rent it from TypeSafe or run it yourself on CLM is now a build-versus-buy decision, not just a preference.