Jev AI Full Course: Build a Live Outfit Mirror, a Voice-Controlled Browser, and 10 Automation Use Cases
Four of Julian Goldie's separate Jev AI videos cut into one hour: a real-time voice-driven outfit mirror, an open-source voice-controlled browser, ten automation builds, and a standalone case for using Jev to stop wasting Claude and GPT-6 Astra tokens.
Jev is a fast, cheap decision-only model that never writes a word, and separating tiny yes/no/pick-one decisions from the big writing model is what actually makes AI agents faster, cheaper, and safer to leave running unsupervised.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
You run AI agents that burn tokens on hundreds of small yes/no or pick-one decisions every week (inbox sorting, lead scoring, internal linking, routing).
You've hit Claude or GPT context limits mid-session and want a concrete way to cut token usage without changing your actual workflow.
You want a plain-English tour of a brand-new model category (decision-only, non-generative) before deciding whether to build with it.
You're comfortable directing a coding agent (Claude Code or similar) to wire up a third-party API rather than writing the integration by hand.
SKIP IF…
You want a from-scratch, line-by-line coding tutorial. This is a demo-and-explain video; the actual build steps are one paragraph of instructions handed to an AI coding agent.
You're looking for an unbiased review. Roughly a third of the runtime is the same paid-community pitch (AI Profit Boardroom) repeated across all four segments.
You need production-grade guidance. Jev launched about a week before this video and every integration shown is explicitly marked experimental.
TL;DR
The full version, fast.
Jev is a new model from TypeSafe AI (built by ChatGPT co-inventor Diogo Almeida) that only makes decisions: given a situation, a question, and a fixed list of allowed answers, it picks one and returns a confidence score, in roughly half a second, for a fraction of a normal model's cost. It never writes anything, which is what makes it fast and cheap. The video is actually four of Julian Goldie's earlier videos stitched together: a real-time voice-driven outfit-picking mirror app, an open-source Jev Voice Browser that clicks and types from spoken commands, ten community-built automations (inbox sorting, lead scoring, internal linking, context-window compaction, and more), and a standalone segment on using Jev to stop Claude and GPT-6 Astra from re-reading your whole chat history for every tiny choice. The through-line: separate the writing (big model) from the deciding (Jev), set a confidence threshold for when to act automatically versus ask a human, and start with whatever boring decision you already make 100 times a week.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Previews the video's four segments: what Jev is, GitHub voice-control projects, cutting Claude/GPT-6 Astra token costs, and ten example builds.
02:00 – 04:35
02 · What Jev Is
Introduces Jev, built by ChatGPT co-inventor Diogo Almeida at TypeSafe AI: a model that only picks from allowed answers and returns a confidence score.
04:35 – 06:27
03 · Decision Types
Explains the three question types: choice, score, and null, and notes several can be batched into one request.
06:27 – 08:59
04 · Early Build Examples
Covers the first public Jev builds: research paper sorting, email sorting, lead scoring, and a flight-finding browser agent.
08:59 – 10:58
05 · Internal Linking Case
A 586-page site gets its internal link map rebuilt in 45.1 seconds versus Claude Opus 5 completing only 21 pages in the same time.
10:58 – 12:51
06 · Two Key Features
Model routing via a LangChain integration and tool-call safety checking are named as the two features that made developers pay attention.
12:51 – 14:10
07 · Context Compaction Debate
A plugin drops a Claude session from ~1M to 86,000 tokens using Jev; developer Theo publicly disputes the approach.
14:10 – 16:14
08 · Limits and Pricing
Covers what Jev can't do (write, prove outcomes, resist being tricked) and its pricing/access via OpenRouter.
16:14 – 19:28
09 · Why It Matters
Frames confidence scoring as solving a trust problem rather than a capability problem for business owners.
19:28 – 22:14
10 · Real Time App Demo
Demos a live webcam 'mirror' app that repaints the presenter's outfit in real time based on spoken requests.
22:14 – 28:15
11 · Build the App Steps
Breaks the mirror app into ear (Chrome speech), brain (Jev), and tailor (image/video model), built by directing a coding agent.
28:15 – 29:59
12 · Voice Browser Project
Introduces Moritz Kremper's open-source Jev Voice Browser project.
29:59 – 32:50
13 · How Voice Browser Works
Explains the three-part pipeline: Chrome speech-to-text, Jev deciding, and Playwright moving the browser.
32:50 – 33:24
14 · Speed Benchmarks
Nine simultaneous voice-command questions answered in ~400-445ms per request.
33:24 – 33:53
15 · Instant Decision Gap
Head-to-head benchmark: Jev at 445ms/8-of-8 versus Claude Haiku, Gemini 3.8 Flash, and GPT-5.6 Luna at 1.6-2.5s/7-of-8.
33:53 – 34:43
16 · Search by Voice Demos
Live demos searching Wikipedia and naming a specific site ('search GitHub for Playwright') by voice.
34:43 – 35:16
17 · Pointing Prevents Hallucinations
Explains how the browser fills text fields by pointing at substrings of the user's own words instead of generating text.
35:16 – 36:03
18 · Boardroom Offer Pitch
Community/offer pitch for the AI Profit Boardroom.
36:03 – 36:27
19 · How Voice Browser Clicks
Explains the page snapshot of up to 100 labeled clickable elements that Jev must choose from.
36:27 – 37:18
20 · Snapshot Labels Confidence
Below a 0.45 confidence threshold, the app shows numbered badges and asks the user to pick directly.
37:18 – 37:46
21 · Install Jev Voice Browser
Installation is four terminal lines using the viewer's own OpenRouter key; recommends reading the code first.
37:46 – 38:30
22 · Wrap Up and Next Video
Closes out the voice browser segment and transitions to the next.
38:30 – 39:22
23 · Ten Use Cases Overview
Previews the ten upcoming builds: self-sorting inbox, self-linking website, task board, context meter, and more.
39:22 – 41:07
24 · System One Model Explained
A condensed recap of the System One framing and three question types before the ten builds.
41:07 – 41:57
25 · Use Case 1 Inbox Sorting
500 emails sorted into folders in seconds for three and a half cents; only low-confidence emails need human review.
41:57 – 43:12
26 · Use Case 2 Keyword Intent
A keyword export gets each row tagged with search intent and a target page, visualized filling in with color.
43:12 – 44:10
27 · Use Case 3 Lead Scoring
700 leads and their outreach messages scored in 40 seconds for 9 cents, flagging message/lead mismatches.
44:10 – 45:50
28 · Use Case 4 Auto Linking
Restates the 586-page internal linking case as a repeatable one-question-per-page pattern.
45:50 – 46:40
29 · Boardroom Community Plug
Community/offer pitch for the AI Profit Boardroom.
46:40 – 47:45
30 · Use Case 5 Publish Traffic Light
Content drafts get three simultaneous Jev checks and route to publish, review, or rewrite.
47:45 – 48:59
31 · Use Case 6 Model Router
A LangChain dashboard routes requests to cheap or expensive models based on a plain-English description of each model's strengths.
48:59 – 50:10
32 · Use Case 7 Context Meter
Restates the context-compaction win and Theo's pushback as a buildable visual meter.
50:10 – 50:46
33 · Use Case 8 Competitor Monitor
A monitor asks one yes/no question per detected competitor-site change so only meaningful changes light up.
50:46 – 51:41
34 · Use Case 9 Talk to Browser
Restates the browser-use flight-finding example as one of the ten numbered builds.
51:41 – 52:50
35 · Use Case 10 Task Board
A mission-control dashboard routes job cards to whichever agent is actually available right now.
52:50 – 53:48
36 · What Changed Summary
Three-part recap: writing/deciding split apart, decision volume stopped being cost-limited, confidence became settable.
53:48 – 54:43
37 · Final Boardroom CTA
Community/offer pitch for the AI Profit Boardroom.
54:43 – 54:59
38 · Ten Builds Closing
Closes out the ten-use-cases segment.
54:59 – 55:46
39 · Stop Wasting Tokens
Opens the fourth, standalone segment on cutting Claude/GPT-6 Astra token costs with Jev.
55:46 – 56:07
40 · Tokens Explained
Defines a token as the unit models use to measure how much text they read.
56:07 – 56:58
41 · Why Chats Get Expensive
Every message resends the whole prior chat; logged real messages cost 124K-222K tokens for one short reply.
56:58 – 57:25
42 · Big Models Waste Tokens
Frames big models as 'professors' wasted on hundreds of tiny binary choices.
57:25 – 58:43
43 · What Jev Is
A third, condensed restatement of Jev's situation/question/answers shape for standalone viewers.
58:43 – 59:50
44 · Outfit Race Benchmark
Seven simultaneous outfit decisions answered together via Jev versus one-at-a-time through three big models.
59:50 – 1:00:55
45 · Voice Browser and Email Speed
Restates the voice-browser and email-sorting examples specifically as token-savings wins.
1:00:55 – 1:01:19
46 · Forum Training Plug
Community/offer pitch for the AI Profit Boardroom.
1:01:19 – 1:03:19
47 · Three Step Implementation
The concrete recipe: spot the small choice, write the question and answers in plain English, set a confidence line.
1:03:19 – 1:04:06
48 · Costs and Confidence Limits
Restates Jev's per-token input cost, no output charge, and that it's for deciding, not writing.
1:04:06 – 1:04:38
49 · Final Thoughts and Outro
Closing thanks and final community pitch.
Atomic Insights
Lines worth screenshotting.
Jev never writes a single word. It only picks from a fixed list of allowed answers and returns a confidence score, which is the entire reason it's fast and cheap.
TypeSafe AI calls Jev a 'System One' model: the fast, reflexive part of decision-making, as opposed to the slow, deliberate 'System Two' writing every current AI agent uses for every decision, including trivial ones.
A developer sorted 1,018 research papers into 24 categories for 8 cents total, at 256 milliseconds per paper, by having Jev pick the category after a summary was written.
One internal-linking run rebuilt a 586-page website's link map in 45.1 seconds for 21 cents; Claude Opus 5 given the same job and clock only got through 21 pages.
On that same linking job, Jev refused to place links on 139 pages because nothing fit, which the presenter calls more valuable than the 584 links it did place.
A lead-scoring run on 700 personalized outreach messages took 40 seconds and 9 cents, and its most useful output was flagging messages that didn't match the lead they were sent to.
One plugin dropped a Claude Code session's context from nearly 1 million tokens to 86,000 in about a second by having Jev score every tool call in history for relevance and drop the low scorers.
A developer named Theo publicly pushed back on that context-compaction use case, arguing that cleaning up history isn't the same as filtering it and can erase the reasoning trail behind a long-running agent's decisions.
Jev bills only for tokens sent in, at roughly 4 cents per million tokens, with no charge for output, because there effectively is no generated output.
Confidence is not accuracy: a high-confidence Jev answer means the model is sure, not that it's correct, so outcomes still need to be checked independently (the browser-use team verifies task completion separately from Jev's 'done' signal).
Jev doesn't see the name of a field or question, only its literal text, so a vaguely-named field like 'safe to publish' does nothing; the actual question text has to carry the instruction.
In a same-page, same-commands benchmark, a Jev-driven voice browser answered 9 questions per request in ~445ms and got 8/8 commands right, versus Claude Haiku (1.6s, 7/8), Gemini 3.8 Flash (2.2s, 7/8), and GPT-5.6 Luna (2.5s, 7/8).
The open-source Jev Voice Browser fills text fields by having Jev point at a substring of the user's own spoken words rather than generating text, which the presenter argues prevents it from putting words in the user's mouth.
In a personal 4-job benchmark, Jev answered outfit-picking questions in 413ms versus Claude Haiku (1,486ms), GPT-6 Astra (3,269ms), and Claude Sonnet 5 (4,545ms) for the same decisions.
The presenter's own agent messages showed real chat re-reads of 124,000, 186,000, and 222,000 tokens for single short replies, because every message resends the entire conversation history.
Takeaway
Separate the deciding from the writing, and set a line for when to trust it.
WHAT TO LEARN
A model that only picks from a fixed list and reports how sure it is can replace most of the small yes/no/pick-one decisions currently costing a big model a full read of your context, as long as you set a confidence threshold for when a human still needs to check.
01Course Overview
The video previews four distinct things it will cover: what Jev is, GitHub projects for controlling a computer by voice, cutting token costs on Claude and GPT-6 Astra, and ten concrete example builds.
02What Jev Is
Jev is built by Diogo Almeida, one of the co-inventors of ChatGPT, after two years spent quietly building a new training approach at TypeSafe AI.
Jev can't write an email, code, or even explain its own answer; it only picks from a list of allowed answers and reports a confidence number.
03Decision Types
The three question types (choice, score, null) cover almost any small decision an agent currently escalates to a big model.
Asking several of these questions about one situation in a single request barely changes the speed or cost versus asking just one.
04Early Build Examples
A developer sorted 1,018 research papers into 24 categories for 8 cents total, at a quarter-second per paper.
A browser-use agent found flights in 7 seconds for under half a cent by having Jev pick from a freshly rebuilt list of clickable page elements after every click, cutting browser commands from 1,092 down to 101.
05Internal Linking Case
Jev rebuilt the internal link map for a 586-page site in 45.1 seconds for 21 cents, placing 584 links and correctly leaving 139 pages alone.
The same job given to Claude Opus 5 only got through 21 of the 586 pages in the same amount of time.
06Two Key Features
LangChain shipped a model-routing integration where Jev reads a request in plain English and picks the cheapest model capable of handling it.
A second use is safety-checking tool calls before an agent executes them, the same kind of guardrail previously locked inside closed coding-assistant products, now usable on any homemade agent.
07Context Compaction Debate
Scoring every tool call in an agent's history for relevance and dropping the low scorers took one Claude Code session from nearly 1 million tokens to 86,000 in about a second.
Developer Theo publicly disagreed, arguing that cleaning up history for space isn't the same operation as filtering it for relevance, and that losing the reasoning trail can cause problems on long tasks.
08Limits and Pricing
Jev cannot write anything and a high-confidence answer is not proof something actually happened; outcomes still need independent verification.
Pricing is about 4 cents per million input tokens with no charge for output, currently accessible free until September 25, then via an OpenRouter API key.
09Why It Matters
The presenter frames the real barrier to automating work as trust, not capability: people already believe an agent can draft the email, they just don't trust it to pick the right one.
A confidence number attached to every decision turns that trust problem into a settable threshold rather than a guess.
10Real Time App Demo
The demo app is a live webcam 'mirror' that repaints the presenter's outfit in real time based on spoken requests, using Jev to decide which clothing item fits and an image/video model to render it.
A single spoken sentence breaks into seven simultaneous Jev decisions (top, jacket, trousers, shoes, extras, room), all returned in under a second.
11Build the App Steps
The build has three parts: Chrome's built-in speech-to-text as the ear, Jev as the brain deciding from a plain-English closet list, and an image/video model (Lucy/FAL) as the tailor rendering the result.
The actual construction step was telling a coding agent (Claude using the Fable 5.1 model) to build the app with Jev in one sentence, then writing the decision questions and one-line answer descriptions by hand.
12Voice Browser Project
This segment introduces a separate open-source project, the Jev Voice Browser by developer Moritz Kremper, released September 8th under an MIT license.
13How Voice Browser Works
The system has three parts: Chrome's built-in speech recognition turns voice into text, Jev decides what action is meant, and Playwright (the same library used for website testing) moves a real browser.
Jev is re-asked every time a new spoken word arrives, and if the user keeps talking, the previous in-flight request is cancelled in favor of a fresh one, so the answer is often ready by the time the sentence ends.
14Speed Benchmarks
Each voice command asks Jev roughly nine questions at once (intent, target element, which site, whether the sentence is finished, scroll distance, etc.) and gets all of them back in around 400-445 milliseconds.
15Instant Decision Gap
On the same eight commands, Jev answered in ~445ms with 8/8 correct, while Claude Haiku, Gemini 3.8 Flash, and GPT-5.6 Luna each took 1.6-2.5 seconds and got 7/8 correct.
16Search by Voice Demos
Live demos show the voice browser searching Wikipedia's own search box for 'Espresso' and naming a specific site ('search GitHub for Playwright') to jump straight to that site's results page.
17Pointing Prevents Hallucinations
Rather than generating search text, the code slices the spoken sentence into candidate pieces and Jev only points at which piece to use, then copies it letter for letter, which the presenter argues prevents the model from inventing words that were never spoken.
19How Voice Browser Clicks
Before every decision the app snapshots the page into up to 100 short-labeled clickable elements, and Jev can only answer with one of those existing labels, so it can't click something that isn't actually on the page.
20Snapshot Labels Confidence
When Jev's confidence on which element the user meant falls under 0.45, the app shows numbered badges on its top candidates and asks the user to pick a number directly, bypassing the model entirely for that reply.
21Install Jev Voice Browser
The project installs in four terminal lines using the viewer's own OpenRouter API key, running locally against a Chromium browser tab; the presenter recommends reading the code first before installing.
23Ten Use Cases Overview
This segment previews all ten upcoming builds: a self-sorting inbox, a self-linking website, a task board that assigns its own cards, and a context meter, among others, all powered by a model that can't write a single word.
24System One Model Explained
A condensed recap of the System One framing and the three question types, positioned here as the prerequisite context before the ten builds are shown.
25Use Case 1 Inbox Sorting
Every incoming email becomes a situation with folder options (reply, research, wait, flag); Riley Brown sorted 500 real emails in seconds for three and a half cents.
The confidence score is what makes it usable day to day: only the emails Jev is unsure about land in a pile for the user to actually check.
26Use Case 2 Keyword Intent
A keyword export (2,000-20,000 rows) gets each row tagged with search intent (informational/commercial/transactional) and a target page, visualized as a spreadsheet filling in with color from the top down.
The presenter frames this as functionally identical to the 1,018-paper sorting example, just swapping documents for keyword rows.
27Use Case 3 Lead Scoring
Builder Roman scored 700 leads plus their personalized outreach messages in 40 seconds for 9 cents, with a second question checking whether each message actually matched the lead it was written for.
The mismatched-message flags are described as the most valuable output on the board, since a good message aimed at the wrong person is silently wasting outreach effort.
28Use Case 4 Auto Linking
Restates the 586-page internal linking case as a repeatable pattern: one question per page (which other page should this link to, if any), visualized as lines appearing between page nodes.
The presenter notes he personally runs internal and cross-site linking across several sites, calling it hundreds of small weekly yes/no decisions that used to be manual.
30Use Case 5 Publish Traffic Light
Every content draft gets three simultaneous Jev checks (does it answer the target search, does it make unsourced claims, are the internal links relevant), producing green/publish, amber/review, or red/rewrite outcomes.
The presenter says the review step, not the writing step, was always his actual publishing bottleneck across multiple sites.
31Use Case 6 Model Router
A LangChain-built dashboard routes each incoming request to a cheap or expensive model based on a plain-English description of what each model is good at, tracking actual spend against what would have been spent sending everything to the expensive model.
32Use Case 7 Context Meter
Restates the context-compaction example (Alex Volkov's plugin dropping a session from ~1M to 86,000 tokens) as a visual meter builders could add to their own long-running agent sessions.
Repeats Theo's pushback that deleting versus reordering/summarizing history is still an open question, since the underlying approach is about a week old at time of filming.
33Use Case 8 Competitor Monitor
A monitoring agent asks Jev one yes/no question per detected change on a competitor's site (does this change actually matter), so only a handful of meaningful changes light up out of a wall of otherwise-silent daily tiles.
34Use Case 9 Talk to Browser
Restates the browser-use flight-finding example (7 seconds, under half a cent, 1,092 to 101 browser commands) as one of the ten numbered use cases, with the same honest caveat that it finds flights but doesn't book them.
35Use Case 10 Task Board
A mission-control dashboard routes incoming job cards (content, research, site fix, video) to whichever AI agent is actually available right now, rather than a fixed assignment list, with unsure cards sliding into a 'you' lane.
Twenty cards sort themselves into agent lanes in about two seconds, which the presenter says is what makes it safe to leave an agent queue running unattended, e.g. overnight.
36What Changed Summary
Three-part recap: writing and deciding used to be one job at one price and are now separate; the volume of decisions that's economically viable stopped being limited by cost; and confidence became a settable number rather than a guess.
39Stop Wasting Tokens
Introduces the standalone premise of this fourth segment: current AI agents route hundreds of tiny decisions through big models that then re-read the entire chat history to answer each one.
40Tokens Explained
Defines a token as the unit Claude and GPT-6 Astra use to measure how much text they read, and notes that hitting a plan's token limit is what stops an agent mid-session.
41Why Chats Get Expensive
Every new message resends the entire prior conversation; the presenter's own logged messages show single short replies costing 124,000, 186,000, and 222,000 tokens because the whole chat rides along each time.
42Big Models Waste Tokens
Frames large models as 'professors' well suited to planning, writing, and fixing hard problems, but wasteful when used for hundreds of tiny binary choices an agent hands them by default.
43What Jev Is
A condensed third restatement of Jev's three-input shape (situation, question, allowed answers) for viewers who are watching this segment as a standalone video rather than continuing from earlier in the compilation.
44Outfit Race Benchmark
One sentence about an outfit becomes seven simultaneous Jev decisions answered together in under a second, versus running the same seven choices through Claude Haiku (1,486ms), GPT-6 Astra (3,269ms), and Claude Sonnet 5 (4,545ms).
45Voice Browser and Email Speed
Restates the voice-browser and email-sorting examples specifically as token-savings wins: for these jobs the big model reads zero tokens because Jev handled the decision instead.
47Three Step Implementation
The concrete recipe: spot which of your agent's decisions already work like a short multiple-choice quiz, write the question and allowed answers in plain English with a one-line description per answer, then set a confidence threshold for auto-acting versus escalating.
Recommends having an existing coding agent (e.g. Claude with OpenRouter access to Jev) propose which of its own current decisions could move to Jev, rather than manually auditing the whole system.
48Costs and Confidence Limits
Restates Jev's roughly $0.04-per-million-token input cost with no output charge, and reiterates that it's suited to optimizing decisions, not to writing, which is where most of the token savings actually come from.
Glossary
Terms worth knowing.
Jev
A decision-only AI model from TypeSafe AI, released September 2026. Given a situation, a question, and a list of allowed answers, it picks one and returns a confidence score; it cannot generate free-form text.
System One model
TypeSafe AI's term for Jev, borrowed from the psychology idea of fast, reflexive thinking versus slow, deliberate 'System Two' reasoning. Jev is built only for the fast, reflexive layer of decisions.
Confidence score
A number between 0 and 1 that Jev returns alongside its answer, indicating how sure it is. Builders set a threshold above which the app acts automatically and below which it asks a human.
Choice / Score / Null question
Jev's three question types: choice picks one option from a list, score rates something on a scale you define, and null answers yes/no as a probability between 0 and 1.
Tool call
A single action an AI agent takes during a session (a file read, a search, an API request). Long-running agents accumulate hundreds of these in their context history.
Context compaction
Reducing an AI agent's stored conversation/tool-call history to free up context window space, either by summarizing it or scoring and discarding entries judged no longer relevant.
OpenRouter
A third-party API marketplace that lets developers call many different AI models, including Jev, through one unified API and key.
Playwright
A browser automation library, originally built for testing websites, that can programmatically click, type, and scroll in a real browser window.
Token
The unit AI models use to measure how much text they read or write. Longer chat histories mean more tokens re-read on every new message, which is slower and more expensive.
Resources
Things they pointed at.
02:00toolJev (TypeSafe AI)
14:10toolOpenRouter
10:58toolLangChain (model-routing integration)
37:18toolJev Voice Browser (Moritz Kremper, GitHub, MIT license)
“Confidence is not the same as accuracy. A high confidence answer means the model is sure. It doesn't mean the model was right.”
important, quotable caveat that cuts against the hype→ newsletter pull-quote↗ Tweet quote
54:59
“Every time you send a message, the AI reads a whole chat again from the top. By message 50 it reads a whole book just to answer one line.”
visceral explanation of why long chats get slow and expensive→ TikTok hook↗ Tweet quote
16:14
“A model that says, I'm 62% sure you should look at this one, solves a trust problem, not a technical one.”
reframes the real barrier to automation as trust, not capability→ newsletter pull-quote↗ Tweet quote
The Script
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
Jev AI, the full one hour course on how to build and automate anything. So today we're going to be talking about Jev AI, how to use it, how to use it for free, how to basically build and automate anything. And this is the full course, step by step, walking you through what might be the most revolutionary AI model that's just dropped this year.
And it's a totally different class of model for AI that can potentially make your AI models 20 to 200 times faster and 40 to 400 times cheaper. And you can basically build and automate anything. So you can see, for example, in this post from Ronak, he actually built out a system where Jeff is playing Minecraft.
You can also get it for free. We'll be talking about how to use it, GitHub projects, what Jeff AI is, how it works, how to build and automate AI apps with Jeff, how to control your computer with Jeff AI voice agents, how to reduce token costs on Astra 6 and Cloud Table 5 using the system, and also 10. example builds with jeff ai and actual use cases so feel free to you know check out whichever bit you're interested in by the way if you want to get access to this for free it is free until september 25th as of making this if you are watching it after that point well you can actually get jeff directly from open router and then you can create an api key like this once you've done that you can actually just go into any agent whether that's chat gpt or claude and start using it now if you want to see some examples of what we've built with it you can use it for controlling your browser with your voice for example you could even for example have a live app like you can see right here which we can basically
use extremely fast in pretty much real time using this system right here combined with Jev AI. So you can basically build and automate anything and it is unbelievably powerful. So with that, let's just get straight into it and we'll start talking about what Jev AI is, where you can use it, the use cases, and again, we'll be covering all of this.
The person behind it is one of the people who actually co -invented ChatGPTA. His name is Diogo Almeida. He spent the last two years quiet.
building a new way to train models. And this week he released JEV, J -E -V. And the numbers he put on it are 20 to 2 times faster than a normal AI model and 40 to 400 times cheaper.
And then somebody actually plugged it into Claude Code as a plugin. One second later, that Claude session went from nearly like 1 million tokens down to 86 ,000. One second, same work, same session, but a fraction of the context, which is pretty wild.
So what actually is this thing? And why is everyone building with it inside a week? Well, Jeff is not a chatbot.
He is not a coding model. He doesn't write at all. You can't ask it for an email.
You can't ask it for code even. You can't even ask it to explain why it picked something. What it does do is make decisions, fast ones, thousands of them.
So you can hand it the current decision and the current situation. You hand it a question with set answers. It picks one and tells you how sure it is.
Now, TypeSafe AI, the company behind it, calls this a system one model. You want to think of it like the fast part of your brain. When you see a red light, you don't write a paragraph about the red light.
You just stop. That's system one. Writing the paragraph is system two.
And right now, every AI agent you run uses the paragraph brain for everything, including the red lights. Now, here's what that actually looks like in real life. Let's say, for example, you have an agent doing research for you.
Along the way... It has to answer a pile of tiny questions. Do I have enough sources yet?
Should I right now keep looking? Is this good enough to send? Or should a person check it?
Which tool do I use next? And every one of those tiny questions currently goes to a big model. A big model that reads the whole history, thinks about it, writes out its reasoning, formats it, hands it back, seconds go by, tokens get spent, and the actual answer was one word.
That's a gap. Jeff feels. And once you understand that gap, you start seeing it everywhere in your own setup.
And there are three kinds of questions you can ask it. And they cover almost everyone. So the first one is choice.
You pick from a list. Which step goes next? Which folder does this go in?
Which of my writers handles this? It gives you the pick plus a probability for every option plus how confident it is overall. The second is score.
So you would... rate this against levels you define yourself how relevant is this source on a scale from unrelated to directly on topic how strong is this lead it gives you a number back and it can land between levels not just on them and the third one is called null it's a yes or no does this message sound urgent does this need a human to approve it it gives you the probability the answer is yes So 0 .999 means almost certainly yes.
Someone sitting near 0 .5 means it genuinely doesn't know, which is useful information on its own. And that last part is the bit that most people skip over. Jev doesn't just answer, it tells you how sure it is.
So you can set a line above this level, carry on automatically. Blow it, stop and ask me. And that single idea changes how much you can safely handle over.
Because... The thing that stops most people automating the work isn't the AI being wrong. It's not knowing when it's wrong.
And you can ask it lots of questions all at once. All the questions in one request get answered in parallel. So asking five questions in one request means instead of one barely changes, it doesn't really change the speed and barely changes the cost.
You can ask, for example, which step next? How urgent is this? And does this need approval in a single go?
and get all three back together. Now, let me run you through what people actually built this in the first few days, because the results are specific and they're all public. Let's start with research.
So a developer called Hassan. ran 1 ,018 AI research papers for it. He summarized each paper first, then sent the title, the summary, and 24 possible topics to Jeff and let Jeff pick the category.
All 1 ,018 papers cost 8 cents total. The middle time per paper, start to finish, was 256 milliseconds, a quarter of a second per paper. Next, we've got email sorting.
So, Riley Brown, I actually ran 500 emails through it, sorted in seconds, three and a half cents for the lot. Each email goes in as a situation and the options are things like reply, research, this first, wait or flag for me.
Every answer points the email at a different folder or a different helper. Next, we've got lead scoring. So a builder called Roman fed it 700 leads along with the personalized outreach messages written for them in 40 seconds.
Jeff predicted how each message would land, gave each one a confidence score, and flagged the ones where the message didn't match the leads. So that was nine cents. That last one matters more than it sounds.
The flagging of mismatches is the interesting part. It's not just rating your outreach, it's pointing at the messages that were aimed at the wrong person. Next up, you've got browsers.
So the browser use team... put Jev inside a browser agent. It found flights in seven seconds.
The cost of that run was under half a cent. The way they did it is pretty clever actually. So after every click, the page changes.
So they rebuild the list of things you can actually click right now and let Jev pick from that fresh list. So when a box needs typing in, A small writing model fills it.
Jeff decides the small model types and the browser clicks. And they measured the difference properly. Their tuned version cut out the middle number of browser commands from 1 ,092 down to 101.
And the middle task time dropped 25%. So the same models on both sides. The speed came from cleaning up the loop, not from a bigger brain.
One honest note for that flight example. It finds flights, it doesn't book them. And the seven second clock starts after the first page load.
Worth knowing before you repeat that. And there's one actually closest to what I would do personally for my SEO agency. So a guy named Borja on X actually pointed Jeff at his website to rebuild the internal links.
586 pages. It read all of them and rebuilt the internal link map. In 45 .1 seconds, it placed 584 internal links.
And on 139 pages, it placed nothing because honestly, nothing fit. That was 21 cents. He ran the same job with Claude Opus 5.
Same 586 pages, same clock. Opus got through 21 pages. That's 586 against 21.
And the refusing to link 139 pages is the part that I probably care about the most, right? Internal linking goes wrong. when a tool forces a link on every page just because it was told to.
Being able to say nothing fits here is a scoring job, not a writing job, which is exactly the kind of work this model was built for. I actually run content across several sites at once, internal linking, cross -site linking, working out which article should point at which one. That's hundreds of small yes or no decisions every single week.
So those have always been the slow, expensive part. Now, a quick word before I get the... parts that actually make this genuinely feel different.
If you want to use Jev inside your own business without touching a line of code, come join us in the Airprofit Boarding. We've built an agentic operating system. You can get a zip file, you can plug in Claude, Hermes, OpenClaude, all of it into one dashboard, shared memory, and the exact job Jev does, routing work between your agents, scoring leads, sorting your inbox, deciding what needs your eyes and what doesn't.
That's the layer we'll be walking through step -by -step on the coaching calls. You get four of them every single week. Daily tutorials, a 30 -day roadmap on getting your first agent running and pointed at bringing in customers.
And over 3 ,000 business owners are inside there already. A lot of them have never used AI before they joined. Link in the description or go to theairprofitbomb .com to get access.
Now, let's talk about the features, the two features that made developers pay attention this week. Because both of them solve problems you've almost certainly hit. The first is routing between models.
You've got cheap, fast models and expensive smart models. Every request you send, somebody has to decide which one it goes to. Usually that's you guessing, or it's a big model deciding which costs you a big model call before any work happens.
Now, LandChain actually shipped a Jev integration for exactly this. So you list your models. You describe in plain English what each one is good at, the direct lookups and small changes for the cheap one and hard decisions for the expensive one.
And Jeff reads a request and actually picks and the whole run uses that model and the probabilities stay available afterwards. So you can look back and check whether the routing was sensible. The instruction you can give it can be as simple as choose the cheapest model that can finish this job.
The second one is safety checking on tool use. And this is the bigger deal. So, coding harnesses like Claude have been checking risky actions before they've run for a while now.
Something looks at the new command and decides whether to allow it or ask you first. That checker has always been locked inside the closed part of the product. You couldn't use it on your own AI agents.
Now that a cheap, fast classifier exists, that same pattern works anywhere. as a wrapper you put around your AI agent. It watches the tool calls, checks each one for risk, and blocks it before it runs.
So the guardrail that used to be a feature of somebody else's product becomes something you add to your own setup. That's the thing I'd pay attention to if you're running AI agents that touch real work. And now let's talk about the context one, because that's where the loudest reaction came from and where the honest pushback came from as well.
So someone worked out that Jeff... could score every tool call sitting in an agent's history and drop the ones that don't matter anymore. That's what took that session we mentioned earlier from nearly a million tokens to 86 ,000 in about a second.
People reported context going from 90 % fall down to 9%. It cuts of, you know, 30 to 60 % in context windows were common. And a well -known developer, Theo, disagreed with the whole approach.
His point... was that cleaning up history is not the same as filtering it. Compaction exists to keep a proper record of what happened.
And if you score tall calls one by one and throw away the low scorers, you can lose the reasoning trail that explains why the agent did what it did on a long task that can cause real problems later. And I think he's right about the risk and I also think the direction is correct. Your agent's history is full of stuff that mattered for two minutes.
hasn't mattered since. A model that can score relevance in a second is obviously useful there. Whether you use it to delete things or just to decide what to summarize first, that's the open question, and it's a week old.
So, you know, this stuff is really brand new. Which brings me to what Jay and Jeff can't do, because this is where people are going to trip up. It can't write anything.
So the research still gets done by a normal model. The draft still gets done by a normal model. The file still gets saved by your code.
Jev is only going to pick for you. And confidence is not the same as accuracy. A high confidence answer means the model is sure.
It doesn't mean the model was right. And it definitely doesn't prove anything happened. If your agent confidently says this file was saved, you should still check whether that file exists.
Browser use does exactly this, right? After Jev says done, they actually went back and checked the outcome separately. And it can be tricked.
So early testers have flagged if someone feeds, for example, text into the situation you hand the model, and they can push the decision. That's the same risk every agent has, but it lands differently when the model is deciding what your system does next. One more detail that's easy to miss.
Jev doesn't see the name you give your question. So if you call a field safe to publish, that name does nothing. The instruction has to be in the question itself and the options have to be described properly.
If you write, does this contain anything that shouldn't go public? That would be much better and not just a tidy label. Same goes for what you feed it, telling it the research you finished gives it almost nothing.
Give it the sources and the findings and what's still missing. The quality of the decision follows the quality of the situation and the context you give it. Also, Jev charges for what you send in.
There's no charge for what comes back. Right now it's about 4 cents per million tokens going in. So if a decision costs you 1 ,000 tokens of context, 10 ,000 decisions comes with roughly 42 cents.
It's in beta on OpenRouter, which means you can reach it in the same way you reach everything else you're probably already using. The number to actually watch is cost per finish task, not cost per decision. A cheap decision that sends your agent down the wrong path costs you far more than decision saves.
So cheap routing, the route's badly as expensive. And that's something you want to understand too. So here's the shape of what's actually changed in three parts.
Number one. Writing and deciding used to be the same job, done by the same model, at the same price. Now they're actually separate.
The big model researches, plans and writes. Jeff roots, scores, approves or escalates. Your code does the thing.
Number two, decisions. So decisions used to happen one after another because each one needed a full model call. Now you can ask a whole batch of questions about the same situation at once and get them all back together.
the waiting in the middle of your agent mostly disappears. And number three, confidence became a number you can add on. So you can set a line above it, run below it, come and ask.
And that's what makes it safe to leave something running, you know, once you go off and do something else. And that third one is the reason this matters more to a business owner than to a developer right now, because the thing holding most people back from handling real work to an agent is trust. It's not capability.
You already know it can write the email. You just don't know whether it'll send the right one or the wrong one, right? A model that says, I'm 62 % sure you should look at this one, solves a trust problem, not a technical one.
Now, here's the honest state of things. The integrations are marked experimental, right? So smart people are arguing about the right way to use it.
The safest use right now is the boring repeated decision you already make 100 times a week, right? Sorting, scoring, routing, flagging, which is usually where the real gains are hiding. Anyway, if you're sitting there thinking, this all sounds like...
a developer territory look at what these jobs actually were sorting 500 emails scoring 700 leads deciding which page should link to which page picking which of your helpers handles the next job those are admin tasks so the task you're doing manually right now or paying somebody else to do or just not doing because there's no time the tools got cheap and fast enough this week that no time stopped being the reason and the gap between the people who set this up and the people who read about it It's going to open up fast, right?
It's not about being technical anymore. Every result I've given you today comes from someone describing a decision in plain English and giving the model a list of options. That's the whole skill.
So if you want help actually building this into your business, come and join us inside the AI Profit Boardroom. You get the agent operating system, there's a zip file, Claude Hermes, open call, plugged into one dashboard, sharing one memory, and we keep updating it to things like JevLand. So you're not rebuilding from scratch every time a new model shows you.
You also get four coaching calls every week where you can bring your own setup and ask what should be rooted, what should be scored, and what should still come to you. Daily tutorials showing you exactly how to wire a decision layer into your letter sorting, your inbox and your content, a 30 -day roadmap so you know what to build first, a prompt library, and a member map so you can find people near you doing the same thing.
We've got over 3 ,500 business owners inside, plenty of them. with zero AI experience before they joined. The link in the comments description or go to theairprofitbomb .com.
The people who separate the writing from the deciding are going to run faster agents for a fraction of the cost. Everyone else keeps paying frontier prices for a one -word answer. Start with the decision you make over and over, give it a list of options, measure what happens, and then take the next one from there.
and we'll show you a powerful app that i've created with jev ai so this is the app so you can see it runs in real time it's basically using jev ai to create decisions in real time so for example i can give myself a microphone over here i can change the headphones to something like this and it works almost instantly this is pretty much real -time video as you can see here and we can change our outfit this app works in real time and it's unbelievably fast as you can see using jeff ai so i'm going to show you how to build real -time live apps like you see today and you can see the jeff cost over here so it's very cheap to use really cool this is actually based and inspired by naively tank so thank you very much for the idea fantastic idea and with that we're going to get straight into how to do this So what is Jev AI?
Well, most AI models write. You ask something, then type an answer, word by word, and that takes seconds. Jev doesn't write at all.
You hand it three things, which is a situation. For example, I can say I'm giving a keynote tomorrow. I'm wearing a t -shirt and shorts, whatever it is, a question.
For example, which jacket should I wear? And then also a list of allowed answers. So for example, red blazer, leather jacket, overcoat, or, you know, keep what I have.
It picks one answer and then tells you how sure it is. So for example, like a red blazer, 81 % sure. It never writes a paragraph or explains itself.
Now, because it never writes, it answers in roughly half a second. And it was 95 to 99 .5 % cheaper. then the model's actually tested against it.
So you can ask it like hundreds of small questions without even noticing. So you want to think of it like the fast part of your brain. When you see a red light, you don't write an essay about it, you just stop.
Jev is built for that kind of snap call. Now, why does Jev suit an app like this? So basically there are three reasons.
Number one is speed, right? So a mirror that takes five seconds to react feels like it's not. working but jev answers faster than you can actually finish noticing you ask so in my test the full writing model takes about 4 .6 seconds for the same decision you can only answer from your list a writing model might say for example wear a nice navy cardigan and when you don't own one the app just breaks jev can only pick from the closet you gave it which you can see right here so every answer is something like the app can actually use and it tells you how sure it is Now, it can also answer many questions in one go.
So one sentence from you becomes like seven questions at once. So for example, what kind of request is it? The top, the jacket, the trousers, the shoes, the extras, and the room itself.
All seven come back in under a second. That's how we built it. So how can you emulate this sort of system?
How does it work step by step? So first of all, you've got part one, which is the ear. And this is the speech feature that's already actually built into Chrome.
So it can turn your voice into text and you can type instead. You don't even need to use AI for that part. Part number two is the brain, which is Jev.
So this is basically like a small program running on your Mac. When text arrives, it sends Jev your sentence, what are you currently wearing, and seven questions, each with its allowed answers. And the closet is a simple list.
So every item has a name and one plain line. saying when you would wear it. So for example, for a red blazer, that line is Julian's signature on stage look, keynotes, conference talks.
And that one line per item is all Jeff actually knows about how to pick your clothes, which we can check from over here. After Jeff picks, the program asks Jeff one more question. How well does this outfit fit what he asked for?
Zero to three. If the score is under two, it tells Jeff the look. clashes and lets it pick again and then finally you've got the tailor which is the picture itself so we've got two versions number one is photo mode so this is like an image model that takes you know one photo of you you can add your own photo and it repaints the clothes and the room and everything else the first time it draws a look that takes about 10 seconds after that look is saved it appears instantly and then we also have live camera mode which you can see over here right and this is basically using my webcam as you can see And it uses a real -time video model as well.
So that model can edit the video whilst it's playing. And each time Jeff decides the app, the app sends the API one new sentence, such as, for example, changes Alfred to a red blazer, a white t -shirt, navy trousers, or put him on a conference stage. So this is using an API called Lucy, and Lucy changes the moving picture about one to two seconds.
later. Then you have the glue and the glue is just one web page and one small server, right? So your keys stay on the server, nothing secret reaches the browser and all the intelligence in the app is the list of questions and the one line of description per clothing item.
Everything else is plumbing. Now in terms of how you can set this up, let me show you. You can use this for any app, right?
This is just a cool example but you could use this for pretty much anything. So, for example, what I did over here is I went into Claude, I was using Fable 5 .1, and I said, can you build this with Jav AI, but make it more unique? It created the image version, but it wasn't quite as nice as I liked it.
You can see here it's running the local host, so all the heavy lifting, all the technical work was done by Fable 5, which is what we like. I also wanted to compare the costs, which we did over here. And look at the difference in cost, by the way, versus Haiku and Sonic 5.
It's absolutely unbelievable. Also, the speed and response time here, way, way faster. And then basically after that, I asked it to create the real -time version.
And it uses a combination of FAL with GEV to create that system, which is unbelievable. Really, really powerful stuff. We can also say what we're doing here.
So we can say or type where we're going. And we can use voice mode too. And it's just very, very quick at making decisions, which makes the whole app work very quickly indeed.
So how can you build something like this? Well, basically, you don't need to code. You just tell a coding agent what you want.
I use Cloud Code. You can use whichever you prefer. And you just want to make sure it has access to Jeff.
Then you're going to explain the app in one sentence. So, for example, you could say, I say this, it decides why, and then I see Z change. It's a three -step app, really, when you look at this.
As cool as it is. And then you're going to write the decisions or get Claude to write the decisions. And this is the actual skill.
So, for every decision that Jeff is going to make, you're going to write the question and the allowed answers in plain English with one... line and when each answer fits. So if the app does something silly, the fix is almost always a clearer line and rarely the code.
And you can always include like a do nothing or keep it answer as well. Then you want to use the confidence score. So when Jeff's confidence is high, you let the app act.
When it is low, have the app ask you or do nothing. And this is what stops the app from just doing silly things or breaking. And finally, you want to pick a fast output.
So the API we used for this, both with Jev and also with Lucy, super fast. And then test it with real sentences. See the outputs as you're testing out the app.
And then also you can see here that we can watch the costs of the app as well. So we can check it over here and also over here too. So Jev, very, very cheap to use in general.
You know, and you could build this for anything. It could be like a voice -controlled slideshow. It could be, for example, an interactive shop window.
It could be an index sorter. It could be like a game where actually as you play it, it generates itself and creates everything step by step. Pretty unbelievable.
If you want to get my full training on how to use Jev AI, all my best systems on this, if you want to connect with me personally and join an amazing community of people building with AI automation, feel free to check out the AI Prof Boarding. We've got loads of training on Jev AI inside there. Inside the community, you can ask questions, get help and support in real time, post questions, etc.
I personally answer them every day. Inside the classroom, you can get access to all my best trainings on this sort of stuff. In the calendar, you can drop a weekly coaching course.
ask questions, get help and support in real time. And then in the map, you can meet people in your local area who are building out with AI agents like you. So feel free to get this link in the description or just go to the AIprofitbomb .com.
Thanks for watching.
to a real browser and it moves before you finish your sentence. This is a new project that just got released by Moritz Krem. So shout out to him.
And basically this is a free GitHub project that you can use with Jev AI to control your browser. Let me show you an example of how it works. So we've got the browser set up here.
And basically it listens to what I'm doing and then it follows my instructions based on this, right? So you can see the proof's history. You can see the decisions.
And if you're wondering, okay, how does Jev AI work or anything like that, I'll come on to it in a second. But if we open this up and we have, for example, Chromium over here, which we can control with our voice using Jev AI over here, we can say, okay, start the mic and open up Google for me. And boom, look at that.
Look how fast it is. Open up bbc .com. Open up Google.
And then we'll stop the mic there. So I'll close this. But you can see how powerful and easy that is.
Now, the way this works, I'll break it down step by step for you. It can basically move and you can talk to a real browser and it moves before you finish your sentence. So you can say, for example, I go to DuckDuckGo.
and the page is already loading as the last word leaves your mouth. You can say, for example, scroll down a bit, click the models link, open a new tab, and a real browser window does it with your hands off the keyboard. And you can set this up to run locally on your machine.
You can see a demo of it working right here as an example. And this is pretty powerful and fun to use. So you can see how it works right here.
You can control it with your voice on the right -hand side, and then on the left -hand side, it can open stuff up for you. And there's basically three parts to this. Your voice, a model that decides, and a real browser.
So what is this? Well, basically it's a small app, the developer called Moritz Kremper on GitHub. On September the 8th, the code is opened, source, and it carries an MIT license as three parts.
So step number one is your voice goes into the speech tool that's built into your browser. So for example, like Chrome. And that turns it into words as you speak.
Those words go to a model named Jev. which makes the decision, and a tool called PlayWrite moves the real browser window. And that's the same tool developers use to test websites, so it can click and type like a person would.
Now, Jev actually can't write a single word. It only picks an answer. So, if you saw my tutorials on it already, this came out earlier this week from a company called TypeSafe, started by Diego Amalda.
Now, Jev, it can't write a single word. So you can hand it a situation and a question with set answers. It picks one and tells you how sure it is with a number between 0 and 1.
So for example, last week, I actually used it for keyword research sorting and that sort of thing. Now, this asks again every time a new word arrives. So the old way is the left -hand side, the new way is right.
So what's actually new here? Well, voice control has been around for years. AI agents that click around a browser have been around a while too.
And you can run them every single day if you want. The new part is when the decision happens. So most voice tools wait for you to stop talking.
and then send the whole sentence to a big model, wait for it to think, and then move. This one asks Jev again every time a new word arrives. Each ask takes well under half a second.
So by the time you finish the sentence, the answer is usually already sitting there. And if you keep talking, the old ask actually gets cancelled, and a fresh one goes out. So you want to picture it like a waiter who stops writing the moment you change your order.
So if we have a look over here, for example, this is the system we've set up. You can see the log over here. And you see everything they've created.
Now, each time you use it, it asks Jeff about 10 questions in one go. You know, what does this person want? Go somewhere, search, click, type, scroll, go back, switch tab.
Which thing on the page do they mean? Which website? Have they finished the sentence?
Are they even talking to me? How far should I scroll? Which of their words should go in the search box?
And Jeff basically answers them all at the same moment. So 10 questions take about as long as one. So in my runs, each request carried nine questions and came back in around 400 milliseconds.
So if we go back to Chromium here, which is where we can control the voice browser, and then we can start the mic over here. Open up Google in a new tab. Type into Google AI SEO.
Press enter. So you can see how fast it moves. So I actually wanted to know how that compares.
I actually ran a small test and we tested. The same pages, the same eight commands. Now, Jeff answered nine questions each time with a middle time of 445 milliseconds and got all eight right.
Then the same pages went to three fast models people use every day with one question instead of nine. So we just tested out Claude Haiku. And that took 1 .6 seconds.
Gemini 3 .8 Flash took 2 .2 seconds. GPT -5 .6 Luna took 2 .5 seconds. Each of them got 7 out of 8.
So why is Jeff quicker? Well, a normal model reads out a page and then writes his answer out. One small piece at a time.
Jeff reads a page and hands back a handful of numbers. It's the gap between a multiple choice test and an essay question. There's nothing to write, so there's nothing to wait for.
Now this is a small test, eight commands, and those models weren't tuned for this example, but you can feel the gap in music. Half a second feels like the browser is basically listening to you and ready to act straight away. So here's another example with Wikipedia.
So this is a Wikipedia article about coffee. If you type in or if you say search for, it's waiting. Search for Espresso and it uses the search box that's already on the page.
It types Espresso, presses enter and we land on the Espresso article. So if the page has no search box of its own, it can fall back to a normal web search anyway. Another example here is we said search GitHub for Playwright.
So you can name the site with this voice browser. You can say search GitHub for Playwright and Jeff will pick two things. Which site you meant.
and which of your words are the search. Then the code fills in an address it already knows for that site and the results page opens. I ran that one on my own machine.
It went straight to GitHub search results for Playwright. Now the code itself will cut your sentence into pieces and Jeff only points at one. So Jeff can't write, but how did the word espresso get into that search box, which you can see right here?
Well, the code cuts your sentence into possible pieces, so Jev only points at one of them. Then the code copies it letter for letter. And the difference here is like a model that writes can make things up.
A model that can only point at your own words can't put words in your mouth. So it's the same with web addresses, right? The code owns a list of sites and Jev just picks from it.
Now, if you want to build things like this into your own business, so you've got a browser you can talk to, an inbox that sorts itself, agents that make small decisions in half a second, that's actually what we do inside the AI Profit Boarding. You get my agent operating system with one dashboard where Claude, Hermes, OpenClaw and everything else can plug into one system with a memory.
We've added our own tools in there for SEO, for videos, for AI avatars, and you can add your own workflows too. You also get a video walkthrough and a 30 -day roadmap for setting it up and daily updates as we improve it. There are also...
four coaching calls a week where you can share your screen and we'll wire Jev up with you live and the daily tutorials cover new setups like this one as they come out. We've helped over 3 ,400 business owners inside there and some of them have never used AI before they joined. Links in the comments description if you want to get access.
Now here's another example so we can actually tell it to scroll up, scroll down a bit, scroll to the bottom, scroll up a page etc and you can see that the Jev AI browser can actually control our browser with our voice. just by giving it actions over here the microphone we could say for example click the models link right and for example here is actually navigating my website goldie bench going through the site and then clicking buttons for us which is pretty unbelievable now you might say okay how does it know what's on the page here so before every decision the app takes a quick snapshot that's up to a hundred things you could click or type into each with a short label for example like e04 So Jeff's answer is just one of those labels.
It can't click something that isn't there, if that makes sense. Now, it doesn't guess. It puts numbers on the page and then asks.
And when it isn't sure which thing you mean, it doesn't actually guess. If Jeff's confidence score is under 0 .45, the app puts little numbered badges on its top picks right there on the page and asks which one. So you can say two.
That reply doesn't even go to the model. The code handles it. And this basically scrolls through the page and then analyzes the numbers on the page on where to go to.
So you can see here it's navigating to a website. Now you might see this is like something technical to set up, but basically you can just get the GitHub details, which you can see right here. It's called JevVoiceBrowser.
And then from there you can install it if you want to. I would check through the code first, make sure you're happy with it first before you install anything like that. It's just four lines in a terminal.
You can also use your open router key with it. And then once that's done, you can basically access it via a local page inside your Chrome and control Chromium with it. So that's basically it.
And then it looks at the patterns, what you're working on, and everything else step by step. So pretty impressive model, easy to use, easy to set up. We've actually got a lot of training on Jev AI inside the AI Profit Boarding.
Link in the comment subscription or go to the AIprofitbomb .com. Inside the community, you can ask questions, get help and support in real time. And we have loads of people asking questions.
And I just personally create like video tutorials for you as well and try and help you. Plus, it's an awesome community of people like learning and growing along the journey. Inside the classroom, you can get access to all of our best trainings, tutorials, step -by -step guides.
In the calendar, you can jump on weekly coaching calls, ask questions. And then this is all available inside the AIprofitbomb. Link in the comments description or go to the AIprofitbomb .com.
Thanks for watching. I'm going to show you 10 things, 10 use cases with Jeff AI, and you can watch every single one of them. This includes an inbox that sorts itself whilst you look at it, a whole website lighting up as it links itself in a website, a task board that hands its own cards to the right AI agent to get stuff done, and a context meter.
Drop in from nearly a million tokens to 86 ,000 in one second. And the model doing all of it can't even write a single word. This is Jev AI.
And Jev came out this week from a company called TypeSafe AI. The man behind it. it's yoga amalda one of the people who co -invented chat you spent two years quietly building this and the claim on it is 20 to 200 times faster than a normal ar model and 40 to 400 times cheaper answers come back in about a tenth of a second too so here's what it actually does in one breath because you need this before the builds that i show you actually make sense.
So how does this work? Basically, Jeff decides. You hand it a situation.
You hand it a question with a set of answers. It picks one and it tells you how sure it is, right? It won't write your emails.
It won't write your article. It won't even explain itself. It just picks.
So type safe causes a system one model. So you want to think of this as the fast part of your brain. Red light, you stop.
You don't write a paragraph about the red light first. Every agent you run right now uses the paragraph brain for everything. Every little which folder does this go in, every is this urgent, every who handles this next goes to a big model that reads everything, thinks, writes out its reasoning and hands back a one word answer three seconds later.
Now, Jev itself is built for that layer and it changes what you can put on a screen because when a decision costs almost nothing, it takes almost no time. You can make thousands of those decisions live in front of you and watch the results move. Now, there's three different question types and you'll see all of them in the build.
So I'm going to show you today. Number one is choice. So you can pick from a list, hands back the pick, a probability for every option and a confidence score.
If you rate something against levels you set yourself, you get a number back, right? No. is the second type of question this is basically where you get yes and over probability from zero to one 0 .999 is almost certainly yes near 0 .5 means it genuinely doesn't know and that's useful on its own and you can ask all three about the same thing one request you come back together so let's get straight into the 10 builds each one is something you could sit and watch or build yourself.
So number one, the inbox that sorts itself. Every email comes in as the situation. The options are your folders, reply, needs, research, wait, flag, me.
Jeff picks and the email moves. On screen, you see like 200 emails drop into folders, one after another, like cards being dealt and a small pile of maybe 12 landing in the actually needs you pile. Really know the shape works and what it costs, right?
Riley Brown actually ran the same. situation. So he ran 500 emails for it, sorted it in seconds and three and a half cents for all of them, right?
The bit that makes it usable is the confidence score. Anything Jeff is sure about moves on its own. Anything it's unsure about goes in the pile for you.
So you're not checking 500 emails, you're checking the 12 it wasn't sure about. Let's talk about use case number two. So this is a keyword list coloring itself in.
So you could take a keyword export, for example, for SEO. That might be like 2 ,000 rows or it might be 20 ,000, right? Every row needs an intent, informational.
Is it commercial? Is it transactional, et cetera, right? And a home, either an existing page or a new one for your website, right?
So let's say we're talking about which pages to create content for. By the way, these are all keywords based on my Google Search Console data. And this is actually something that we're using.
You can see a full demo of it right here. So you can run it through Jeff and watch the spreadsheet fill with color from the top down. Blue for informational, green for commercial, orange for transactional, gray for the ones it isn't sure about, which is the column you probably actually read.
The cost is basically nothing. So a developer called Hassan published and pushed 1 ,018 documents through Jeff, right? 1 ,018 research papers.
To sort them into 24 categories, 8 cents total, a quarter of a second each. Swap documents for keywords and the job is identical. I've got a keyword agent inside my setup that pulls ideas in all week, right?
Now sorting what it finds was a boring part, but now we can automatically do it with something like Jeff AI. Number three, a lead board with confidence scores. So let's say, for example, you're getting loads of leads, as you can see right here, and Jeff scores each one, medium, strong, and weak.
And it gives it a confidence number. Then a second question runs on the outreach message written for that lead. Does this message actually match this person?
On screen, leads sort themselves into columns, and a handful turn red. The red ones are where the message and the leads don't match. Good message, wrong person.
Now, a builder called Roman ran exactly this. So 700 leads with personalized messages, 40 seconds. It predicted how each message would land, scored its confidence, and flagged the mismatches.
It cost nine cents. That red column is the most valuable thing on the board because that's what the outreach was quietly wasting your time. And you see an example right here of how it works.
Number four, a whole website linking itself. So if you're doing any sort of SEO, if you have a website, all your blogs need to link so that Google can crawl them. It's a lot of work.
It's painful. It used to take days, and sometimes it was a total waste of time. So, for example, picture every page on your site as a dot.
If you run Jev over the lot asking one question per page, which other page should this link to? If any, you can then watch lines appear between dots and watch some dots stay unconnected. Now, a guy named Borja, who actually talks about SEO on X, he did this on a 586 -page website, rebuilt the internal link map in 45 .1 seconds, placed 584 links, 21 cents.
Same job with Claude Opus 5, same clock, Opus got through 21 pages. But the number that matters is 139. That's how many pages Jay left alone because nothing honestly fit.
Now, anyone who's used any sort of automated tool, you know, whether that's for internal linking or anything else, knows why that matters. If you tell a tool to do something and it does it everywhere, sensible or not, that's not very useful.
But if it can tell you, okay, listen, nothing fits here. Don't do that, right? It can push back a little bit when it knows that it's not moving in the right direction.
Well, that's actually super useful for you. Now, for me personally, I run content across several sites. So this is hundreds of small...
links, small internal links between each page. Watching it happen in under a minute is quite a different feeling to just manually handle this inside a spreadsheet. Now a quick one before number five.
Because five is where these builds start talking to each other. If you want to build these yourself without writing code, come and join us in the Air Profit Bomb community. Link in the comments description or go to theairprofitbomb .com.
We've built an agent operating system. You can get a zip file of Claude Hermes open call all plugged into one dashboard of one shared memory. And this deciding layer is exactly what we're going to add to it as Jeff matures.
On the coaching calls for... a week you can bring your own inbox your own leads your own site and we can set up the systems with you live you get daily tutorials showing you how these sort of systems work and automations 30 -day robot to get your first one running and pointed at bringing in customers over 3 000 business owners inside plenty of them had never used ai before they joined and now they're mastering it link in the description or just go to theairprofile .com to get access So let's come on to use case number five, the publishing traffic light.
Every draft that comes out of the content pipeline stops at a light before it goes anywhere. Jeff asked three questions at once. Does this actually answer the search it was written for?
Does it make a claim with no source behind it? Are the internal links sensible? This is really powerful for AI SEO.
Are the internal links relevant for the page? Three probabilities come back in one go. Green and it publishes to WordPress and gets pushed for indexing straight away for that piece of content and that blog post.
Amber and it waits in a review folder for you. Red and it goes back to the writing model of a note. On screen it's a queue of drafts moving through a light.
One after another, most going green, a few paws in amber, and you can see your whole publishing day and your SEO strategy in about 30 seconds. Now, I publish across multiple sites with Claude Code, and the check -in was always a bottleneck, never the write -in, right? Easy to automate the write -in.
And you can run this exact system through any AI agent. Claude Code is something that I prefer, but you can choose whatever you want to. Number six, the model router with a live cost counter.
So you've got cheap fast models and you've got expensive smart models. Something has to choose which one each job goes to. Usually, that's you guessing or a big model choosing, which costs you a big model call before any actual work starts.
Now, Langchain actually shipped a ready -made piece for this. So you can describe in plain English what each model is good at, small edits and lookups for the cheap one, hard decisions for the expensive one, and Jeff reads a request and picks. The visual is a beautiful dashboard, as you can see.
Right here, every request comes in on the left. It gets a label and slides to a model on the right. Underneath, you've got two counters.
One is what you're spending. The other is what you would have spent sending everything to the expensive model. Watching the gap between those two numbers grow throughout the day is a whole point, right?
The instruction for this can literally be choose the cheapest model that can finish this job. And you can see some examples of what... Langchain have built right here.
Pretty impressive stuff. Really powerful, as you can see right here, where you can pick between the agents, the options, and it's really good at decisions. Number seven, the context meter.
So this can, you can basically build a context meter, you know, and anyone who runs long agent sessions knows the feeling of this. The context bar fills up, the agent gets slower. and doesn't respond as smartly or as quickly, you end up restarting and losing your place or having to reset the whole conversation with clear or compact.
Now, Jeff can score every tool call sitting in a nation's history for whether it still matters and drop the ones that don't. Now, Alex Volkov actually ran this as a plugin in some... Claude, right?
One second later, his session went from like nearly 1 million tokens down to 86 ,000. Other people showed their meter dropping from like 90 % full to... Now, you could build something super visual for this, as you can see right here.
And an honest note on this, right? So a well -known developer, Theo, pushed back on this. His point was that cleanup history isn't the same as filtering and scoring items one by one, and being the scorers can lose the trail explaining why the agent did what it did, right?
So the direction still makes sense, whether you delete or just reorder is the open question. This is all about a week old, right? It's very new technology when you're using GFAI.
Number eight, the competitor monitor that only lights up when it matters. So I've got an agent that watches competitor sites. The problem with monitoring is that most changes don't matter.
A typo fix, a date change, a new footer link. If every change pings you, you're going to stop looking. So Jeff can sit between the monitor and the dashboard with one yes or no question.
Does this change actually matter to us? Every change then gets a probability. Only the ones above your line light up.
On a screen, it's a wall of tiles, one per competitor, all dark throughout the day. Two or three will go bright. And these are the ones actually worth your attention on that day.
Everything else gets scored and quietly filtered. Number nine, the browser you talk to. So you could say, for example, to your AI agent, find me a flight to London next Friday out loud and watch your browser move.
You could click type and scroll results in seven seconds. Now the browser use team actually built the underlying agent for this. So after every click, the page changes.
So they rebuild the list of things you can click right now. and let Jev pick from that fresh list. So when a box needs typing in a small writing model, it can fill it, right?
Jev decides the small model types and the browser clicks. Their run found flights in seven seconds for under half a cent. They measured the tune -in with browser commands dropping from 1 ,092 to 101 and task time dropping 25%.
It was the same model on both sides, right? The speed just came from cleaning up the loop. Honest note, it's going to find flights, so it's not going to book them for you.
Still pretty fun. to check out as a personal sort of task with Jeff AI as well. Task number 10, the task board that hands out its own cards.
And this is the one that ties everything together. It's one that's pretty fun to use. So, you know, let's say, for example, I have a mission control dashboard, which you can see right here with the Asian OS.
And let's say new jobs come in for the AI agent, a content job, a research job, a site fix, a video job, right? Right now, something has to look at each card and decide which agent handles it. It could be Claude Code, Hermes, OpenClaw.
That decision has always gone to a big model, which means every card costs a full model call before any work done, which can get quite expensive if you're running frontier models, right? Now, Jeff can take that job. Each card is the situation.
The options are the agents are actually available right now, not a fixed list. Jeff picks and the card slides into that agent's lane. Cards he isn't sure about slide into a lane called you.
On screen, 20 cards drop onto the board and set themselves into lanes in about two seconds. Then the agents start working and you don't have to touch anything. The detail that makes it safe is the same detail from number one, which is confidence.
So you can set a line. Above it, the card moves. Below it, the card waits for you.
And that's what allows you to leave this whilst you just go out for a walk or something like that. Or, you know, I could run overnight even. So let me pull this together into what actually changed.
Three things. Writing and deciding used to be the same job. Now they're totally separate.
Jeff can do all the sorting and deciding for you. Volume stopped being the limit. Every one of these 10 builds was possible before, but it was quite expensive.
Now you can reduce the costs and the limits and the tokens, which means that it gets a lot cheaper. And number three, confidence became something that you can actually add on. And this reduces the amount of hallucinations you get because you can set a confidence line and be like, okay, above this, go for it.
Below this, don't do it, right? And if you look at what the actual skill was in every build, if you describe a decision in plain English, you don't need to be a developer to use any of this, right? You just write out the options clearly, set a confidence line, that's the whole thing.
Now, this is brand new technology. You know, we're still learning how to use it. But it seems like quite a revolutionary improvement in AI agents, whether it will stick around or not long term.
Who knows? Let's see. But I want to show you 10 use cases because I know a lot of people will be asking about this inside the AirProp for Boardroom.
I would just start with something boring you decide to do every week. Maybe you have to make a decision like, you know, every day. You can easily automate it with Jeff AI instead.
If you want this whole system. with a Jev Masterclass. Come join us in the Air Profit Boardroom.
You get the agent operating system, a zip file with Claude Hermes, open -claw plugged into one dashboard, sharing one memory, and we're building a Jev deciding layer into it as it matures. So your inbox, your leads, your publishing, et cetera, is all going to sort itself. You also get daily updates, four coaching calls a week where you can bring your own setup and we can wire it live.
Daily tutorials for each one of these 10 builds, a 30 -day roadmap so you know which one to build first, a prompt library, and a member map so you can meet other people running AI agents near you. We've got over 3 ,000... 500 business owners inside the AI Profit Boardroom already.
Link in the comments description or go to the airprofitboardroom .com. That was 10 builds with Jeff AI, every one of them doing something that number one is super visual, but number two helps you understand how to use it and how to make the most of it. I would pick the one that matters to you the most right now and then implement it.
Don't try and do it all at once. Cheers for watching. Jeff AI, how to stop wasting Claude and Jeep6 Astro tokens.
Here's how to reduce your Claude and GP6 Astra token usage with Jeff AI. So right now, your big AI models are doing hundreds of tiny jobs. They don't need to do.
And everyone eats your tokens. Now, Jeff AI... is a tiny ai that takes those jobs answers in under a half second and tells you how sure it is now i actually raced it against for example claude and jeep six and four real jobs and in one race the tiny model got the most answers right you'll see all four races the three easy steps set it up and two bonus moves for your everyday chat so stick with me because one of those bonus moves made my ai agent forget its own rules and the fix was one number let's start simple so what is a token?
A token is how Claude and GP6 Astra measure reading. Your plan only lets the AI read so many tokens. The more it reads, the slower it answers.
And when you hit the limit, your agent stops. So if your AI reads less, it runs faster and it runs longer. Today is about making it read less.
Now, most people don't know this part, but every time you send a message, the AI reads a whole chat again from the top. Your first message, it reads. one page by message 50 it reads a whole book just to answer one line every file opened is still in there so in every test it's going to read that over and over and over again now I actually checked my own chats with my AI agents and these are like real messages are typed so for example I actually typed can you add this one too and it read 124 ,124 tokens I also asked it, you know, do you have the guide on this as well?
And that took up 186 ,000 tokens. And here's my favorite. How's it going?
It costs 222 ,000 tokens in one answer because the whole chat came along for the ride. Now, here's the real waste. Claw and Gypsies are like...
professors they're great at thinking planning writing fixing tricky things but your agents also hand them hundreds of tiny choices for example is this email urgent which shoes should these two pages link and that's like paying a professor to sort your mail and every one of these tiny choices uses up more tokens now what is jeff well basically most ai Models write.
Jeff doesn't write a single word. You can just give it three things. What's going on?
A question, a list of answers. It's allowed to pick from. It picks one and it tells you how sure it is, like 90 % sure.
So Jeff actually came out this week on September the 15th from a company called TypeSafe AI. And because it never writes, it's fast. Now, why does this matter so much?
Well, a model that writes can make things up, ask it for an outfit, and it might say wear a navy cardigan. But there's no navy cardigan in my closet. So now the app is stuck.
But Jeff, well, Jeff can only pick from the list you give it. So for example, red blazer or leather jacket or even sunglasses, for example, or keep what he has, right? So every answer is one your app can use right away.
And it's literally way, way faster than using a normal AI agent. So how do you reduce your tokens? Well, when you hand a tiny choice job to Jev, Claude and Jube6 Astra read nothing for that job, zero tokens.
Jev still has to read it because somebody has to, but Jev did the same work 99 % cheaper than Jube6 and Astra and ClaudeSonic5. You know, I've tested this on my real jobs. And let's have a look.
So example number one. is my voice mirror, right? So I say where I'm going and it picks my outfit.
I type, I'm giving a keynote tomorrow. That one sentence turns into seven tiny choices, which top, which jacket, which trousers, which shoes, which extras, which room. And this is even about clothes.
Now, Jeff answers all seven together in under a second. Red blazer, white shirt. navy trousers and a stage behind me.
Then I gave those same outfit choices to the big models. 40 requests each. Jev answered in 413 milliseconds.
Chord Haiku took 1486. G6 Astra took 3269. Chord Sonic 5 took 4545.
Now, which is more slow? Of course, it's the models that are thinking. And for quite a lot of these...
steps. You just need something that can decide. It doesn't need to write anything.
It just needs to make a quick decision. And the tiny model can keep up with professors because it's just picking from the choices you've already given it. Which is how the system works.
It's got all these presets and then if we click on something it can basically operate straight away. It can think. It's the same for example with this system right here.
This system allows us to control our browser. Now this is way way faster than using a normal voice agent because the voice agent is going to think this system right here basically just operates in real time.
So for example, we say start mic over here, scroll down the page, open up Google, right? It can easily do it. And we can just stop the mic right there.
Why is it doing that? Because you can see over here that it's got these choices for the different things that we're doing. By the way, this is a free GitHub from...
Moritz Krem, shout out to him for the voice browser system. Really, really cool idea. But this is a whole system.
It can do the same, for example, for emails. It just picks a choice of whether to reply, research, wait, or flag. And you can see here how quickly it can sort through emails as it's running through everything.
So it's just way faster when you're using this. By the way, if you want more training on this sort of stuff, feel free to check out the AI Profit Bottom. Link in the comments description or go to the AI Profit Bottom .com.
A great community where you can post questions, get help and support whenever you need to. In the classroom, you can get access to all of my best trainings on this sort of stuff. In the calendar, you can jump a weekly coaching course, ask questions, get help and support in real time.
And this is all available inside the AI Profit Boarding. Link in the comments description or go to the AIprofitboarding .com. Now, the way that I would start implementing this just works in three simple steps, right?
So step number one is you spot the tiny choices. You would look at what your AI agent does all day and find the parts that really just like a quiz. So if we have a look at, for example, that mirror system, these are the options which answer the question.
And so Jeff can quickly decide through the allowed answers and pick the right ones. For example, with my email system. It can answer, okay, is this email urgent or not?
My website is like, should these two pages be linked to or not? And if the answer could come from a short list, it's a tiny choice and the professor doesn't need to do it, aka the big frontier models don't need to do that. Now, you can actually get your AI agent to figure out this stuff for you.
So for example, you can give your AI agents like Claude access to the API for Jeff, which you can get from OpenRouter. And then you can get that API, go into Cloud or go into the GPT -6 and say, hey, based on what I'm working right now with, what could we use Jeff for? How can we optimize decision making inside any apps or tools or websites that we've built so that we can save time?
So, for example, you know, you could build a game that just generates itself as it goes based on the decisions you give it. And then the decision making can go to Jeff. It can pick it under a second.
And then your AI agent can keep doing the big work, right? With Claude, Astra, whatever you prefer. So planning, writing, fixing things, you know, he can do that.
When he reaches a small choice though, he can use Jeff. And the answer comes straight back and your agent carries on. Now, I like to build with Claude Code.
That's the one I like. But you can do this with any agent. You can tell it use Jeff for this choice and give it your questions.
And then it's got this confidence score as well. So you can set limits. You can say, right, above 60%, you carry on.
Below 60 % on the confidence score. Okay, you get back to me, you tell me, you flag it. So that's basically it.
That's the whole system. So you can see from the numbers that I'd say have put out that the cost normally with an LLM is like $0 .2 to $10 per input. For JEV, it's $0 .042.
Output is free because there is no real output with JEV. Whereas normally output tokens... with an LLM is five times more than the input cost.
But at the same time, JEV is more for optimizing decisions, which is where you're going to save the most tokens with JEV, right? You wouldn't use this for writing stuff because it can't. And additionally, it's way, way faster.
So not only do you save tokens, but you can also run decisions way faster through this model. Now, it's still in the early stages, but it's pretty exciting. And it's probably one of the biggest releases this year.
when it comes to AI models. And if you want to get more training on this sort of stuff, feel free to check out the AI Profit Boardroom. We have an amazing community and lots of training on Jev AI inside the calendar.
You can drop a week of coaching calls, ask questions. In the map, you can meet people in your local area, building out with AI agents like Jev. And also, I answer your questions personally right there too.
Plus, you can direct message me if you need anything. So feel free to get that. Link in the comments description or just go to the AIprofitboardroom .com.
Thanks for watching.
The Hook
The bait, then the rug-pull.
A model that just launched this week and can't write a single word is being credited with dropping one Claude Code session from nearly a million tokens to 86,000 in about a second. This video is Julian Goldie's case for why: four of his own videos on Jev AI, spliced into one, walking through a live outfit-picking mirror app, an open-source voice-controlled browser, ten small-business automations, and the token math behind why none of it needs a big model to make the decision.
Frameworks
Named ideas worth stealing.
02:00concept
System One vs. System Two decisions
TypeSafe AI frames Jev as the fast, reflexive layer of decision-making (seeing a red light and stopping) versus the slow, deliberate 'writing' layer every current AI agent uses for every decision, trivial or not.
Steal forAuditing any AI agent workflow for decisions that don't need a full model call
04:35list
Three question types: Choice, Score, Null
Choice - pick one from a list
Score - rate against levels you define
Null - yes/no as a probability 0-1
Jev's entire interface is these three question shapes, and batching several of them into one request costs barely more than asking one.
Steal forStructuring any classification, sorting, or routing task as a Jev-compatible decision
1:01:19list
The three-step build recipe
Step 1: spot the small choices your agent already makes
Step 2: write the question and the allowed answers in plain English, with one line per answer describing when it fits
Step 3: set a confidence line above which the app acts and below which it asks you
The presenter's repeated three-step pattern for adding Jev to an existing agent or app without touching code beyond describing the decision to a coding agent.
Steal forAny existing AI agent that currently sends every small decision to a big model
CTA Breakdown
How they asked for the click.
VERBAL ASK
53:48product
“Link in the comments description or go to theairprofitboardroom.com”
Repeated near-verbatim roughly five times across the video's four spliced segments, pitching the same paid AI Profit Boardroom community (reported member count climbs from ~3,000 to ~3,500 across the repeats, a sign these were recorded on different days).
Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.
Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
A tiny AI that never writes, only picks from a list, cuts frontier-model token spend by roughly 99% on the small decisions your agent doesn't need a professor for.
Jev doesn't chat back, it answers a typed question in under half a second, and Kevin Badi walks through what that buys you when you put it in front of Claude or GPT.
A lightweight alternative to built-in computer-use tools: one markdown skill and a handful of Python scripts that let a coding agent click, type, and screenshot its way through any desktop task.
A creator walks through the plugins, projects, and routines behind ChatGPT's agentic Work mode, then demonstrates it editing a video, drafting a sponsor script, and testing a video game all at the same time.
Billy Howell shares his screen and walks through the Grok Bot agents running his Arlington Bagel newsletter, from a chief-of-staff bot that spawns new hires to a $200-limit card that keeps them from overspending.
01:02
02:49
03:38
05:15
06:52
07:40
08:28
10:05
11:42
13:19
14:56
15:45
17:22
18:10
19:00
20:15
22:01
23:23
23:50
24:42
25:20
26:15
27:10
27:30
29:16
31:06
31:54
39:59
42:25
44:50
47:15
49:33
51:18
59:22
62:36
09:39
Video of the Day14:45
07:16
13:01
18:16
15:04