Video summary

Jev - The Ultimate Classification Model?

Main summary

Key takeaways

Technology

Main idea / framing

  • The video argues that many real-world tasks inside software don’t require “reasoning LLMs” (slow, multi-minute chain-of-thought).
  • Instead, they’re often simple classification/decision problems—such as:
    • routing tickets
    • detecting urgency
    • checking rule violations

  • The video criticizes reasoning/chat interfaces for:

    • Latency cost: generating lots of text to get a single label.
    • Black-box chain-of-thought: you can’t actually see the internal reasoning even if you’re paying.

  • The alternative presented is a “system one” model that behaves more like a fast function than a conversational chatbot.

Product introduced: Typesafe AI “Jev”

  • Company / model: Typesafe AI, model Jev
  • Founder: Dio Almida (former OpenAI contributor; co-author on the InstructGPT paper)
  • Conceptually positioned as a System 1 classification model: designed for automation and structured outputs without chatty text generation.

How Jev is supposed to be used (core API / features)

Jev takes:

  1. State: unstructured input text/data to classify (e.g., support ticket, agent trace, logs)
  2. Typed questions: only three types

Question types

  • choice: model selects one option from a provided list
    • Output includes:
      • the selected option
      • probabilities for every option
  • score: model returns a rating on a user-defined scale
    • Output includes scores/probabilities (as described in the demo)
  • null: yes/no-style question returning a probability of “yes” (0–1 range)

Key claims about outputs (from the video)

  • Probabilities are given as explicit numeric confidence values.
    • Presented as more reliable/less “fake probability” than LLMs that pretend to output JSON.
  • Jev is described as usable like a smart if-statement in code:
    • change thresholds in your application logic rather than rewriting prompts.

Demo / evaluation highlights (from the presenter)

Pricing (as stated in the video demo via OpenRouter)

  • ~$0.042 per million tokens in
  • $0 per million tokens out

Response speed / behavior

  • Responds very quickly (no multi-minute generation).
  • Likely stochastic:
    • repeated queries can yield slightly different results
    • but generally consistent.

Examples of tasks tested

  • Language ID / romanization
    • detects language quickly (including Thai characters)
    • can handle romanized variants
  • Sentiment scoring (example scale 0–2)
    • Positive → high end
    • Negative → low end
    • Mixed → middle
    • includes confidence/probabilities; costs described as extremely small per call
  • Question detection (null)
    • can detect questions even without a question mark (semantic cues matter)
    • performance varies with specificity (e.g., “Can you help find my cat?” vs vaguer prompts)
  • Support/work classification & routing
    • example: billing category detection (“charged twice…refund”) → high confidence
    • ambiguous text may yield an “unclear” class, reducing routing confidence
  • Multiple simultaneous decisions
    • runs multiple typed questions in one request (e.g., category + “was refund requested” + “is it time sensitive”)
    • time-sensitivity probability rises when “right now” urgency is present
  • Prompt injection / adversarial attempts
    • video claims Jev handles prompt injection-type inputs “pretty well”
  • Spam detection and PII detection
    • claims good performance at detecting personal identifiable information and spam
  • Content safety / code review
    • can classify whether something is safe vs unsafe
  • Agent tool selection
    • compared to function-calling: Jev mainly selects the tool (which function) rather than producing tool arguments itself
    • emphasized distinction:
      • tells “which tool to use” vs “extract arguments to pass”
  • Chaining decisions/actions
    • presenter strings ~20 classification tasks together sequentially
    • reports very low total cost (just over 0.12 cents, per description)
    • framed as a major advantage for building automation quickly

Under-the-hood / training & architecture (limited info)

  • The video states there’s no paper and no architecture diagram, so details are sparse.
  • Mentioned components:
    • a new model architecture
    • a parallel sampler
  • Training method:
    • RLCD = Reinforcement Learning for Calibrated Decisions

RLCD comparison (conceptual)

  • Compared to existing paradigms:
    • RLHF (reinforcement learning from human feedback)
    • reinforcement learning from verifiable rewards (referenced alongside GRPO-like approaches)

Performance/latency claims

  • Video claims Jev runs in a single pass (no token-by-token generation).
  • Reported runtime: roughly 70–500 ms, plus network round trip.

“Can’t hallucinate” claim (as explained in the video)

  • Not necessarily “no wrong answers.”
  • Rather:
    • it won’t break the schema you provide
    • it won’t invent invalid JSON structure or nonexistent tool names
  • It can still choose the wrong class option—so correctness isn’t guaranteed, but output format reliability is emphasized.

Takeaway / implications stated

  • The presenter suggests Jev could reduce reliance on:

    • fine-tuning small BERT-style classifiers for classification-only use cases
    • or using chat/reasoning LLMs when you only need labels

  • Notes it’s early days and predicts possible open-source follow-ons based on similar ideas.

Main speakers / sources (end)

  • Main speaker: the video presenter (name not given in subtitles)
  • Primary external source mentioned: Daniel Kahneman, Thinking, Fast and Slow
  • Company/model source: Typesafe AI — Founder Dio Almida
  • Research paper referenced: InstructGPT (via Dio Almida’s authorship mention)

Original video