Build Anything with Jev, Here’s How

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.