One Week of System One Models: From Jev to Your Own Environment

Traditional language models are the wrong tool for the small decisions inside software. Routing a ticket, flagging personal data or judging whether an answer is grounded in a source takes a language model seconds and a few cents, and the output arrives as text that must be parsed and validated before code can act on it. System One models, introduced in our previous article on Jev, invert that trade: state and typed questions in, a probability per option out, in tens to hundreds of milliseconds, with nothing to parse.

Jev launched as a hosted, US-based service. The question this article addresses is what happened in the week that followed, and what it means for teams that need these decisions made in their own environment, in a European cloud region, or on a hosting platform of their choosing.

Timeline: A Model Category in Seven Days

Jev entered early access on 15 September 2026, alongside a 40 million dollar seed round. The response from the open community was immediate:

Within 72 hours: "OpenJev" experiments read option probabilities directly from the logits of open language models, skipping text generation entirely.
19 September: Convai Innovations released Laya, an Apache-2.0 decision model of about 420 million parameters (a ModernBERT encoder with a trained decision head), installable with a single pip command. The same day, Von appeared: 395 million parameters, serving TypeSafe's /v1/systemone wire protocol so exactly that a Jev client works against it after changing one URL.
The same week: OpenDecision (zero-shot NLI on ModernBERT), Verdict (151 million parameters), SemIf (option logits read from an unmodified Qwen 3.5 4B) and djev (Maisa's implementation on Google's DiffusionGemma) followed.
By 19 September: JevBench, an independent benchmark from Benchmark Heaven, ranked 38 systems on four axes: intelligence, calibration, speed and cost.

Figure: JevBench v1.2.13, the JevBench Score across 534 decisions. Jev 1.13.0 leads at 75.4; SemIf (74.7), djev (74.3) and Verdict (72.5) are open rebuilds; Laya (70.1) and OpenDecision (67.0) are the small encoders discussed below. Source: JevBench by Florian Standhartinger and contributors, Benchmark Heaven, MIT licence; chart reproduced with attribution.

The interface to use these models did self standardise immediately. Every option accepts the same three question types, choice, score and yes/no noul, over a state object, and returns a distribution over the options. So only minor changes need to be performed to evaluate and use another model.

Architectural Breakdown: Three Ways to Build a Decision Model

The systems on the board fall into three families, and the family determines what the model can and cannot do.

Trained decision heads on a small encoder (Laya, Von, Verdict): a bidirectional encoder of 150 to 420 million parameters reads state and question in one pass; a small head scores each option. Fast (tens of milliseconds), cheap to host, small context.
Logit readout from a frozen language model (SemIf, open-alternative-jev, djev): the options are rendered as answer letters and the model's next-token logits over those letters become the distribution. No generation, no parsing. Accuracy and calibration close to Jev; latency and cost of the underlying 4B to 27B model.
Zero-shot NLI over an encoder (OpenDecision): each option becomes a hypothesis and the entailment probability is normalised across options. No training data for the task needed; weaker on multi-step judgement.

Jev itself is closed, and TypeSafe has not published its architecture beyond describing it as parallel and non-autoregressive.

Deployment: Own Environment, Cloud Region, Hosting Platform

The open models are standard Hugging Face checkpoints under Apache-2.0 or MIT licences, which opens three deployment options:

In the application's own environment: the encoders fit in a couple of gigabytes and need no accelerator to answer in under 100 milliseconds; the 4B model fits a single mid-range GPU. They all ran easily on my work laptop.
On a cloud GPU in the region of choice: The models easily run unchanged on any provider, including European ones.
Behind a hosting platform: Some model hosts are already providing these models within a European hosting environment. The options are sure to expand the following days.

Limitations of the System One Models, both Open-Source and Jev

Context window: the open encoders read 512 tokens per question, state included, about 350 words of content. The 4B models read a few thousand tokens, Jev tens of thousands.
Option count: option lists must stay short, around twenty for the encoders against 255 for Jev.
Calibration: their probabilities cluster at 0.00 and 1.00 rather than in between, so they should be treated as votes rather than odds until refitted on the user's own data.
Question wording: they read questions literally, which makes the wording part of the code.
Languages: the multilingual checkpoints are weaker than the English ones.
No calculation, shared with Jev: These models are too limited to reason and calculate. Use a LLM or code to handle that aspect. Generally the wont understand convert things like 2 weeks into 14 days for example.

Business Use and Developer Use

Two adoption patterns are emerging. Business teams can use System One models for classification inside a process: routing tickets to the right queue, flagging complaints and churn signals, detecting personal data before storage, scoring urgency. Developers use them inside software as semantic conditions: whether a tool call is safe to execute, whether an answer is grounded in the retrieved passage, whether a user needs a human, checks that fit in a test suite. It costs barely anything to call and never return malformed output so it easily integrated with AI coding harnesses.

Two follow-up articles will cover each pattern in depth: System One models in a business process, from ticket intake to policy checks, and System One models in the developer's toolbox, as guardrails, routers and the decision layer around an agent. With open weights that run very fast in any environment or region, these decision models can change the economics of AI agents.