CampusX
CampusXSep 24
Tech

Jev by TypeSafe AI | What is a System-1 Decision Model | CampusX

90 min video5 key momentsWatch original
⚡
TL;DR

Jev is a System-1 decision model that classifies inputs 13x faster and 81x cheaper than GPT-5 while maintaining calibrated confidence scores.

Key Insights

1

Not an LLM, a classifier — Jev is not an LLM — it's a System-1 decision model that classifies multiple-choice questions instantly, not a text-generation engine. It makes decisions 10-15x faster than GPT-5 at roughly 1/80th the cost.

2

OpenAI researcher, System-1 focused — Jev was built by Diego Almedida, who left OpenAI after leading InstructGPT and RLHF research, because existing LLMs waste time and money on reasoning tasks that only need fast decision-making.

3

Parallel sampling, no extra cost — You can ask Jev 14 questions at once about a single piece of text — all answered in parallel — and still pay no extra, unlike LLMs where each query or token costs money.

4

Calibrated confidence, RLCD training — Jev's confidence scores are calibrated using RLCD (Reinforcement Learning for Calibrated Decision), meaning when it says 80% confident, it's actually right 80% of the time — not hallucinating confidence like LLMs do.

5

No hallucination, bounded output — Jev never hallucinates or invents answers because it only picks from options you give it; it can't generate novel text, making it safer for production automation workflows.

6

System-2 vs System-1 division — The future divides AI labor: LLMs handle complex reasoning and text generation; Jev-like models handle routing, classification, and small decisions — both working together in pipelines.

7

Decoder-based, synthetic pre-training — Jev is almost certainly a decoder-based transformer (like GPT, not BERT) pre-trained on massive synthetic data, evidenced by its 84.6% MMLU score and lack of need for fine-tuning.

Want this for every new video CampusX posts? Brevyd summarizes each upload automatically, the morning it drops.

Deep Dive

Why Jev Exists: The System-1 vs System-2 Gap

Diego Almedida, a core OpenAI researcher who led InstructGPT and RLHF work, noticed a critical problem: LLMs were engineered for deep reasoning (System-2 thinking), but modern software needs fast reflexive decisions (System-1 thinking). Every week new AI models emerge, but most are overhyped noise. Almedida believed Jev was different — not a feature but infrastructure. He left OpenAI in 2024 to start TypeSafe AI in stealth mode, then released Jev on September 15th. His core philosophy: software doesn't need a model to deliberate for seconds to classify a support email, route an API call, or detect fraud. It needs to decide instantly. This gap between capability (what we built LLMs to do) and requirement (what production systems actually need) is what Jev solves.

What Jev Actually Is: Decision Model, Not Language Model

Jev is not an LLM. It's a generalized classifier that takes three inputs — state (context), questions (what you want to know), and options (the choices) — and returns the best match with a confidence score. You give it a customer support email, ask it seven things about categories, sentiment, urgency, language, and refund intent, and it answers all seven instantly. Unlike logistic regression, which you'd have to retrain on your data, Jev comes pre-trained on global knowledge. It needs no fine-tuning. Feed it a question, four options, and a sentence of context, and it picks the right answer in 70–500 milliseconds. You can ask 14 questions in parallel about the same context and still get answers in that timeframe. Cost-wise, GPT-5 runs $119 per million input tokens and $956 per million output tokens; Jev costs $4 per million input tokens and output is free. Process 10,000 emails daily: LLM costs $3,000/day; Jev costs $40/day. Per year: $1.1M vs $14,000. That's the core value proposition.

Five Key Advantages Over LLMs

Speed is first: Jev is 5–13x faster than LLMs at identical classification tasks, making real-time UI updates and game AI feasible. Cost is second: the math above shows it's roughly 80x cheaper at scale. Third, parallelism: one API call with 14 questions, one answer set, no extra latency or cost — LLMs process sequentially. Fourth, calibrated confidence: thanks to RLCD training (Reinforcement Learning for Calibrated Decision), its confidence scores are honest. If Jev says 90% confident, it's right 90% of the time. LLMs famously hallucinate confidence. Fifth, no hallucination: Jev can only pick from your options. Ask it which Indian city is the capital with choices Mumbai, Chennai, Delhi, Kolkata — it will never invent 'New Delhi' or apologize and reformat itself into JSON. It's bound by schema. These five properties make it suitable for the hundreds of small decisions embedded in enterprise workflows where LLMs currently overkill.

The Architectural Inference: Decoder-Based Transformer with Non-Autoregressive Decoding

Jev's creators disclosed almost nothing — no paper, no dataset, no methodology. But clues exist. It scores 84.6% on MMLU (a broad-knowledge benchmark), which only happens when a model is pre-trained on vast text at scale. This is typically a decoder job; encoders don't scale that way. MMLU scores this high require autoregressive pre-training on billions of tokens. Jev is therefore almost certainly a transformer decoder, similar in architecture to GPT, not BERT. However, it's trained on synthetic data (generated, not real-world text), which explains why it generalizes without fine-tuning — the synthetic data was likely created by an existing model and curated for classification tasks. The non-autoregressive behavior (no token-by-token generation) likely uses a parallel sampling mechanism: instead of predicting token 1, then token 2, then token 3 sequentially, Jev evaluates all possible completions or all option probabilities at once, then picks the highest. This is computationally different from a standard LLM's prefill-decode pattern.

Parallelization and Prefill-Decode Architecture

Standard LLMs operate in two stages: prefill and decode. In prefill, the model consumes your entire input (question plus context), computes key and value vectors through all transformer layers, and builds an internal representation. In decode, it generates output token by token, using previous outputs as new input. This sequential decode phase is why LLMs are slow. Jev sidesteps this with parallel sampling. Instead of generating 'The', then 'capital', then 'of', it evaluates all options against the context in parallel, computes scores for each, and returns them together. The trick: it doesn't have an LM head (language modeling head) that produces probabilities for every English word. Instead, it has a scoring head that assigns probabilities to your specific options — Billing, Shipping, Technical, General — based on the input. Fifteen options? Same latency. This architectural choice explains both the speed and the bounded output. You're not asking for unbounded generation; you're asking for constrained scoring, which is fundamentally faster.

Real-World Demos: From Review Analysis to Game AI

Within days of launch, users built dozens of working systems. One person built a Flipkart-style review analyzer that breaks a product's ratings by feature (camera 4.6, battery 3.5, display 3.7, design 4.7) using Jev classification instead of custom NLP pipelines. A researcher classified 1,000 research papers in minutes, cost under $1. Someone built a real-time browser automation agent, using Jev for decision-making and JavaScript for action, completing complex tasks in seconds instead of minutes. A LinkedIn plugin filters AI-generated slop posts in real time. A context-compression tool uses Jev to intelligently prune irrelevant chat history before feeding to an LLM, reducing hallucination and cost. A game agent plays Subway Surfers using Jev for split-second movement decisions. A trading bot uses Jev to classify market signals. An email classifier processes 1,500 emails in seconds. What unites these: all involve fast, bounded decisions embedded in loops. None of them required fine-tuning. All are production-ready.

The Architectural Shift: AI from Feature to Primitive

The biggest implication is structural. Today, AI feels like a feature — you announce it, integrate it, celebrate it. Jev presages a shift to AI-as-primitive, like an if-else statement. You'll write code: if Jev says customer_anger_score > 0.9, escalate to human; else auto-refund. No ceremony, no separate AI service call, just logic. This mirrors how databases or caching became invisible infrastructure. Right now, adding AI to a product is expensive and slow. In two years, it will be the assumed plumbing. The boundary between what LLMs do and what decision models do will sharpen: LLMs own generation, complex reasoning, and user-facing chat; decision models own classification, routing, gating, and embedded choices. This isn't replacement; it's division of labor. You'll use both. But the 100,000 times per day you route a ticket, classify sentiment, or score a lead — that's not for a multi-billion-parameter LLM. That's for Jev.

Building a Flipkart-Style Analyzer in Under an Hour

To ground this in code, the instructor built a real application in roughly 100 lines. Load a CSV with 50 product reviews. For each review, send the text as state (context) and ask 14 questions in parallel: Does the reviewer mention the camera? How satisfied are they with the camera? Does the reviewer mention battery? And so on for all seven feature categories. Jev returns probabilities for yes/no on presence and a satisfaction score (1–5) on each feature. Aggregate across all 50 reviews. Done. Output: camera 3.0/5 mentioned in 12 reviews, battery 3.5/5 in 15 reviews, display 3.7/5 in 16 reviews — exactly the feature-level breakdown Flipkart displays. An LLM plus fine-tuning would take weeks; custom NLP would take months. Jev took a few hours and cost pennies. The code imports the TypeSafe SDK, instantiates a client, defines a threshold (if confidence < 0.5, ignore the answer), and loops. The parallel batch means one API call extracts all features from all reviews in seconds. This workflow — send context, ask multiple questions, aggregate answers — is the template for dozens of production use cases.

Takeaways

  • ✓Use Jev for routing, classification, and decision-making tasks where speed and cost matter more than reasoning depth.
  • ✓Deploy Jev inside LLM pipelines to reduce expensive API calls—guard rails, model routing, confidence-based branching logic.
  • ✓Trust Jev's confidence scores directly; they're calibrated via RLCD, not faked like LLM confidence.
  • ✓Build multi-question inference in a single API call—Jev's parallel sampler answers 14 questions as fast as one.

Key moments

3:00The core insight: System 1 vs System 2

“Software needs System-1 thinking but we've been building System-2 models. Jev fixes that.”

8:36Speed demo: GPT-5 vs Jev

“GPT-5 took 6.58 seconds. Jev did it in 472 milliseconds. That's 13x faster.”

11:00Annual cost comparison

“10,000 emails per day: LLM costs 11 lakh rupees yearly. Jev costs 14,000 rupees. 81x cheaper.”

45:00Why it works: MMLU score reveals decoder architecture

“Jev scores 84.6% on MMLU. That means it's a full decoder trained at scale on massive pretraining data, not just a small classifier.”

55:00Parallel sampling: The hidden weapon

“Ask 14 questions at once, get 14 answers in the same latency. Cost doesn't increase. That's parallel sampling.”

You just read one. Brevyd does this for every upload.

Follow CampusX and every new video comes back as a summary like this, in your morning briefing. No watching required.