Jev decision models explained: the open-weight class

A Jev decision model is a model you call for a typed decision. A state and a fixed-shape question go in. A chosen option, a probability of yes, or a level on a scale you defined comes back with calibrated confidence. No prose comes out. This guide defines the class. It tells the provenance story straight. It maps the three routes the open models take. It reads the benchmark record honestly, including the sealed-question gap. It gives the self-host and adapter paths. The spine is the provenance. A closed-weight original made the class visible in September 2026. An open-weight family answered within days. The three platform lanes named here belong to that family, planned and not yet listed.

A posture note first, because this guide names three lanes on this platform: jev-fast, jev-causal, and jev-batch. All three are planned and pre-launch. No row exists in the platform's model data. Nothing answers under those aliases. No rate is published, and no launch date is promised. Cost talk is unit-shaped. The lanes are designed to meter by the million input tokens against a prepaid wallet. The answer is a typed decision, so there is no output side to bill. When rows land, rates render from the catalog, never from this page.

The question, and what ranks for it

We captured the search results for the definitional question on 24 September 2026. All ten rows were explainers. The set held developer blogs, a course library, trade news, a review site, and the original publisher's announcement. None serves the class. This guide holds the definitional ground honestly. It covers what the class is, where it came from, and what the open family can do. Every number is dated and owned.

What a decision model is

A decision model takes choices in and returns scores out. You send a state, the model's word for the text being judged, plus one or more typed questions. A choice question supplies options. It returns the pick, a calibrated confidence, and the full distribution. A noul question is the binary door: a statement, and a probability of yes. A score question names an ordered scale of two to ten levels. It returns the expected level. Nothing is generated. The model reads and picks, never writes. An answer is always one of your options.

Calibrated is the word doing the heavy lifting. A calibrated probability is one the model has been trained to mean. When it says 0.8, it is right about eight times in ten. A raw classifier score promises nothing of the sort. The difference governs any threshold or escalation you build on it.

The framing comes from decision science. The psychologist Daniel Kahneman described thinking as two systems. System 1 is fast and automatic. System 2 is slow and deliberate. A decision model is a System 1 you call from software, in milliseconds. A large language model is the System 2 tool, spending a full generation pass on every call. Which of these options, asked thousands of times an hour, is System 1 work. A question that needs prose is System 2 work.

The closed original that made the class visible

The class has a start date. On 15 September 2026, TypeSafe AI released Jev, a System One model. It made typed decisions with calibrated probabilities and no free-form generation. The release was limited early access, hosted by the publisher. The weights stayed closed. No download, no self-host path, no disclosed size.

The split that shaped everything after: the wire contract was published, the weights were not. The contract is a state plus typed questions in and a typed answer set out. It is public and standardized in practice, so anyone could write a client. Nobody outside the publisher could run the model, audit it, fine-tune it, or serve it. The contract created demand for the class. The closed weights created demand for an open answer.

Why it mattered: agent stacks spend most of their calls on small decisions. Which tool, which queue, does this pass review: all were priced at generation prices. A typed decision at a fraction of the work is a structural saving on exactly those calls. That is why the open builds followed within days.

The name, handled carefully

The search space around the name is polluted, so one careful paragraph. Jev, capital J and the rest lowercase, is a product name, not an acronym. JEV in all caps is the biomedical abbreviation for Japanese encephalitis virus. A medical paper on it ranks on the first page of the class query. That is why the acronym question sits in the People Also Ask box. On decider-shaped queries, an academic paper about rule-controllable decoding ranks and is unrelated. The People Also Ask phrase "joint decision model" is decision theory: decisions made by interacting parties, not this class either. As for the name's origin, the publisher's own announcement documents it. Jev is named after the nineteenth-century economist William Stanley Jevons. His observation that efficiency increases demand for what it makes cheaper is the bet the name carries.

The open classmates: three routes, one contract

The open answer came as a family. Coverage counted six open builds in the first two days. The hubs carry a long tail of small models, most under two billion parameters and permissive licenses. Three of them matter in practice: one causal model and two encoders. Each has a full published record. The census, dated September 2026:

All three are Apache 2.0: download, run, fine-tune, ship commercially, no permission ask. The Laya card documents a ModernBERT encoder. It documents a router over three checkpoints, more than one hundred languages, and training against a proper scoring rule. That training is calibration by construction. The decider-2b card documents the causal route: a 2-billion-parameter finetune published one day after the original. It reads the state like text and scores the answer slots you define. The open-jev card documents the batch encoder: English text, a 512-token window with the state cut to 256, up to 255 options per choice. Its official repository carries a full measured record.

On this platform the family maps to three planned lanes, written ahead of their rows. jev-fast takes the Laya encoder route. jev-causal takes the decider-2b causal route. jev-batch takes the open-jev batch route. Each has its own page. None has a row in the platform's model data. Nothing answers under its alias, and no rate or date exists. Each faces a listing gate first. The gate is a standardized decision benchmark run with the release pinned by hash. It also requires a calibration spot-check. The classification family page carries the wider set.

What the numbers say, and what they do not

Three evidence layers exist. Each needs its label.

The publisher layer. The decider-2b card's evaluation table, version 10, reads 0.805 accuracy in-task against 0.755 held-out. Its calibration error reads 0.037 against 0.084. Accuracy drops visibly off the trained tasks, and calibration error roughly doubles. The open-jev card's record, from 1,500 states and 3,508 questions, reads 0.854 in-domain against 0.690 out-of-distribution. The card adds that confidence runs slightly hot on unseen question shapes. Laya's publisher publishes speed rather than accuracy tables, in the official repository. The figures are 33 milliseconds per question single and 7.2 batched on one T4-class card.

The independent layer is thin, and the thinness is information. One head-to-head exists, and its sharpest caveat sits inside its own numbers. An independent benchmark run in September 2026 scored Laya against the hosted original. The set was 2,000 typed routing decisions. It read 0.766 against 0.727 routing accuracy, at 38.4 milliseconds per decision against roughly 400. The calibration figures were published at the source. The 0.766 belongs to a checkpoint fine-tuned on the benchmark's own training split. Zero-shot on the same benchmark, the encoder scored 0.362 against the original's 0.727, below the majority baseline of 0.461. The routing boundary follows from that split. The encoder wins in-domain or fine-tuned. The hosted original wins out of the box and on wide option sets. A 9-billion-parameter quality-tier sibling exists with its own hosted service. Its comparison is the vendor's in-house run: 90.1 against 93.2 on 324 held-out items, with an untrained base at 66.4. That is a claim to check, not a neutral audit.

The sealed layer is where the honesty lives. JevBench v1.4 is the class benchmark, posted 23 September 2026 by its operator. It scores models on fresh sealed decisions, 308 of them this version. It uses an equal-weight harmonic mean and separate speed and cost gates. On that board the batch encoder ranked 56th at 12.65. The operator's method notes carry the number that explains the gap: 29.5 percent accuracy on sealed decisions against 52.4 on the public slice. Sealed questions are questions nobody has seen. The honest read across all three layers: strong and calibrated inside the trained shapes, measurably weaker on unseen shapes. Confidence runs hot exactly where accuracy drops. Measure on your own questions before committing a corpus.

Routing the family

The routing is flagship first, and the table is the rule. The encoder is the lighter pass, so it takes the first attempt on every decision. The causal lane takes the passes the encoder cannot hold. The batch lane takes offline volume.

Self-host paths

Apache 2.0 makes every road open, and for these three the roads are well built. The flagship encoder downloads from its card at about 0.9 GB, with serving code in the official repository. One mid-range GPU runs it. CPU serving is viable at lower throughput. The batch encoder ships an official ONNX port in four variants. A browser library runs it on-device over WebGPU or WebAssembly at about 0.35 GB quantized. One catch: the library's default is a smaller Qwen-based build with a longer window. Pass the encoder's alias. The causal model runs from full-precision weights at about 3.5 GB. It also runs from 4-bit-class GGUF builds at about 1.5 GB through llama.cpp. That engine's OpenAI-compatible server exposes the chat endpoint shape the hosted lanes are designed to ride. Community mirrors publish the GGUF files.

The discipline that separates a trustworthy self-host from mirror roulette: pin what you run. Mirrors are third-party re-uploads. Anyone can replace a file under the same name. Record the exact hash of the weights you validated and the build commit of the engine. Verify both on every re-pull. Stop the pipeline on a mismatch. Unrelated repositories carry lookalike names. An unofficial mirror sat in the top results when we checked. That is our own capture check, not a warning the batch model's card carries.

The adapter story: the contract is the compatibility layer

The native contract of this class is not chat-shaped. A request is a state plus typed question definitions. The answer is a typed result set. The chat-completions body most tooling already speaks does not carry it natively. Every guide written since the original's release routes readers through adapter layers for exactly this reason.

The adapter is not a workaround; it is the compatibility layer. The three primitives are its whole vocabulary: choice, noul, and score in, typed results out. Third-party services already serve Jev-class models on the published wire contract. They sit behind the original's own paths, SDK-compatible. That proves a compatible lane can take those clients as they stand. This platform's lanes are designed the same way. The stable face is the OpenAI-compatible chat route. An adapter underneath owns the typed contract. A client written against either shape changes a base URL and a model string and nothing else. The base-URL swap itself is its own guide: the OpenAI-compatible API guide.

One boundary, stated the way the batch model's card states it: no public specification of the original's interface exists. The open side's wire compatibility is a best-effort reconstruction from public material. It is not a certified match. A migration that matters should test the shapes it depends on.

Frequently asked questions

What is a Jev decision model?

A model you call for a typed decision rather than text. A state and typed questions go in. Typed answers with calibrated confidence come out, never prose. The name comes from the closed-weight original that made the class visible in September 2026. The class now includes an open Apache 2.0 family implementing the same published contract.

What does JEV stand for?

Nothing, in this class: Jev is a product name, not an acronym. The all-caps JEV in search results is Japanese encephalitis virus. It is a biomedical abbreviation, and its literature shares the query space. The publisher's announcement documents the name's origin. Jev is after the nineteenth-century economist William Stanley Jevons.

Is Jev open source?

No. The original's weights are closed. It is hosted by its publisher under paid early access. No self-host path or parameter count is disclosed. What is open is the wire contract. A family of Apache 2.0 models implements it: downloadable weights you can audit, fine-tune, and serve.

Do the open clones match the original?

One independent head-to-head exists. It favors the encoder only in its tested shape: 0.766 against 0.727 routing accuracy on 2,000 typed decisions, at 38.4 milliseconds against roughly 400. The 0.766 is a fine-tuned number. Zero-shot on the same benchmark the encoder scored 0.362 against the original's 0.727. The hosted original also wins out of the box on wide option sets. No like-for-like number exists for the batch encoder. Closed weights mean nobody outside the publisher can put the same questions to both models. The sealed record adds the caution: scores on public questions overstate scores on fresh, unseen ones.

What does a decision lane cost?

No rate exists for any lane yet, because no row exists in the platform's model data. The metering basis is designed and public: per million input tokens against a prepaid wallet. There is no output side to bill. Requests refused at a zero balance are billed nothing. There is no free tier. When rows land, rates render from the catalog on the pricing page. Metered-spend failure modes and wallet mechanics are their own guide: how to avoid API bill shock.

The class after the closed weights is days old, and the honest picture is sharp. There is a published contract. An open family implements it across two routes. A sealed benchmark rewards skepticism. Self-host paths are good enough to test every claim on your own questions. The three lanes on this platform are written, not listed. The models index carries the catalog state. The classification family page holds the wider set. When the rows land, a wallet and a key take minutes on the signup page.

Last verified: 2026-09-25