Unveiling System One Models and Jev

By Diogo Almeida, Founder of TypeSafe AI Published: September 15, 2026

For several years, Large Language Models (LLMs) have displayed "superhuman" capabilities in conversational interfaces. However, this raises a critical question: Why hasn't this translated into widespread, reliable automation?

During my tenure at OpenAI, I contributed to the methodologies that enabled models to follow complex instructions and engage naturally with users. While I initially believed chat-centric models were the path to AGI, it became evident that a fundamental piece of the puzzle was missing.

After two years of stealth development and significant research breakthroughs, TypeSafe AI is proud to introduce a new category of frontier models: System One Models. These are engineered specifically to make rapid, structured decisions that can be integrated directly into software pipelines.

The Architecture of Automation

To achieve this, we didn't just tweak existing models; we built an entirely new stack. This includes a proprietary model architecture, a parallel sampler designed for peak efficiency, and a novel training regime called Reinforcement Learning for Calibrated Decisions (RLCD).

Our debut model, Jev, is now available via early access.

What is Jev?

Jev maintains the intelligence levels of current frontier LLMs for "System One" tasks but operates $\approx 100\times$ faster. By abandoning the generation of raw strings, Jev eliminates hallucinations and focuses exclusively on structured, typed outputs.

The Core Concept: Think of Jev as a frontier-intelligence function call. $\text{Unstructured State} \rightarrow \text{Jev} \rightarrow \text{Typed Probabilistic Decisions}$

---

💅 Comparing the Frontiers: LLMs vs. System One

The following table delineates the shift from human-centric chat models to software-centric decision models.

Visualizing the Process Flow

---

Practical Applications

While traditional LLMs are incredible for rapid prototyping, their unpredictability makes them risky for production. Jev is designed for scenarios where reliability is non-negotiable.

• Fuzzy Decision Rules: Use AI to classify, route, or branch logic where hard-coded rules are too rigid.
• High-Performance UX: Implement AI decisions in $\approx 100\text{ms}$ for seamless user experiences.
• AI Governance: Act as a high-speed judge to detect jailbreaks or verify the reasoning traces of other LLMs.
• Reliable Composition: Because the output is constrained by types, Jev is easier to compose into complex, stable systems.

---

The Evidence: "The Receipts"

We recognize that these claims are bold. Here is how we substantiate them:

1. Speed and Cost

Our speed claims are verifiable. While our current benchmarks are run from West Coast laptops (where our servers reside), the latency reduction is real. Note: We are working to ensure long-term pricing sustainability, expecting costs to decrease over time.

2. Mathematical Certainty

Type errors are a possibility. Type errors are mathematically impossible in Jev's output. This is a structural guarantee, not a probabilistic hope.

3. Side-by-Side Performance

In our demonstrations, the most striking difference is that Jev outputs all probabilities in parallel, whereas LLMs must generate tokens one by one.

⚠️ Adding Nuance to the Demo

To be transparent about our demo:

• The query used was simplified with human-readable keys for clarity.
• The input state was a short, dense paragraph, which favors our sampling method.
• We compared Jev against GPT-5.6 Terra (using default reasoning), as it is the closest match in intelligence.
• In the recorded run, Jev and GPT-5.6 Terra only differed on the "Churn likelihood level."

Measuring Success: Workflow Evals

We have moved beyond simple ground-truth classification. Instead, we use Workflow Evals to see how AI performs inside actual code.

// Conceptual representation of a Workflow Eval
const workflow = {
  input: "User State",
  nodes: [
    { id: "decision_1", model: "Jev", reference: "Smartest_Model_Avg" },
    { id: "decision_2", model: "Jev", reference: "Smartest_Model_Avg" }
  ],
  metric: "Probability Alignment"
};

By treating the compute graph as the source of truth and comparing Jev's predictions against the average of the world's most expensive and capable models, we can measure its utility as a software component rather than just a chatbot.