edit_document 1,239 words
Words 1239
Reading time ≈ 6 min
Notes 0
Last edited Sep 30, 2026 · 15:03

For the past few years, the AI narrative has been dominated by one paradigm: chat. We’ve built superhuman conversational agents, coding copilots, and reasoning engines. Yet, a lingering question remains for software engineers: If these models are so smart, why is end-to-end automation still so brittle, slow, and expensive?

The answer lies in a fundamental mismatch. Software doesn’t need a chatty scribe; it needs reliable, lightning-fast, structured decision-making.

Enter System One Models, a new class of AI architecture pioneered by TypeSafe AI with their closed-source model, JEV. In this post, we’ll break down exactly how JEV-style models work, why they are fundamentally different from regular chat LLMs, and explore the exciting open-source alternatives that are bringing this capability to your local machine.

How JEV-Style Models Work (In Plain English)

To understand System One models, let’s use an analogy.

Imagine you ask a regular LLM: “Is this customer support ticket about billing?” The LLM acts like a meticulous scribe. It reads your prompt, thinks about it, and then writes out the answer character by character (autoregressive generation). Even if you ask for JSON, it still generates the curly braces, quotes, and letters one token at a time. This process is inherently sequential, relatively slow, and prone to “typos” (hallucinations or malformed JSON) that require costly post-generation parsing and validation.

A JEV-style (System One) model works completely differently. It acts like a specialized, parallel grading machine.

  1. You provide it with an unstructured or structured state (e.g., the ticket text).

  2. You provide it with a strict, predefined schema of typed questions and allowed options (e.g., {"is_billing": {"type": "boolean"}}).

  3. Instead of “writing” an answer, the model performs a single, parallel forward pass. It directly computes the mathematical probability (logits) of every allowed answer token simultaneously.

  4. It returns a clean, type-safe data structure with calibrated probabilities (e.g., {"is_billing": {"probability": 0.94}}).

There is no decoding loop. There is no text generation. There are no type errors, because the output space is mathematically constrained to the schema you provided. It’s essentially a frontier-intelligence, fuzzy if-statement.

JEV vs. Regular Chat LLMs: A Technical Comparison

TypeSafe AI’s JEV (named after economist William Stanley Jevons, highlighting how dropping the cost of intelligence unlocks exponential new use cases) is the flagship of this new class. Here is how it contrasts with a traditional System Two (chat/reasoning) LLM:

| Feature | Regular Chat LLM (System Two) | JEV / System One Model |
| :--- | :--- | :--- |
| **Primary Optimization** | Human preference (RLHF) for helpful, verbose text. | Calibrated decisions (RLCD) for epistemically honest probabilities. |
| **Output Mechanism** | Sequential, autoregressive token generation. | Parallel, single-pass logit scoring over a predefined schema. |
| **Output Format** | Unstructured strings (requires parsing/validation). | Strictly typed, structured values (booleans, enums, scores). |
| **Hallucination Risk** | Moderate to High (can invent facts or malformed JSON). | **Zero** for schema violations; calibrated confidence for factual uncertainty. |
| **Latency** | Seconds (3s to 300s+ for complex reasoning). | Milliseconds (70ms – 500ms end-to-end). |
| **Cost Profile** | Expensive output tokens (often 5x input cost). | Input tokens are cheap; output "tokens" are effectively free. |
| **Best Use Case** | Brainstorming, open-ended generation, human-in-the-loop chat. | Routing, classification, scoring, guardrailing, and real-time software automation. |

Note: JEV is currently available only via early access through TypeSafe AI and is not open-source.

The Open-Source Rebellion: 3 Alternatives to JEV

The software engineering community thrives on openness, self-hosting, and transparency. Fortunately, developers have already begun reverse-engineering the interface pattern and training methodologies of System One models using open-weight foundations.

Here are three notable open-source projects leading the charge:

1. Bespoke-Nimble-9B

Repository: bespokelabs/Bespoke-Nimble-9B

Bespoke Labs took a highly pragmatic approach. Instead of training a model from scratch, they released a lightweight LoRA adapter built on top of the open-weight Qwen3.5-9B base model.

  • How it works: It is specifically fine-tuned to score allowed answer tokens directly for context-grounded choices, booleans, and rubric score levels.

  • Why it matters: It completely bypasses free-form reasoning or text generation. By constraining the model to evaluate a predefined schema, it achieves JEV-like behavior with a fraction of the compute required for full model training. It’s an excellent, drop-in starting point for teams wanting to experiment with structured scoring without leaving the Hugging Face ecosystem.

2. Mapika / decider

Repository: Mapika/decider

decider is the most comprehensive open reproduction of the System One model class to date. It offers a family of models (including a 2B and a 35B Mixture-of-Experts variant) fine-tuned from Qwen3.5 base models.

  • How it works: It introduces a brilliant optimization called schema caching. The model pre-computes the attention key/value states of the question and option blocks. When a request comes in, it only processes the new “state” (context) and forks the cached state, executing the whole decision via optimized CUDA graphs in a single pass.

  • Why it matters: It natively supports Choice, Score, and Noul (probability of yes) types. It also enforces independent scoring, meaning adding or reordering questions doesn’t alter the probability of other answers—a critical feature for reliable software composition. It even includes a calibration-aware Reinforcement Learning (RL) stage to ensure the output probabilities are mathematically honest.

3. TheoLeeCJ / SemIf (formerly OpenJev)

Repository: TheoLeeCJ/SemIf

SemIf (Semantic Ifs) is an independent research project with a clear mission: "Semantic ifs from open models, on a 3090 at home."

  • How it works: It extracts typed option probabilities directly from open models (like Qwen3.5–4B or MiniCPM5–2B) via direct logit reading. It features a “shared-state” mode, where a long context (like a massive document) is prefetched into the GPU once, and then branched across dozens of decision criteria in parallel.

  • Why it matters: It proves that you don’t need a closed, proprietary API to get JEV-like performance. In their benchmarks, a 4B model using direct logit extraction achieved an 0.845 modal agreement on a TypeSafe subset, closely trailing the closed JEV service (0.883), while being 5.2x faster than asking the same model to autoregressively generate a JSON array of answers. It even includes a WebGPU browser demo, proving this can run client-side.

When Should You Use Which?

As a software engineer, your architecture should reflect the right tool for the job:

  • Reach for a Regular Chat LLM (e.g., GPT-4, Claude 3.5 Sonnet, Qwen3.5–72B) when the task is open-ended: drafting emails, generating boilerplate code from scratch, brainstorming, or any scenario where human review is the final gate.

  • Reach for a System One / JEV-style Model when the task is a deterministic workflow: routing a support ticket to a department, scoring the toxicity of a prompt, extracting a specific enum from a document, or making real-time decisions in a game loop or high-frequency trading bot.

The Future is Structured

The “chat” interface was a necessary bridge to make AI accessible to humans. But the next frontier of AI engineering isn’t about making models better at talking; it’s about making them better at deciding.

By giving up the flexibility of free-form string generation, System One models like JEV, decider, SemIf, and Bespoke-Nimble gain superpowers: mathematical guarantees against type errors, massive latency reductions, and radically lower costs.

The closed-source offerings are proving the concept, but as projects like decider and SemIf demonstrate, the open-source community is already building the robust, self-hostable infrastructure that will power the next generation of automated software.

Have you experimented with direct-logit scoring or structured decision models in your stack? Share your experiences in the comments below!