Video summary

Build Anything with Jev, Here’s How

Main summary

Key takeaways

Technology

Summary of key technological concepts, features, and takeaways

  • New AI model class: “Jeff” (TypeSafe AI)

    • Positioned as fundamentally different from standard LLMs.
    • Does not generate tokens or text; instead it outputs probabilities/decisions.
    • Runs as a parallel, non-autoregressive model, producing scores for multiple options at once.
    • Claimed benefits: very low latency, very high speed, very low cost, and no hallucinations (especially for structured outputs/tool calls).

  • What Jeff does (product behavior)

    • Converts a text prompt into decision probabilities rather than natural-language answers.
    • Not a chat model—the intended usage is structured decisioning.
    • Example UI pattern:
      • Choose an option (e.g., which department handles a ticket)
      • Get a score (customer frustration level)
      • Get a probability (likelihood of refund request)
    • Typical response time claimed: ~100–150 ms (ranges mentioned: 70–500 ms).

  • “One model, many tasks” via criteria selection

    • A single Jeff request can score multiple criteria (category/urgency/refund eligibility, etc.).
    • Intended to avoid building/training separate classifiers—developers specify the criteria and Jeff returns the corresponding probability outputs.

  • Architecture & reliability vs LLMs

    • Explanation emphasizes that LLMs are token-by-token autoregressive, which is slower and can drift; Jeff avoids this by doing parallel probability evaluation.
    • Jeff is trained for calibrated uncertainty using a method described as RLCD (reinforcement learning for calibrated decisions).
    • Strong emphasis on structured output correctness:
      • 0% structured output hallucination rate claimed (contrasted with other models having non-zero error rates).
      • Tool-call error rate also claimed to be 0%, versus other models that may forget to call tools or call the wrong ones.

  • Performance & pricing claims

    • Claimed speed: 200x faster than current fastest models (also mentions 100–200x and 400x cheaper claims).
    • Claimed cost: output is free; pricing tied to input tokens only (example given: $42 per billion input tokens, with output tokens not charged).
    • Framed as enabling “intelligence too cheap to meter” style applications.

Use cases/examples highlighted

  • Fraud/legitimacy decisioning (e.g., invoice fraud)

    • Prompt like “Is this invoice a fraud?” returns probability breakdown (e.g., clean vs fraud vs review).
    • Emphasizes fast latency (~0.1s) and no token generation.

  • Real-time decisioning / games

    • Controls actions (e.g., move left/right/shoot) by scoring options using probabilities quickly enough for gameplay.

  • Self-driving / real-time navigation

    • Inputs like distance/speed/obstacles produce instant action decisions (accelerate/slow/stop/turn).
    • Emphasizes that LLM-style response times would be too slow for safety-critical control loops.

  • “Computer use” / UI navigation

    • Demonstrated as navigating a website interface (e.g., booking a flight) with very fast action-per-step decisions.
    • Claimed advantages: avoids mis-clicking and avoids hallucinations while producing structured, reliable actions.

  • Predictive spreadsheets

    • Example: as a user types urgency, Jeff classifies/labels many rows (e.g., “no follow-up needed” → “urgent”) in ~100 ms, scaling to hundreds of rows.

  • Predictable automation in customer experiences

    • Framed as enabling real-time interactions (e.g., customers clicking actions and receiving responses in ~100–150 ms, not seconds).

Guide/tutorial content included

Video’s “how to build” plan (Jeff-powered business)

The speaker outlines a 3-step process:

  1. Choose the right idea

    • Examples of Jeff-suitable products:
      • A Typeform competitor that ranks candidates in real time.
      • Adversarial test suites for CI/CD to break releases by automating exploratory checks.
    • Recommendation: improve existing deterministic apps or LLM-lite applications by replacing slow/expensive parts with Jeff’s fast probability decisions.

  2. Use a VPS to host your software

    • Claims you only need one VPS for a full-stack app.
    • Sponsorship: Hostinger VPS
      • Mentions setup steps like choosing a plan, region, and OS, plus using Coolify (open-source deployment manager).
      • Mentions using a Linux VPS (Ubuntu) for agent friendliness.

  3. Build and deploy a full-stack Jeff-powered app

    • Demonstration flow:
      • Create a full-stack app that presents an interactive form and uses Jeff to output structured probability categories (e.g., disqualified/mediocre/qualified/highly qualified).
      • Deploy via Coolify on the Hostinger VPS.
      • Use an inference provider compatible with Jeff:
        • TypeSafe direct API might be waitlisted, so the tutorial uses OpenRouter as a workaround.
      • Shows environment variables setup (API key, passwords), GitHub repo creation, CI/deployment pipeline using Dockerfile.

What the demo app shows

  • A “Signal”/form-like recruiting flow where the user’s inputs update the probability-driven evaluation in near real time.
  • Includes a “black box but inspectable” concept: the app can visualize probabilities and allow viewing the rules/decision results.

Main speakers/sources (as stated)

  • David Andre (speaker; “my name is David Andre… been making AI videos…”)
  • Mattia (referenced as providing the “best” Jeff explanation video/explanation)
  • TypeSafe AI (creator of Jeff; referenced multiple times)
  • Cognition AI / Nader (cited for the “predictive spreadsheets” example)
  • Rafal (cited for an adversarial testing suite example)

Mentions other AI figures/companies for context (e.g., Yann LeCun, Sam Altman, Dario, Cursor, OpenAI, Anthropic, etc.), though they are not the tutorial’s primary sources.

Original video