Sam Witteveen · Published 2026-09-18

Jev - The Ultimate Classification Model?

privateReview: unreviewedConfidence: high
jevtypesafeRLCDclassificationsystem1non-autoregressiveCalibrationstructured-outputparallel-sampling
Open on YouTube ↗

Summary

Overview

  • Speaker: Sam Witteveen
  • Channel: Sam Witteveen
  • Main topic: TypeSafe AI's Jev model, a System One model designed for structured outputs, classification, and function calling without chat interfaces.
  • Purpose: To analyze and demonstrate Jev by TypeSafe AI, explore its underlying mechanics (RLCD, parallel sampler), compare it to existing LLMs, and walk through practical applications and pricing. Frontier AI labs have focused heavily on reasoning, long chains of thought, and thinking budgets (System 2 thinking), which make models slow, expensive, and opaque for software integration. Software typically needs fast, structured decisions like classification (pick from a list, scoring, yes/no probabilities). TypeSafe AI, founded by former OpenAI researcher Diogo Almeida (lead author of InstructGPT), spent two years in stealth building Jev, a System One model that outputs typed choices, scores, and probabilities without chat interfaces, token-by-token generation, or hallucination of schema, offering high speed and very low cost.

Topic Map

The State of Frontier Labs and System 2 Reasoning

  • Explanation: Over the past two years, every frontier lab (OpenAI, Anthropic, Google Gemini, DeepSeek, Meta, Qwen) has focused on reasoning using longer chains of thought and thinking budgets. While powerful, these models are slow, expensive, and hide their chain of thought even when billed for it.
  • Key claims:
    • All frontier labs are focused on reasoning and longer chains of thought.
    • Reasoning models are System 2 thinking: slow, deliberate, and effortful.
    • Frontier labs do not let you see the chain of thought even though you pay for it.
  • Examples:
    • Waiting multiple minutes for a reasoning model to return an answer.
  • Terminology:
    • System 1 thinking
    • System 2 thinking
    • Chain of thought
    • Thinking budget
  • Why it matters: Highlights the industry-wide overemphasis on slow reasoning models for tasks that software actually solves with simple classification.

Software Needs System 1 Classification

  • Explanation: Most decisions made inside software every second are not complex System 2 problems; they are simple classification problems (pick-from-a-list, urgency checks, rule violations) that should not take 30 seconds or minutes.
  • Key claims:
    • Most decisions in software are classification problems.
    • Asking reasoning models to return one-word answers wrapped in JSON incurs massive latency and token costs.
  • Examples:
    • Routing a support ticket
    • Checking if a message is spam
    • Escalating to a human
  • Terminology:
    • Classification
    • Latency cost
    • Order-regressive generation
  • Why it matters: Exposes the mismatch between slow chat-based LLMs and the fast, structured decision-making needs of software applications.

Introducing Jev by TypeSafe AI

  • Explanation: TypeSafe AI, founded by Diogo Almeida (co-author of the InstructGPT paper), came out of stealth with Jev, a model designed for software automation rather than chat.
  • Key claims:
    • Jev has no chat box and does not write left-to-right token by token.
    • Output tokens are free on OpenRouter, while input tokens cost $0.042 per million tokens.
    • Jev is a System One model acting like a typed function call.
  • Examples:
    • Passing unstructured text state and typed questions into jev(state, questions).
  • Terminology:
    • TypeSafe AI
    • Jev
    • Diogo Almeida
    • InstructGPT
    • System One model
  • Why it matters: Introduces a radically different paradigm for integrating AI into software pipelines.

The Three Building Blocks: Choice, Score, and Noul

  • Explanation: Jev operates on three types of questions: Choice (picks one option from a list plus probabilities), Score (rates on a user-defined scale), and Noul (yes/no probability via a sigmoid function).
  • Key claims:
    • There are only three kinds of questions: Choice, Score, and Noul.
    • Outputs contain no text to parse, returning structured probabilities and confidence scores.
    • Jev eliminates faked JSON outputs from order-regressive LLMs.
  • Examples:
    • Classifying support ticket language as French, English, German, or Thai.
    • Scoring customer review sentiment from 0 to 2.
    • Determining whether text is asking a question (Noul).
  • Terminology:
    • Choice
    • Score
    • Noul
    • Sigmoid function
    • Confidence score
  • Why it matters: Provides developers with deterministic, structured primitives instead of parsing fragile text.

Practical Demos: Customer Support, Code Review, Content Moderation, and Agent Tool Selection

  • Explanation: Demonstrating Jev across four practical use cases: customer support routing, code review (SQL injection detection), content moderation, and agent tool selection.
  • Key claims:
    • Jev evaluates inputs rapidly in 300-500ms with extremely low cost.
    • It successfully handles prompt injection, sarcasm, PII detection, and tool selection.
    • Sequential action chains of 20 decisions execute in under 9 seconds for less than 1/20th of a cent.
  • Examples:
    • Routing duplicate charge tickets to Billing with 97% confidence.
    • Detecting SQL injection vulnerabilities in Python code.
    • Playing Doom with 10 queries per second for ~$7/hour.
  • Terminology:
    • Prompt injection
    • PII detection
    • Tool selection
    • Sequential actions
    • Doom gameplay
  • Why it matters: Proves that Jev's architecture handles complex software workflows with high speed, accuracy, and low cost.

How Does It Work? RLCD and Parallel Sampler

  • Explanation: TypeSafe AI utilizes a new model architecture, a parallel sampler for maximum efficiency, and a training method called Reinforcement Learning for Calibrated Decisions (RLCD).
  • Key claims:
    • RLCD stands for Reinforcement Learning for Calibrated Decisions.
    • Unlike RLHF (Human Preference) and RLVR (Verifiable Rewards), RLCD optimizes for calibrated decisions with epistemically honest probabilities.
    • End-to-end response time is 700ms-500ms (40x-200x faster than frontier models).
  • Examples:
    • Comparing existing LLMs (RLHF, RLVR) with System One + Jev (RLCD).
  • Terminology:
    • RLCD
    • Parallel sampler
    • RLHF
    • RLVR
    • Calibrated decisions
    • Epistemically honest probabilities
  • Why it matters: Explains the technical breakthrough enabling fast, non-autoregressive, calibrated structured outputs.

Key Points

Chat is the wrong interface for software

  • Explanation: Software applications do not want paragraphs of text; they want structured values they can use immediately without parsing latency.
  • Evidence: Traditional LLMs require parsing markdown JSON out of conversational text streams, introducing latency and failure points.
  • Practical implication: Developers should use function-call-like interfaces that return typed values directly.

Jev eliminates token-by-token generation for classification

  • Explanation: Jev does not write text left-to-right; it evaluates the whole answer at once using parallel sampling.
  • Evidence: Output tokens are priced at $0/M on OpenRouter because generation is non-autoregressive for the output values.
  • Practical implication: Massive reduction in latency (700-500ms) and cost.

Reinforcement Learning for Calibrated Decisions (RLCD)

  • Explanation: A new training methodology optimized for calibrated, epistemically honest probability scores rather than human conversational preferences.
  • Evidence: Outputs include accurate confidence scores and probability distributions across all available options.
  • Practical implication: Eliminates hallucinations in structured outputs and tool selection.

Frameworks, Models & Processes

Jev Function Call Framework

  • How it works: Treats the model call like a typed function taking state and typed questions.
  • Components:
    • State (unstructured text or data)
    • Typed Questions (Choice, Score, Noul)
  • When to use: Whenever software needs fast, structured classification, routing, scoring, or probability checks.

Examples & Case Studies

Passing support ticket text through Jev with Choice, Score, and Noul questions.

  • Illustrates: How Jev classifies text into billing, technical, or account categories with confidence scores.
  • Lesson: Structured building blocks eliminate prompt engineering and fragile JSON parsing.

Jev running 20 sequential decisions to manage an eCommerce order workflow.

  • Illustrates: Chaining multiple classification decisions together efficiently.
  • Lesson: Complex multi-step software agents can run reliably and cheaply using System 1 models.

Jev playing Doom by making 10 queries per second.

  • Illustrates: The extreme speed and real-time capability of Jev's parallel sampling architecture.
  • Lesson: Real-time automated control is viable at a cost of ~$7/hour.

Actionable Takeaways

  • Immediate:
    • Try Jev on OpenRouter for classification and routing tasks.
    • Replace fragile JSON prompt generation with typed classification blocks.
  • Strategic:
    • System 1 models are unlocking fast software automation that chat-based LLMs were too slow and expensive for.
    • RLCD (Reinforcement Learning for Calibrated Decisions) represents a major shift away from RLHF for functional software.
  • Questions to investigate:
    • What underlying model architecture powers Jev?
    • How well does RLCD scale to larger models or more complex domains outside classification?

Claims Worth Verifying

  • Jev output tokens are free on OpenRouter. (pricing)
  • Jev achieves 700ms-500ms end-to-end response time. (performance)
  • Diogo Almeida was a lead author on the InstructGPT paper. (factual)

Notable Quotes

"Every frontier lab... all of it in one direction. They've all been focused on reasoning." (at 0:06) "Chat is the wrong interface for software." (at 4:02) "This is what we were all faking." (at 6:38) "We built a new stack entirely focused on automation: with a new model architecture, parallel sampler for maximum efficiency, and training method we call Reinforcement Learning for Calibrated Decisions (RLCD)." (at 21:47)

Compressed Summary

  • Frontier labs focus on slow System 2 reasoning models.
  • Software needs fast System 1 classification, not chat paragraphs.
  • TypeSafe AI's Jev model provides typed Choice, Score, and Noul outputs.
  • Trained with RLCD (Reinforcement Learning for Calibrated Decisions).
  • Delivers non-autoregressive structured outputs in 700-500ms with zero hallucination of schema.
  • Keywords: jev, typesafe, rlcd, classification, system1
  • Core insight: Jev replaces slow, conversational, chat-based LLMs with a fast System 1 model optimized via RLCD for deterministic, typed classification and structured software automation.

Core insights

6
Mechanismhigh noveltystrong evidence

Jev produces its output values non-autoregressively via a parallel sampler, so output generation is not billed per output token the way autoregressive decoding is.

Why it matters

Output-token cost is the dominant cost driver for high-volume classification/agent loops; if the values are evaluated at once rather than generated left-to-right, marginal cost per decision collapses, reshaping what workloads are economically viable (10 queries/sec Doom control, 20-step action chains).

Generalization

Any system where the 'answer space' is a bounded typed set (labels, scores, probabilities) can in principle be evaluated in parallel instead of decoded sequentially, decoupling output cost from answer-space size.

Jev does not write text left-to-right; it evaluates the whole answer at once using parallel sampling.
Open source video
Output tokens are priced at $0/M on OpenRouter because generation is non-autoregressive for the output values.
Open source video
Output tokens are free on OpenRouter, while input tokens cost $0.042 per million tokens.
Open source video
Mental Modelhigh noveltymoderate evidence

RLCD (Reinforcement Learning for Calibrated Decisions) is positioned as a third training paradigm distinct from RLHF (human preference) and RLVR (verifiable rewards), optimizing for epistemically honest, calibrated probabilities rather than rewarding plausible or verifiably-correct answers.

Why it matters

Calibration is the property agent runtimes actually need for thresholds and routing decisions — a 97% confidence label is only useful if it is honest. If preference/reward-verification objectives systematically distort confidence, then a separate objective is required for decision-critical classifiers.

Generalization

Training objectives determine the trustworthiness of downstream decision signals; systems that act on model output probabilities need an objective explicitly shaped around calibration, not preference ranking or binary correctness.

RLCD stands for Reinforcement Learning for Calibrated Decisions.
Open source video
Unlike RLHF (Human Preference) and RLVR (Verifiable Rewards), RLCD optimizes for calibrated decisions with epistemically honest probabilities.
Open source video
Architecturemedium noveltymoderate evidence

The API surface is a typed function call returning structured values and probabilities (Choice/Score/Noul) rather than a chat stream requiring JSON extraction, removing the parse-and-fail layer from software integration.

Why it matters

Every chat-based structured-output pipeline carries latency and failure points from coaxing models to emit valid JSON and parsing it back; collapsing that into a typed call moves the schema guarantee into the model interface instead of the harness.

Generalization

Where a downstream consumer needs typed values, the interface should be a typed call returning those values, not a conversational text stream with an extraction step bolted on.

Jev has no chat box and does not write left-to-right token by token.
Open source video
Outputs contain no text to parse, returning structured probabilities and confidence scores.
Open source video
Jev eliminates faked JSON outputs from order-regressive LLMs.
Open source video
Jev is a System One model acting like a typed function call.
Open source video
Architecturemedium noveltymoderate evidence

There are exactly three primitives — Choice (pick one from a list plus probabilities), Score (rate on a user-defined scale), and Noul (yes/no probability via a sigmoid).

Why it matters

A tiny, closed set of question types constrains the model interface to decision primitives that map directly onto software control flow, enabling deterministic composition (routing, thresholds, escalation) without freeform output handling.

Generalization

Reducing a model's expressive surface to a small set of decision primitives trades generality for composability, determinism, and testability — often the right trade for infrastructure components.

There are only three kinds of questions: Choice, Score, and Noul.
Open source video
Choice (picks one option from a list plus probabilities), Score (rates on a user-defined scale), and Noul (yes/no probability via a sigmoid function).
Open source video
Passing unstructured text state and typed questions into jev(state, questions).
Open source video
Empirical Resultmedium noveltymoderate evidence

The economic and latency profile (300–500ms per evaluation, 20-decision chains under 9 seconds for <1/20th of a cent, Doom at 10 QPS for ~$7/hour) makes per-decision model calls viable inside tight control loops, not just document-level workflows.

Why it matters

If per-decision inference is cheap and sub-second, designers can put a model call at every decision point in a loop (game control, agent action selection) rather than batching or avoiding model calls for latency reasons.

Generalization

The architectural choice of where to place model calls (per-step vs per-task) is determined by the latency/cost floor of the model; lowering that floor enables finer-grained agentic control loops.

Jev evaluates inputs rapidly in 300-500ms with extremely low cost.
Open source video
Sequential action chains of 20 decisions execute in under 9 seconds for less than 1/20th of a cent.
Open source video
Playing Doom with 10 queries per second for ~$7/hour.
Open source video
Mental Modelmedium noveltymoderate evidence

The industry-wide shift toward System 2 reasoning (longer chains of thought, thinking budgets) creates a mismatch with software, whose dominant decisions are simple classification tasks, and frontier labs withold the chain of thought even when it is billed.

Why it matters

Frames reasoning-model adoption as a cost/latency liability for routine decisions, and highlights that paying for hidden chain-of-thought is an observability gap for anyone debugging model behavior.

Generalization

Choosing a reasoning model for a classification-shaped task incurs latency and token cost the task does not require; model class should match decision complexity.

Most decisions in software are classification problems.
Open source video
Asking reasoning models to return one-word answers wrapped in JSON incurs massive latency and token costs.
Open source video
Frontier labs do not let you see the chain of thought even though you pay for it.
Open source video

Deep dives

5

Calibration of decision-critical classifiers under distribution shift

Research question

How well-calibrated are Jev's reported confidences under distribution shift and adversarial inputs, and can RLCD-trained models maintain calibrated probabilities where RLHF/RLVR models fail?

Why

Confidence thresholds are used for routing and escalation in production; if confidences are miscalibrated under shift, deterministic control flow built on them will fail silently. A calibration benchmark establishes whether RLCD delivers on its promise.

explore its underlying mechanics (RLCD, parallel sampler)
Open source video
outputs typed choices, scores, and probabilities
Open source video
Source video

Boundary of non-autoregressive output heads

Research question

What classes of task can a non-autoregressive output head handle versus tasks requiring sequential composition, and where does accuracy degrade?

Why

Determines the architectural envelope: if non-autoregressive heads only handle single-step classification, then multi-hop reasoning must be decomposed into chained calls, affecting latency and cost models.

Jev has no chat box and does not write left-to-right token by token
Open source video
without chat interfaces, token-by-token generation, or hallucination of schema
Open source video
Source video

Reliability gains from typed calls vs chat+JSON extraction

Research question

Does replacing chat+JSON parsing with a typed call measurably reduce end-to-end failures, retries, and latency in production classification pipelines?

Why

The parse-and-fail layer is a known source of production incidents. Quantifying the reduction gives a concrete engineering justification for adopting typed model interfaces.

Jev is a System One model acting like a typed function call
Open source video
Asking reasoning models to return one-word answers wrapped in JSON incurs massive latency and token costs
Open source video
Source video

Durability of zero-output-token pricing

Research question

Is the free-output-token pricing a structural consequence of non-autoregressive inference or a temporary market strategy, and what are the implications for systems dependent on it?

Why

Systems that architect around zero marginal output cost could face repricing risk. Understanding the cost structure informs build-vs-buy and vendor lock-in decisions.

Output tokens are free on OpenRouter, while input tokens cost $0.042 per million tokens
Open source video
offering high speed and very low cost
Open source video
Source video

RLCD as a third training paradigm: calibration vs preference vs verifiability

Research question

Does RLCD measurably improve calibration metrics (e.g., ECE, reliability diagrams) versus RLHF and RLVR baselines on decision-critical classification tasks?

Why

If calibration objectives produce more trustworthy confidences, the training paradigm for decision models should shift; if not, RLCD is a branding exercise.

explore its underlying mechanics (RLCD, parallel sampler)
Open source video
Source video

Article ideas

4

Calibration is the New Accuracy: Why RLCD Matters More Than RLHF for Decision Systems

For decision-critical classifiers, calibrated probabilities are more valuable than preference-aligned or verifiably-correct outputs; RLCD's explicit optimization for epistemically honest probabilities addresses a gap that RLHF and RLVR leave open.

Angle

Training objective design: contrast RLHF (human preference), RLVR (verifiable rewards), and RLCD (calibrated decisions), arguing that confidence trustworthiness is a first-class requirement for automated routing.

Source video

The System 2 Detour: Why Most Software Decisions Need System 1 Classification

The industry-wide rush toward reasoning models with long chains of thought is a misallocation for the majority of software decisions, which are simple classification tasks; adopting System 1 models like Jev yields order-of-magnitude latency and cost improvements without sacrificing accuracy.

Angle

Contrarian: reasoning models are overkill for routing, spam detection, and escalation; propose a decision-complexity taxonomy to match model class to task.

Source video

Death to JSON Parsing: Why Typed Function Calls Should Replace Chat+Extraction

The pervasive pattern of prompting chat models to emit JSON and then parsing it is a fragile workaround; typed function interfaces that return structured values directly eliminate an entire class of production failures and should become the default for machine-to-machine model interactions.

Angle

Engineering reliability: quantify the cost of parse-and-fail, show how typed primitives (Choice/Score/Noul) map to control flow, and argue for schema guarantees at the interface level.

Source video

The Zero-Cost Output Token: How Non-Autoregressive Inference Changes System Design

When output generation is evaluated in parallel rather than decoded token-by-token, the marginal cost of a decision collapses, enabling per-decision model calls inside tight control loops (10 QPS, sub-second latency) that were previously economically irrational.

Angle

Economics-driven architecture: decouple output cost from answer-space size, and show how this enables fine-grained agentic control and dense action selection.

Source video

Project ideas

4

CalibrationBench: Reliability of Decision Models Under Shift

beyond-evals

Jev's reported confidences will show ECE < 0.05 in-distribution but ECE > 0.15 under distribution shift and adversarial prompt injection, while RLHF/RLVR baselines will show worse in-distribution calibration.

Proof of concept

Build a harness that queries Choice/Score/Noul primitives on a suite of classification tasks (routing, spam, PII) with known ground truth; compute reliability diagrams and ECE for in-distribution and shifted/adversarial variants; compare against chat-model self-reported confidence.

Measurement

Expected Calibration Error (ECE), maximum calibration error, and reliability diagrams across task families and shift conditions.

Source video

TypedCall vs JSON: Production Reliability A/B

new

Replacing a chat-model-with-JSON-extraction pipeline with a typed-call model (Jev) reduces malformed-output rate from >5% to ~0% and cuts end-to-end p95 latency by at least 50% for identical classification workloads.

Proof of concept

Implement two interchangeable microservices for the same tasks (support ticket routing, urgency scoring, escalation yes/no): one using a chat LLM with JSON extraction and retry logic, one using jev(state, questions). Run both against a replayed production workload.

Measurement

Malformed-output rate, retry rate, end-to-end p50/p95 latency, and cost per 10k decisions.

Source video

Non-Autoregressive Boundary Probe

new

A non-autoregressive output head matches autoregressive accuracy on single-hop classification tasks but exhibits significant accuracy degradation (>20%) on multi-hop composition tasks that require sequential latent reasoning within a single call.

Proof of concept

Create a benchmark of tasks with controlled composition depth (e.g., single classification vs. two-step logical composition vs. arithmetic then classification). Query Jev and an autoregressive baseline; measure accuracy as a function of composition depth.

Measurement

Accuracy degradation curve across composition depths, and comparison of chained single-step calls vs. single composed call.

Source video

Doom Per-Decision Control Loop Economics

movement-lab

A per-decision model call at 10 QPS in a real-time control loop (Doom) is economically viable (<$10/hour) and achieves comparable play performance to a batched approach, validating that non-autoregressive decision models enable fine-grained agentic control.

Proof of concept

Recreate the Doom demo: integrate Jev to make 10 decisions per second, measure cumulative cost over 1 hour, latency per decision, and game score; compare against a baseline that batches decisions or uses a slower model.

Measurement

Cost per hour, per-decision latency distribution, and in-game performance (score, survival time).

Source video

Architectural implications

3

Structured output is currently faked by autoregressive models writing JSON inside prose, then parsed by the caller.

Before

Caller prompts a chat model to emit JSON, then parses markdown/text to recover values, with fallback and retry logic for malformed output.

After

Caller invokes a typed function (jev(state, questions)) that returns the decision values and probabilities directly.

Consequence

The parsing/validation layer moves from the developer's harness into the model interface, removing a class of production failure modes and reducing response latency.

Source video

Output cost is currently proportional to generated tokens, so bounded answers still cost per token.

Before

Cost scales with output length; a one-word classification still pays for tokens and generation time.

After

Non-autoregressive evaluation of a bounded answer space decouples output cost from token count (output priced at $0/M).

Consequence

High-frequency, per-decision model calls become economically feasible, enabling model-in-the-loop control and dense agent action selection.

Source video

Decision-critical classifiers must expose trustworthy confidence for thresholding and routing.

Before

Confidences come from softmax over generated tokens or self-reported confidence, often poorly calibrated.

After

A training objective (RLCD) explicitly optimizes calibrated, epistemically honest probabilities.

Consequence

Teams can build deterministic control flow on confidence thresholds (routing, human escalation) with a principled expectation that stated confidence means what it says.

Source video

Tradeoffs and failure modes

4

Closed decision surface vs generative flexibility

Benefit

Typed Choice/Score/Noul returns are parse-free, fast, and composable.

Cost or risk

The model cannot produce freeform text or answers outside the predefined types, limiting its use for open-ended generation tasks.

There are only three kinds of questions: Choice, Score, and Noul.
Open source video
Source video

Self-reported calibration

Benefit

Outputs include confidence scores usable for thresholds and escalation.

Cost or risk

The claim of 'epistemically honest probabilities' is asserted by the vendor; whether confidence is actually well-calibrated under distribution shift is unverified in the summary.

RLCD optimizes for calibrated decisions with epistemically honest probabilities.
Open source video
Source video

Economic sustainability of free output tokens

Benefit

Output tokens at $0/M and $0.042/M input make high-volume use extremely cheap.

Cost or risk

A pricing model with zero output cost may be a launch-phase strategy rather than a durable cost structure; dependent systems could face repricing.

Output tokens are free on OpenRouter, while input tokens cost $0.042 per million tokens.
Open source video
Source video

Robustness of a non-chat decision interface

Benefit

Handles prompt injection, sarcasm, PII detection, and tool selection in demos.

Cost or risk

Adversarial inputs against a classifier that must still be trusted for routing/security decisions raise the bar for calibration and failure transparency.

It successfully handles prompt injection, sarcasm, PII detection, and tool selection.
Open source video
Source video

Open questions

4

How well-calibrated are Jev's reported confidences under distribution shift and adversarial inputs?

Why unresolved

The summary asserts RLCD produces 'epistemically honest probabilities' and cites a 97%-confidence routing example but provides no calibration curve, reliability diagram, or out-of-distribution evaluation.

Research direction

Build a calibration benchmark: measure ECE/reliability diagrams for Choice/Noul outputs across in-distribution and shifted inputs, including prompt-injection cases.

Source video

What classes of task can a non-autoregressive output head handle versus tasks requiring sequential composition?

Why unresolved

The summary describes parallel sampling of the answer and 20-decision chains, but does not specify whether outputs requiring composition or multi-step latent reasoning can be produced at all.

Research direction

Probe the boundary: test tasks requiring multi-hop composition or arithmetic within a single call versus chained single-step calls, and measure accuracy degradation.

Source video

Is the free-output-token pricing a structural consequence of the architecture or a temporary market strategy?

Why unresolved

The summary links $0/M output pricing to non-autoregressive generation but does not establish the underlying cost economics or provider terms.

Research direction

Analyze inference cost structure for parallel/non-autoregressive sampling versus autoregressive decoding and monitor pricing durability.

Source video

Does replacing chat+JSON parsing with a typed call measurably reduce end-to-end failures in production pipelines?

Why unresolved

The parsing-failure savings are asserted as practical implication but no comparative reliability data is provided.

Research direction

Run an A/B harness: identical classification workloads through a chat-model-with-JSON-extraction vs a typed-call model, measuring malformed-output rate, retries, and end-to-end latency.

Source video

Key claims

7
factualVerification needed

Jev has no chat interface and does not generate output left-to-right token by token.

Evidence

Jev has no chat box and does not write left-to-right token by token.

Question

Is output generation genuinely non-autoregressive, and what is the architecture of the parallel sampler?

Source video
factualVerification needed

Output tokens are free on OpenRouter while input tokens cost $0.042 per million.

Evidence

Output tokens are free on OpenRouter, while input tokens cost $0.042 per million tokens.

Question

What are the current published prices, and is the zero-output-price durable?

Source video
causalVerification needed

RLCD optimizes for calibrated decisions with epistemically honest probabilities, unlike RLHF and RLVR.

Evidence

Unlike RLHF (Human Preference) and RLVR (Verifiable Rewards), RLCD optimizes for calibrated decisions with epistemically honest probabilities.

Question

Does RLCD measurably improve calibration metrics (e.g., ECE) versus RLHF/RLVR baselines?

Source video
comparativeVerification needed

Jev is 40x-200x faster than frontier models with 700-500ms end-to-end response time.

Evidence

End-to-end response time is 700ms-500ms (40x-200x faster than frontier models).

Question

What baseline models and prompt/response configurations were used to compute the 40x-200x speedup?

Source video
factualVerification needed

Jev offers only three question types: Choice, Score, and Noul.

Evidence

There are only three kinds of questions: Choice, Score, and Noul.

Question

Does the API expose exactly these three primitives, and how are they composed or nested?

Source video
factualVerification needed

Sequential chains of 20 decisions execute in under 9 seconds for less than 1/20th of a cent.

Evidence

Sequential action chains of 20 decisions execute in under 9 seconds for less than 1/20th of a cent.

Question

Under what input sizes and concurrency was this measured, and does it hold in production conditions?

Source video
opinionVerification needed

Most decisions made inside software are classification problems, making reasoning models a mismatch.

Evidence

Most decisions in software are classification problems.

Question

What proportion of production AI decision calls are classification-shaped versus reasoning-shaped in real systems?

Source video

Connections

5