What Is Jev AI?

Jev (often searched as Jev AI or TypeSafe Jev) is an artificial intelligence model built by TypeSafe AI—founded by former OpenAI research lead Diogo Almeida, Erik Gafni, and Sasha Sheng. Unlike general-purpose Large Language Models (LLMs) such as OpenAI's GPT models, Claude, or Gemini, Jev is built specifically to make fast, typed decisions inside software rather than generate conversational text, essays, or code.

Instead of predicting text token by token and forcing developers to prompt-engineer JSON schemas and parse strings, Jev acts as a software evaluator: you feed it unstructured application state (such as customer emails, ticket threads, or user inputs) alongside predefined, typed questions. Jev evaluates that state and returns typed outputs—categorical choices, numerical scores, or calibrated probabilities—directly into your code.

Jev is intended for high-frequency operational tasks where software needs semantic judgment at low latency and low cost:

• Intent routing: Sorting incoming user requests, tickets, or webhooks into bounded categories.
• Agent tool selection: Deciding which tool or workflow branch an AI agent should execute next.
• Safety guardrails: Intercepting adversarial, abusive, or off-topic inputs before they reach expensive models.
• Priority and risk scoring: Scoring items against an ordered rubric (such as lead quality or churn risk).

Dedicated Jev Guides: How to Use Jev · Intent Routing & Fallbacks · Jev vs. Structured Outputs · Use Cases & Task Fit · API Reference · Pricing & Calculator · Confidence & Calibration

Why Is Jev Called a "System One" Model?

TypeSafe describes Jev as a System One Model, referencing Daniel Kahneman's framework in Thinking, Fast and Slow:

• System 1 is fast, instinctive perception—recognizing a face, sensing urgency, or categorizing an object immediately.
• System 2 is slow, deliberate reasoning—solving math, writing an essay, or debating trade-offs step by step.

Autoregressive LLMs (especially reasoning models generating chain-of-thought tokens) work like System 2: they deliberate sequentially, predict tokens one by one, and often take several seconds to answer.

Jev is built to act as the System 1 layer. It does not write prose or generate code. It evaluates input state and returns calibrated, typed decisions in a single pass. When software needs a fast boolean flag, category label, or routing decision, Jev handles that perception step. If your workflow subsequently needs a drafted email or a complex plan, you pass Jev's structured decision to an autoregressive model.

Traditional Generative LLM:
Input State ──> [Token-by-Token Generation / Thinking] ──> Raw String / JSON ──> Parser / Validator ──> Code
                 (Autoregressive decoding, output token fees, 1–5+ seconds typical)

TypeSafe Jev (System One):
Input State ──> [Parallel Pass / RLCD Sampler] ──> Typed Decision + Probabilities ──> Code
                 (Single forward pass, 188ms p50 measured, output tokens free)

The name "Jev" refers to William Stanley Jevons and the Jevons Paradox: as a technology makes a resource cheaper and more efficient to use, consumption of that resource grows. TypeSafe's bet is that slashing the latency and cost of discrete software decisions will unlock thousands of micro-evaluations that are currently too slow or expensive for frontier LLMs.

Is Jev an LLM?

No. Jev is a non-autoregressive decision model, not a Large Language Model.

While Jev understands natural language in both its input state and question instructions, how it runs and what it returns are fundamentally different from generative models:

1. No prose generation: Jev cannot write an essay, summarize a document, explain its thinking, or hold a conversation. It evaluates state and emits categorical variables (Choice), ordinal ratings (Score), or continuous probabilities (Noul).
2. Parallel sampling: Instead of generating tokens sequentially, Jev evaluates all questions in parallel across the input state in a single pass (188ms median client latency in our Banking77 test).
3. Guaranteed schema boundaries: An LLM can deviate from a JSON schema if its generation slips. Jev outputs probability distributions mapped directly to your declared criteria, making malformed schema output structurally impossible.
4. Zero-output economics: While standard LLM providers bill output tokens at 3x to 5x input rates, TypeSafe charges $0.00 for output tokens.

If you need a model to draft content, write code, or explain reasoning, use an autoregressive model. If your software needs a categorical decision, boolean flag, or routing destination, Jev replaces the prompt-and-parse LLM loop.

Read our full Banking77 benchmark comparing Jev against Gemini 3.8 Flash structured output

comparison↗

The Three Decision Primitives

TypeSafe Jev structures all queries into three typed question primitives. Each primitive addresses a specific decision shape and returns typed values with probability distributions:

1. Choice: Discrete Option Selection

Selects one option from a bounded list of 2 to 255 options. It returns the selected choice, a full probabilities distribution across all options, and an overall confidence score.

2. Score: Ordinal Rubric Rating

Rates the input state along an ordered rubric of 2 to 10 levels. Rather than returning a crude integer, Jev returns a probability-weighted expectation (score) that can fall between levels, allowing fine-grained sorting.

3. Noul: Calibrated Statement Probability

Evaluates whether a statement about the state is true or false. It returns a single float (noul) between 0.0 (definitive false) and 1.0 (definitive true) representing calibrated probability, without a separate confidence score.

Speculative Fan-Out

Because Jev evaluates all questions in parallel against the input state in a single request, adding questions introduces minimal latency overhead. TypeSafe recommends the Speculative Fan-Out pattern: ask every question your application might need upfront, and let deterministic code decide which answers to act upon.

from typesafe_sdk import TypeSafeClient, Choice, Score, Noul

client = TypeSafeClient()

# Evaluates classification, urgency, and fraud in a single parallel pass
response = client.system_one(
    state={
        "user_id": "usr_9421",
        "message": "My card was charged twice for order #4092. Please refund immediately.",
        "account_age_days": 184
    },
    questions={
        "category": Choice(
            instructions="Classify support category",
            criteria={
                "billing": "Billing, duplicate charges, or refunds",
                "technical": "Software bugs or app errors",
                "account": "Login and profile changes"
            }
        ),
        "urgency": Score(
            instructions="Assess customer urgency",
            criteria=["low", "medium", "critical"]
        ),
        "is_fraud": Noul(instructions="Does this payload indicate payment fraud?")
    }
)

print(response.category.choice)       # "billing"
print(response.category.confidence)   # 0.941
print(response.urgency.score)         # 1.82 (continuous rubric score)
print(response.is_fraud.noul)         # 0.04 (calibrated probability)

Get started with runnable first-call examples for Python and TypeScript

implementation↗

Where Jev Fits — And Where It Breaks

Jev is not built to replace conversational assistants or multi-step reasoning agents. It belongs at the decision boundaries of software.

What It Handles Well

• Intent routing & triage: Sorting inbound user messages or tickets into queues within 130ms–190ms. Paired with an explicit fallback route and confidence gating, automated precision exceeded 95% in our CLINC150 testing.
• LLM guardrails and tool gating: Checking user prompts before sending them to an expensive frontier model, or verifying that a proposed agent tool call complies with policy.
• RAG passage filtering: Scoring candidate passages in parallel to discard irrelevant chunks before prompt construction.
• Browser action selection: Picking the next operation and target element from an indexed DOM snapshot, with a text model called only when a field needs typed input.

See how DOM-based browser agents use Jev to choose the next click, input, or wait

workflow↗

Read our CLINC150 routing study measuring explicit fallbacks and confidence gating across 5,500 test samples

workflow↗

Review our complete task-fit matrix of high-fit, conditional, and poor-fit Jev tasks

concept↗

Known Boundaries and Failure Modes

TypeSafe documents several architectural constraints in jev-1.13, and our benchmarks surfaced others:

1. Type safe does not mean semantically correct: Jev guarantees schema compliance by construction—it will never emit syntax errors, invalid JSON, or unlisted enum keys. But valid output does not mean the decision was right. When we forced Jev to choose among 150 supported intents without an escape route, it assigned $\ge 0.90$ confidence to 150 completely unsupported requests (15.0%). Never treat schema validity as proof of correctness.
2. No text generation: Jev cannot draft messages, summarize context, format markdown, or generate code. Asking it for text causes validation errors.
3. No arithmetic or counting: Jev lacks arithmetic execution. If a decision requires checking whether an invoice amount exceeds an account balance, do the math in code and pass the resulting boolean into state.
4. No calendar or date reasoning: Jev treats dates as literal strings, not timestamps. Asking whether "2026-09-21" is within 30 days of an event will produce unreliable answers. Compute elapsed days in code before calling Jev (e.g., account_age_days: 14).
5. Struggles with negative criteria: Framing rules as negations ("Select this if the user is not asking for a refund and does not have an active subscription") causes accuracy drops. Frame criteria around positive assertions.
6. No multi-hop reasoning: Because Jev evaluates inputs in a single forward pass without generating chain-of-thought tokens, questions requiring multi-step deductions degrade in accuracy. Break complex policies into sequential checks in software.
7. Score calibration is weak: In the Score primitive, jev-1.13 score level calibration is rough. While the returned score is a continuous float representing expected value across level indices, small fractional differences should not be treated as fine-grained linear measurements.

Is TypeSafe Jev Open Source?

No. TypeSafe Jev is a proprietary, hosted model available only via POST https://api.typesafe.ai/v1/systemone or gateway partners like OpenRouter. TypeSafe has not released model weights or training code, and self-hosting is not supported.

TypeSafe does publish open-source client SDKs on GitHub (Python typesafe-sdk, TypeScript @typesafe-ai/sdk), but the underlying model remains closed. Independent community projects (such as Laya, kev, and OpenJev) implement Jev-like decision interfaces on top of open base models like Qwen or DeBERTa, but none of these contain TypeSafe's weights or training data.

TypeSafe has not disclosed the parameter count for jev-1.13.0.

Pricing and Token Economics

TypeSafe Jev uses an asymmetric zero-output pricing model:

• Input Tokens: $0.042 per million tokens ($42 per billion tokens).
• Output Tokens: $0.00 (Free / unmetered). Standard API responses report output token usage, but output is billed at $0.00.

For an application evaluating 100,000 requests per month (averaging 350 input tokens each), total monthly inference cost is roughly $1.47 (100,000 × 350 × $0.042 / 1,000,000).

In our Banking77 benchmark across 77 intents, Jev cost $0.0679 per 1,000 decisions compared to $0.4570 for Gemini 3.8 Flash—an 85% cost reduction.

Calculate workload costs and compare token economics in our interactive calculator

product↗

Model Architecture and RLCD Training

The structural differences between Jev and traditional LLMs come down to how the model is trained and sampled:

• Chat models use RLHF: Reinforcement Learning from Human Feedback aligns generative models to conversational fluency, detail, and helpfulness.
• Reasoning models use RLVR: Reinforcement Learning with Verifiable Rewards trains models on verifiable math, coding, and logical puzzles.
• Jev uses RLCD: TypeSafe developed Reinforcement Learning for Calibrated Decisions. RLCD trains the model to output calibrated probabilities on discrete decisions rather than plausible-sounding text.

Because Jev does not generate text, it skips autoregressive sampling. All questions in a request are evaluated in parallel across the input state in a single forward pass.

Model Versions

How to Try Jev

You can test Jev through three main channels:

1. Direct API Access: Call the hosted endpoint at TypeSafe AI:

   curl -X POST https://api.typesafe.ai/v1/systemone \
     -H "Authorization: Bearer $TYPESAFE_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{
       "state": "Payment failed for invoice #8192 due to card expiration.",
       "questions": {
         "category": {
           "type": "choice",
           "instructions": "Select issue category",
           "criteria": {"billing": "Billing and payment issues", "technical": "System errors"}
         }
       }
     }'
   

2. Client SDKs: Install TypeSafe's open-source libraries:
   • Python: pip install typesafe-sdk
   • TypeScript: npm install @typesafe-ai/sdk
3. Gateways: OpenRouter (typesafe/jev-1.13) and Vercel AI SDK (@ai-sdk/typesafe-ai).

Follow our complete step-by-step setup guide with runnable Python and TypeScript code

implementation↗

Inspect complete endpoint schemas, status codes, and error formats in the Jev API Reference

implementation↗

Worth the Waddle?

Evidence and Editorial Context

To understand how AI Model Waddle categorizes vendor disclosures, technical benchmarks, and first-party operational testing, consult our reference framework:

Review AI Model Waddle evidence standards and empirical methodologies

concept↗

Learn how Jev confidence scores and calibrated probabilities behave in production

concept↗

Sources & Documentation

1. AI Model Waddle CLINC150 Benchmark Dataset — 5,500 evaluated test samples measuring forced choice, explicit fallback, and confidence gating.
2. AI Model Waddle Banking77 Benchmark Dataset — 385 evaluated test samples comparing jev-1.13.0 and gemini-3.8-flash.
3. TypeSafe AI: Introducing System One Models & Jev — Diogo Almeida, September 15, 2026 announcement.
4. TypeSafe Documentation: System One & Primitives Specification — Official documentation covering Choice, Score, and Noul schemas.
5. TypeSafe Documentation: Jev 1.13 Jaggedness and Limitations — Documented boundary conditions, date/math constraints, and failure modes.
6. TypeSafe Documentation: Models (price, rate limits, context length) — Lists jev-1.13.0 at $0.042 per million input tokens with free output tokens. Checked September 26, 2026.