1. What is Jev?

Jev is the first public System One Model, released by TypeSafe AI on September 15, 2026. The company was founded by Diogo Almeida (ex-OpenAI, co-author of InstructGPT research), Erik Gafni, and Sasha Sheng. They raised approximately $40 million in seed funding led by DCVC.

Jev is not a large language model. It does not write text, generate code, summarize, or hold conversations. Its only job is to make structured decisions that software can use directly.

You give Jev two things:

• State: Any relevant text or JSON (a support ticket, email, resume, user query, game state, etc.)
• Questions: One or more typed questions you define in advance

It returns typed answers with probability distributions and a calibrated confidence score.

Think of Jev as a high-intelligence function call: unstructured data in, reliable decisions out.

2. System 1 vs System 2 Thinking

The name “System One” comes from Daniel Kahneman’s book Thinking, Fast and Slow.

• System 2 (slow thinking) = deliberate, sequential reasoning. This is what current frontier LLMs excel at — writing long responses, planning, coding, and multi-step problem solving.
• System 1 (fast thinking) = quick, intuitive judgments. Most decisions inside software fall into this category: routing a ticket, choosing a tool, scoring a lead, checking if a request is safe, or deciding whether to escalate.

LLMs are powerful but expensive and slow when used for simple operational decisions. Jev was built specifically for the System 1 layer inside applications.

The practical result is a hybrid architecture:

• LLMs handle generation and deep reasoning
• Jev handles the high-frequency micro-decisions that surround them

3. How Jev Works

Jev uses a transformer backbone but replaces the normal language modeling head with a specialized answer head. Instead of generating tokens one by one (autoregressive decoding), it evaluates all questions in a single parallel pass.

This architectural difference is the main reason for its speed and cost advantages. Because there is no sequential token generation, the expensive memory-bandwidth bottleneck of normal LLMs largely disappears.

Key properties:

• Schema-constrained outputs (it can only choose from options you define)
• Parallel evaluation of multiple questions over the same state
• Built-in calibrated confidence scores
• No free-form text generation

4. The Three Question Types

Jev supports three core primitives:

1. Choice
Select one option from a closed list (up to ~255 options).
Example: “Which department should handle this?” → Billing / Technical / Sales / Other

2. Score
Place the input on an ordered scale you define.
Example: Severity levels — Minor / Moderate / Major

3. Noul (Boolean probability)
Evaluate a yes/no statement and return a probability between 0 and 1.
Example: “Is this claim likely fraudulent?”

Every answer includes:

• The selected value
• Probability distribution across options
• An overall confidence score

The confidence score is designed to be calibrated: a 0.85 confidence should mean the answer is correct roughly 85% of the time on similar data.

5. Training Method: RLCD

Most LLMs are trained with RLHF (Reinforcement Learning from Human Feedback). This optimizes for responses that humans prefer, which works well for chat but produces poorly calibrated confidence estimates.

TypeSafe uses a different method called RLCD — Reinforcement Learning for Calibrated Decisions. The model is trained so that its probability outputs closely match real-world accuracy. This makes the confidence scores usable for automated decision-making in code.

Training relies heavily on synthetic data with known ground truth. Full technical details of RLCD have not been published.

6. Speed, Cost, and Economics

Public numbers from TypeSafe (as of late September 2026):

On their published workflow benchmarks, TypeSafe reports peak gains of roughly 193× faster and 444× cheaper for System One–style tasks. Real-world gains vary by use case but are consistently large for classification and routing workloads.

Because output tokens are free and multiple questions can share the same state, the economics of agent design change significantly. Decisions that were previously too expensive to call frequently become practical.

7. Practical Use Cases

Jev shines in high-volume, structured decision tasks:

• Support ticket & email routing — Classify by department, urgency, sentiment, and risk in one call
• Dynamic model routing — Send simple queries to cheap models and complex ones to frontier models
• Tool selection in agents — Choose the next tool or action without invoking a full LLM
• Guardrails — Approve or block tool calls based on safety criteria
• Resume & lead scoring — Evaluate candidates or leads against defined criteria
• RAG filtering — Score and filter documents before sending them to an expensive LLM (can reduce token usage dramatically)
• Content moderation & AI-slop detection — Fast classification of social posts or user content
• Real-time UI decisions — Morph interface elements based on partial user input

The common pattern is the same: replace expensive LLM calls that only need a structured answer with a Jev call.

8. Agentic Architecture Patterns

A practical multi-tier pattern looks like this:

1. User request arrives
2. Jev evaluates intent, complexity, and required tools (fast, cheap)
3. Simple tasks → execute directly or call a lightweight model
4. Complex tasks → call a frontier LLM
5. Optional final Jev check on the LLM output for safety or format compliance

This keeps the expensive System 2 model in reserve and uses it only when necessary.

Confidence thresholds become first-class control flow:

if confidence >= 0.90:
    act_automatically()
elif confidence >= 0.60:
    ask_clarifying_question()
else:
    escalate_to_human()

9. Code Examples

Basic Python example (using the official style):

from typesafe import TypeSafe

client = TypeSafe(api_key="YOUR_API_KEY")

response = client.system_1.predict(
    model="jev-latest",
    state="My package arrived damaged and I want a full refund immediately.",
    questions=[
        {
            "question": "Which department should handle this?",
            "options": ["Billing", "Shipping", "Technical Support", "General"]
        },
        {
            "question": "How urgent is this request?",
            "options": ["Low", "Medium", "High", "Critical"]
        }
    ]
)

print(response.best_option)
print(response.confidence)

Multi-question batching with threshold logic:

def process_ticket(ticket_text):
    result = client.system_1.predict(
        model="jev-latest",
        state=ticket_text,
        questions=[
            {"question": "Category", "options": ["Billing", "Support", "Refund"]},
            {"question": "Is this a high-priority issue?", "options": ["Yes", "No"]}
        ]
    )

    if result.confidence >= 0.90:
        route_automatically(result.best_option)
    elif result.confidence >= 0.60:
        trigger_followup()
    else:
        escalate_to_human()

10. Limitations and What Not to Do

Jev is powerful within its design boundaries, but it has clear limits:

• Text only (no images, audio, or video in the initial versions)
• Cannot generate free-form text or explanations
• Weak at arithmetic, counting, and precise date reasoning
• Reads questions very literally
• No chain-of-thought reasoning traces
• Closed source (weights not released)
• Calibration quality still needs validation on your own data

Avoid these anti-patterns:

• Using it to summarize long conversations
• Asking it to judge complex LLM reasoning quality
• Forcing it to output text character by character
• Relying on it for strategic multi-step games that require memory
• Treating high confidence as a guarantee of correctness (always validate thresholds on real traffic)

Keep math, counting, temporal logic, and open-ended generation in your application code or a full LLM.

11. Comparison Table

12. Final Takeaways

Jev does not replace large language models. It makes the overall system more efficient by handling the many small, structured decisions that currently waste LLM capacity.

The biggest opportunity for most teams is simple: identify every place in your agents or workflows where you currently call an LLM only to get a classification, route, score, or yes/no answer. Replace those calls with Jev (or a similar System One model) and measure the impact on latency, cost, and reliability.

When designed well, the hybrid pattern — System 1 for decisions + System 2 for generation — produces faster, cheaper, and more controllable AI systems.

Jev is still early. Multimodal support, better numeric reasoning, and more transparent evaluation tools will likely arrive in future versions. For now, it already offers a practical way to move many operational decisions out of expensive generative models and into a purpose-built, machine-native layer.