TypeSafe Jev: Fast, Typed AI Decisions Inside Software

TypeSafe Jev is a non-autoregressive AI model designed to make fast, structured decisions inside software rather than generate conversational text. Built by TypeSafe AI—founded by former OpenAI research lead Diogo Almeida, Erik Gafni, and Sasha Sheng—Jev evaluates unstructured program state against typed questions and returns validated outputs (Choice, Score, or Noul probabilities) in a single parallel forward pass. Running at 70ms to 500ms latency and priced at $0.042 per million input tokens with unmetered output, it targets workflow automation, intent routing, and agent guardrails where traditional large language models (LLMs) are too slow, costly, or prone to schema hallucinations.

What "System One" Means in Software

Most applied AI today relies on autoregressive language models. When a developer asks an LLM to classify a support ticket, route an agent task, or verify a tool call, the model predicts text token by token. To use that decision in software, the developer must constrain text generation (via prompt engineering, JSON mode, or grammar-guided decoding) and parse strings back into program variables.

This workflow carries three structural friction points:

High latency: Sequential token generation takes 2 to 30 seconds on frontier models.
Schema fragility: Even with constrained decoding, LLMs can drop keys, hallucinate unexpected enum values, or fail on edge cases.
Mismatched economics: Output tokens are typically 3x to 5x more expensive than input tokens, penalizing structured data extraction.

Traditional LLM:
Input State ──> [Autoregressive Token Generation] ──> Raw String / JSON ──> Parser / Validator ──> Code
                 (Sequential, 2-10s latency, output token fees)

TypeSafe Jev:
Input State ──> [Parallel Pass / RLCD Sampler] ──> Typed Decision + Probabilities ──> Code
                 (Single forward pass, 70-500ms, output tokens free)

TypeSafe calls Jev a System One Model, referencing Daniel Kahneman’s dual-process cognitive framework (Thinking, Fast and Slow). In Kahneman’s terminology, System 1 represents fast, automatic, intuitive perception, while System 2 handles slow, deliberate, analytical calculation.

Jev does not chat, write code, or explain its thoughts. It acts as an intelligence primitive for software logic: unstructured state goes in, and calibrated, typed decisions come out.

The name "Jev" refers to English economist William Stanley Jevons and the Jevons Paradox: as technological improvements make a resource cheaper and more efficient to use, total consumption of that resource increases rather than decreases. TypeSafe’s explicit thesis is that reducing the cost and latency of discrete software decisions by two orders of magnitude will unlock thousands of automated micro-evaluations that are currently impractical with frontier LLMs.

concept

Training Method: RLCD vs. RLHF

The structural differences between Jev and traditional LLMs stem from how the model is trained and sampled:

Chat models use RLHF: Reinforcement Learning from Human Feedback aligns generative models to human preferences—conversational fluency, detailed explanations, and helpfulness.
Reasoning models use RLVR: Reinforcement Learning with Verifiable Rewards trains models on verifiable math, coding, and logical puzzles where final outputs can be programmatically checked.
Jev uses RLCD: TypeSafe developed Reinforcement Learning for Calibrated Decisions. RLCD trains the model to produce calibrated probabilities on discrete decisions rather than plausible-sounding sentences.

Because Jev gives up freeform string generation, it does not use an autoregressive sampler. All questions sent in a request are evaluated in parallel across the input state in a single forward pass.

Capability / Trait	Autoregressive LLMs (Claude, GPT-4o)	TypeSafe Jev (`jev-1.13.0`)
Primary Output	Freeform strings, Markdown, conversational text	Typed structures (`Choice`, `Score`, `Noul`)
Sampling Mechanism	Sequential (token by token)	Parallel (single query pass)
End-to-End Latency	2,000ms – 30,000ms+	70ms – 500ms (typical ~100ms)
Input Pricing	$0.15 – $15.00 per million tokens	$0.042 per million tokens ($42 / Btok)
Output Pricing	$0.60 – $60.00 per million tokens	Free (unmetered)
Type Guarantees	Probabilistic prompt compliance; requires JSON parsing	Mathematical guarantee; zero type errors
Uncertainty Output	Often overconfident verbal hedging	Calibrated probability distribution + confidence
Maximum Context	128k – 2M tokens	64k tokens (32k for state + longest question)

The Three Decision Primitives

TypeSafe provides three 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 (up 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 is true or false. It returns a single float between 0.0 (definitive false) and 1.0 (definitive true) representing calibrated confidence.

reference

Speculative Fan-Out and Workflow Quickstart

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.

# Evaluates classification, urgency, and fraud in a single parallel pass (~100ms)
response = client.system_one(
    state=ticket_payload,
    questions={
        "category": Choice(options=["billing", "technical", "security"]),
        "urgency": Score(levels=["low", "medium", "critical"]),
        "is_fraud": Noul(instructions="Does this indicate payment fraud?")
    }
)

To set up API credentials and execute your first working script in Python or TypeScript:

implementation

Where Jev Fits in Application Architecture

Jev is not designed to replace conversational copilots or reasoning agents. Instead, it operates at the boundary layers of software systems:

Confidence-gated triage: Classify incoming webhooks, emails, or user tickets in ~100ms. If confidence >= 0.85, execute an automated action. If confidence is low, route to a human queue.
LLM guardrails and tool call verification: Intercept user prompts before they reach an expensive frontier model, or verify that an agent's proposed tool call conforms to security policy.
RAG passage reranking: Filter hundreds of retrieved search chunks in parallel, scoring relevance and discarding contradictory snippets before context injection.
Real-time game loops and interactive UX: Low latency (sub-100ms) enables continuous control loops running at 10+ queries per second at low operating costs.

workflow

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).

For a typical application evaluating 100,000 requests per month (averaging 350 input tokens each), total monthly inference cost is approximately $1.47.

cost

Ecosystem Integrations

Developers can integrate Jev through direct API access or supported ecosystem proxies:

Direct API: POST https://api.typesafe.ai/v1/systemone using @typesafe-ai/sdk (Node) or typesafe-sdk (Python).
Vercel AI SDK: Integrated via @ai-sdk/typesafe-ai using experimental_evaluate.
OpenRouter: Accessible via the Alpha Decisions API under model slug typesafe/jev-1.13.

integration integration

Key Limitations to Plan Around

TypeSafe’s documentation explicitly documents several architectural constraints in jev-1.13:

No String Generation: Jev cannot draft prose, summarize articles, or write code.
Math and Counting Failures: Arithmetic, list counting, and sum calculations must remain in application code.
Date Comparisons: Jev treats dates as literal strings rather than sequential timestamps.
Context Rot on Bloated Payloads: Accuracy declines when state payloads contain excessive noisy context.

caveat

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:

concept