Open Jev Alternatives: A Field Guide to the Variants

On September 30, Maincode released Matilda Jev, a 26.1B open-weights decision model. It ships its own server for the same typed-question format that TypeSafe’s Jev uses. It’s the largest Apache-2.0 entry with a drop-in server. It isn’t the first.

TypeSafe released Jev in mid-September. In the three weeks since, independent authors have published about a dozen open models that copy, borrow from, or loosely resemble it. The ModelSystem.One catalog tracks most of them. Sizes range from 0.6B to a 35B mixture-of-experts. Some are drop-in servers. Others share only the name.

In our previous post, we looked at where to put a decision model in your system. This post answers the next question: which model? We read the catalog entries and model cards for each variant. We sorted them by what you’d actually need to know before running one.

Key Takeaways

• “Jev” now names a contract, not one model: a state plus typed questions in, calibrated probabilities out. The open variants honor that contract to very different degrees.
• Only a few speak the same wire format. Matilda Jev, Jev-Style, and RSI-Jev serve a local /v1/systemone endpoint. Others use their own output shapes or a different task entirely.
• The two 27B models share a base, Qwen3.8-27B, but not a license. Matilda Jev is Apache-2.0. OpenJev 27B is CC BY-NC 4.0, so commercial use needs a separate deal.
• Almost every score is author-reported, on different benchmarks, and often in-domain. You can’t rank these models from their cards.
• Before switching, run your own labeled cases through the open model and hosted Jev side by side, in shadow.

What makes a model “a Jev”?

Jev is TypeSafe’s first “System One” model. You send a state, as text or JSON, plus a set of named questions. Each question declares its type, per TypeSafe’s docs and OpenRouter’s Jev guide:

• Choice picks one option from a list of up to 255 that you define, with a probability for each.
• Noul is TypeSafe’s yes/no type. It returns the probability that a statement holds.
• Score places the state on an ordered scale, with a probability per level.

No text is generated. Output tokens are free, and input costs $0.042 per million tokens. Jev 1.13, the current hosted version, takes up to 32,000 tokens of state and questions.

That contract is easy to describe and hard to match. An open model can match it at three levels, and the level decides how much work a switch takes.

1. Wire-compatible. It serves the same request shape over HTTP. Your client code changes a base URL.
2. Contract-compatible. It answers choice, noul, and score questions with probabilities, but through its own API or a Python call. You write an adapter.
3. Inspired by. It does something related, such as classification or entailment. You rethink the integration.

The variants at a glance

“Reported result” is what each author or catalog entry claims. None of it is independently verified, and the benchmarks differ from row to row.

Model	Author	Base	Size	License	Compatibility	Reported result
Matilda Jev v1	Maincode	Qwen3.8-27B	26.1B	Apache-2.0	Wire (/v1/systemone)	~59 to 60 self-reported on the Decision Index harness, vs 57.91 for Jev 1.13
OpenJev 27B	openjev	Qwen3.8-27B	27B	CC BY-NC 4.0	Contract (up to 52 options)	84.0% vs 85.4% for hosted Jev, 10,000 questions
Jev-Omni	Akhila Datta	Gemma 4 12B	~12B	Apache-2.0	Contract, own output shape	86.15% matched on JevBench
Jev-Style 2B	chaoliangUNSW	Not stated	2B	Not stated	Wire (/v1/systemone)	73.6% vs 86.6% for hosted Jev, JevBench v1.4.1
Jev-Style 0.8B v3	chaoliangUNSW	Not stated	0.8B	Not stated	Wire (/v1/systemone)	9.5 points below the 2B
RSI-Jev v3.0	Shanghua Gao	Qwen3.5-2B	2B	Apache-2.0 weights, MIT code	Wire (/v1/systemone)	Suite mean 0.756, mostly in-domain
Tiny-Jev	lostargon	Qwen3-0.6B	0.6B	Apache-2.0	Contract (Python)	95.8% in-distribution
NanoJev	NanoJev project	Qwen3-0.6B	0.6B	Open source	Contract	77.8% test, 76.6% OOD on game tasks
open-jev-deberta-v3-large	kotoba-lang	DeBERTa-v3-large	Encoder	Open weights	Contract, ~512-token context	0.854 in-domain, 0.690 on new questions
openjev	AlexWortega	Qwen3.5	0.8B to 35B MoE	MIT	Inspired by (NLI)	ANLI r3 0.42 to 0.63, v1 to v2
mini-jev	Not stated	Qwen3-4B, frozen	4B	Not stated	Inspired by (teaching)	Roughly matched JSON grammar on CLINC150

The 27B drop-ins: Matilda Jev and OpenJev 27B

These two are the closest thing to self-hosted Jev. Both fine-tune the same base, Qwen3.8-27B, and both report results near the hosted model.

Matilda Jev is the most complete port. Its model card lists choice, noul, and score questions, text or JSON state, and optional images. It has a 255-option readout, matching Jev’s choice limit. The bundled runtime applies a stored calibration temperature. It serves POST /v1/systemone, so a client written for the System One format can point at it.

Maincode’s card reports about 59 to 60 overall across 150,317 requests, using the community Decision Index harness. The ModelSystem.One launch note lists Jev 1.13 at 57.91 for comparison. Matilda’s score is self-reported and wasn’t yet on the official board at launch. The card’s area scores are uneven: 79.07 on tools and automation, but 46.84 on knowledge and reasoning.

The card is also honest about scope. The listed run is “not a full benchmark rerun or continued-training run.” It was validated on AMD MI355X hardware only, and it publishes no latency figures. The bf16 weights take about 49 GiB.

OpenJev 27B reads text, JSON, web pages, and screenshots. Its catalog entry reports 84.0% on 10,000 questions, against 85.4% for hosted Jev. It’s strong on screenshot navigation (88.0%) and weaker on knowledge-heavy questions. It handles up to 52 options per question, not 255. Short text decisions take about 80 ms on an H100, and quantized builds fit a 24 GB GPU.

The difference that matters most is the license. OpenJev 27B ships under CC BY-NC 4.0. You can’t use it in a commercial product without a separate license. Matilda Jev is Apache-2.0. For production use at a company, that settles it before any benchmark does.

The small models: Jev-Style, RSI-Jev, Tiny-Jev, NanoJev

The small variants trade accuracy for running anywhere: a laptop, a CI runner, an edge box.

Jev-Style comes in 0.8B and 2B versions. It’s the most practical small option because it’s wire-compatible. The jev-style package (v0.3.0+) serves a local /v1/systemone endpoint with jev-style serve --release 2b. It accepts up to 25,600 input tokens, with GGUF and MLX builds. The author reports 73.6% for the 2B on 231 public JevBench v1.4.1 items, with a 95% interval of 67.6 to 78.9%. Hosted Jev scored 86.6% on the same items. That’s a 13-point gap, and the author publishes it rather than hiding it.

RSI-Jev is a 2B model on Qwen3.5-2B-Base, trained by an automated research loop. In the author’s words, agents “propose arms, register predictions before GPU spend, and retire champions.” Version 2.1 added option-scoring and confidence heads, answering in one forward pass at about 10 ms per decision. Version 3.0 added a listwise ranking reward and raised the suite mean from 0.736 to 0.756. Both versions run behind the same local /v1/systemone server. Read the fine print: eleven of twelve suite benchmarks used training data. Those are in-domain scores.

Tiny-Jev and NanoJev both fine-tune Qwen3-0.6B. Tiny-Jev answers choice, score, and noul in 20 to 50 ms on Apple M-series hardware. Its 95.8% is in-distribution, and its classic-benchmark comparisons pit a 2,000-item fit against a zero-shot reference. NanoJev’s authors call it suited to “research / game-controller demos,” such as maze and Snake. Take them at their word.

Multimodal: Jev-Omni

Jev-Omni is a ~12B classifier on Gemma 4 12B. It accepts text, image, audio, and video through an optional media= argument. The catalog calls it the first open peer with all four modalities shipped. It returns {prediction, prediction_index, confidence, probabilities}, not the System One response shape, so you’ll need an adapter.

The card reports 87.57% on DecisionBench Medium and 86.15% matched on JevBench. Neither run includes hosted Jev on the same items, so treat them as standalone numbers. Latency on an H200 runs from 26 ms to about 500 ms, depending on input. If your decisions start from screenshots, recordings, or call audio, this is the variant to test first. OpenJev 27B covers screenshots too, under its non-commercial license.

Same name, different contract

Three entries need a warning label before you integrate them. Two don’t follow the contract at all, and one follows it within tight limits.

• openjev is a cross-encoder for natural language inference. It outputs contradiction, entailment, or neutral. The catalog notes it has no first-class score or noul API. It’s useful for grading answers against references, with checkpoints from 0.8B to a 35B MoE.
• open-jev-deberta-v3-large does follow the typed-question contract. Its context is only about 512 tokens, though. Accuracy drops from about 0.854 in-domain to 0.690 on new questions. That gap is the clearest overfitting signal in the set.
• mini-jev is a teaching project. It reads letter logits from a frozen Qwen3-4B. Its catalog entry says the outputs are “not calibrated probabilities.” The catalog gives it a maturity score of 2 out of 10.

Can you compare the numbers?

No. Look at the “reported result” column again. It cites the Decision Index, JevBench v1.4.1, JevBench “matched,” DecisionBench Medium, a private 10,000-question set, and several in-domain suites. Only three rows put an open model next to hosted Jev on the same items:

Variant	Benchmark	Variant	Hosted Jev
Matilda Jev	Decision Index harness, self-reported	~59 to 60	57.91 (Jev 1.13)
OpenJev 27B	10,000 questions	84.0%	85.4%
Jev-Style 2B	JevBench v1.4.1, 231 items	73.6%	86.6%

Even these aren’t independent. Each comparison was run by the variant’s own author or reported from their card. The benchmarks themselves are young, too. On ModelSystem.One’s JevBench v1.5.7 table, hosted Jev ranks third, behind two other decision models.

There’s a subtler problem. A decision model’s value is calibration as much as accuracy. When it says 0.8, it should be right about 80% of the time. Expected calibration error (ECE) measures the gap, and lower is better. Only two variants report it. RSI-Jev reports 0.0556 for v2.1 and 0.066 for v3.0. open-jev-deberta reports about 0.022, in-domain. Matilda Jev ships a calibration temperature but no ECE or curve. Your thresholds depend on calibration, so this is the number to measure yourself.

Check before you load the weights

Matilda Jev and Tiny-Jev both load with trust_remote_code=True. That runs Python from the model repo on your machine. It’s normal for custom architectures, but treat it like any third-party dependency. Pin the repo to a commit hash. Read the modeling file. Run it in a container without production credentials.

The same applies to the small packaged servers. Each is a young project, published in the last three weeks.

Which one should you try?

Start from your constraint, not the leaderboard.

• Data can’t leave your network, and you’re a commercial team. Try Matilda Jev. It’s the only Apache-2.0 model at the large end with a wire-compatible server.
• You need low latency on modest hardware. Try Jev-Style 2B behind its local server. Expect lower accuracy than hosted Jev, and measure how much on your own cases.
• Your inputs include images, audio, or video. Try Jev-Omni, and budget for an adapter.
• You’re doing research or non-commercial work. OpenJev 27B is worth a look, especially for screenshot-driven agents.
• You want to study how these models are trained. RSI-Jev publishes its whole experiment log, version by version, on GitHub.

When hosted Jev is still the better choice

Self-hosting isn’t automatically cheaper. Hosted Jev charges only for input, at $0.042 per million tokens. A 27B model in bf16 needs a large GPU running all the time, plus someone to own it. At low or bursty volume, that’s hard to justify. It’s the same trade-off we covered in right-sizing your AI spend.

Stay on the hosted model when your data can leave your network and volume is modest. Stay there if no one on the team wants to own GPU serving. And stay there if your decisions lean on knowledge and reasoning. That’s Matilda Jev’s weakest area, and OpenJev 27B’s too.

Move to an open variant when data residency rules it in, or when volume is high and steady. Also move when you need to fine-tune on your own labels. TypeSafe’s public docs don’t describe a fine-tuning option for Jev.

Reader questions

Is Matilda Jev better than Jev?

On Maincode’s own run of a community benchmark, it scores slightly above Jev 1.13 overall. That doesn’t mean it’s better on your questions. Its area scores range from 46 to 79, so it depends heavily on the task. Test it on your own labeled cases.

Can we switch without changing code?

Only for the wire-compatible variants: Matilda Jev, Jev-Style, and RSI-Jev serve /v1/systemone. Check the exact request and response schema against what your client sends. For the others, plan on writing an adapter.

Will these models keep up with hosted Jev?

We don’t know, and neither do their authors. Most are one-person projects, three weeks old. Pin a version, keep your evaluation set, and rerun it whenever you upgrade either side.

Where to start

The open Jev ecosystem is three weeks old and moving fast. That’s a reason to build a test harness now, not to pick a winner.

If you’re evaluating decision models for production and want help designing the evals, Moonlight AI does this work with teams.

Your step for this week: take 100 decisions your system already makes, labeled by hand. If you use hosted Jev, log its answers. Then start Jev-Style 2B locally, or Matilda Jev if you have the GPU, and send it the same requests. Compare agreement with your labels for each question, not overall. Plot accuracy against confidence for both. Questions where the open model matches hosted Jev are candidates to move. The rest stay where they are.