A judgment in a SQL query

Natural language inside the query

The problem is a recruiter’s: a pile of resumes, and the need to find who fits. Roberts answers it not with an LLM agent loop, but with a single SQL select statement:

“So this is against a DuckDB, where we have a function.”00:09:24

The function calls Jev on each resume with a question in plain English, returns the probability as a score, and sorts descending:

SELECT substr(name, 1, 22) AS candidate, round(jev_noul(resume_body, 'Has this person worked on fraud, or trust and safety problems?'), 2) AS score FROM pool ORDER BY score DESC LIMIT 20;

Evidence: transcript 00:09:24

Pipelines vs. plumbing in 2.3 seconds

The pool holds 117 synthetic, ML-heavy resumes with made-up names, so fraud and trust-and-safety prompts score high immediately. To prove the model isn’t matching keywords, Roberts swaps the prompt inside scratch.sql to an adversarial question—every resume contains the word “pipeline” (data pipelines, AI pipelines), so he asks whether each candidate is qualified to perform plumbing:

“If you were going to just do a lexical search, it might pick up some of these.”00:09:24

Jev scores them all near zero without touching an index or training set, scanning the full table live:

“So we went over one hundred seventeen records.”00:09:24

“We had 2.3 seconds of wall time and spent almost nothing on this query.”00:09:24

Evidence: transcript 00:09:24

Retrieval without the retrieval stack

Normally, the recruiter problem requires an entire retrieval pipeline: chunk and embed resumes, load a vector database, run similarity search, and finish with a reranker. Looking closely at modern rerankers reveals why Jev collapses the stack:

“One interesting callout is the Quinn reranker.”00:08:03

Qwen’s reranker already asks a yes/no relevance question at the end of the pipeline. If the judgment model is fast and cheap enough to check every row directly, everything upstream disappears:

“But with Jeff, we basically take out all the embedding steps.”00:08:03

“I don't have to train anything up. I don't have to do embedding. I don't have to put things in a vector database.”00:08:03

Evidence: transcript 00:08:03

Why a decision model, not an LLM

Calling a model on every row or keystroke fails if every branch pays full LLM latency and cost. In a standard agent loop—request, decide, tool call, judge, repeat—invoking a frontier model at every branch puts slow System Two reasoning on trivial routing decisions:

“So one is there's too much intelligence.”00:00:37

“So you know, LLMs a lot of times are just a hammer looking for a nail.”00:00:37

Look at those harness branches in code and they reduce to plain control flow:

“it's really just a conditional.”00:01:42

Jev exposes three primitives mapped directly to code: probability (if/then), choice across up to 255 options (switch/case), and scoring (sorted). Unlike traditional classifiers that demand labeled datasets and retraining, plugging in a question generalizes zero-shot—Roberts tests “is a fish a pet?” (50/50) and disambiguates it 20 ms later with context:

“Oh, is a fish on my plate a pet? Clearly not.”00:03:17

Evidence: transcript 00:00:37, 00:01:42, 00:02:24, 00:03:17

From what you want to say to what you want to do

Standard autocomplete predicts the words of your question without moving you closer to completing the task. Workday’s prototype (fake data, not yet in production) flips the search box into an action surface that adapts live as you type—requesting time off, pulling a hidden payslip card, booking Friday’s 2 p.m. meeting with your boss, or popping up an org owner’s contact card with an email button:

“Where we go from predicting what you want to say. To predicting what you want to do”00:04:00

“This is not something that we could have done with an LLM.”00:04:00

Evidence: transcript 00:04:00

Jev picks the card; the team fills it in

Running at typeahead cadence stays economically viable because each routing judgment costs next to nothing:

“And you know we can do this at about twenty bucks for a million judgments.”00:06:42

Architecture splits cleanly into two steps: Jev gets the user in the front door, and the domain team owning that workflow defines the progressive questions that complete the task:

“So first, Jeb is picking the card”00:06:42

Before merging any new card into the library, teams test for intent collisions against existing cards—hitting 96% accuracy in initial seven-card experiments:

“We were able to get ninety-six percent accuracy on that.”00:06:42

Front-door intent routing and in-database SQL filtering share the same thesis: wherever an LLM felt too slow or expensive, small decision models open new territory:

“imagine the things that you can do when you have a decision model installed.”00:10:57

• Decision models replace retrieval stacks on focused pools: calling Jev inside DuckDB scored 117 resumes in 2.3s with no embeddings, vector DB, or training (00:08:03, 00:09:24).
• Action autocomplete runs at keystroke latency: at ~$20 per million judgments, UI cards adapt live while the user types (00:04:00, 00:06:42).
• Split intent selection from domain logic: Jev picks the card (96% across 7 cards); the owning team defines how the card finishes the work (00:06:42).

Evidence: transcript 00:06:42, 00:10:57