The Jev AI classifier is a fast, cheap model that returns a probability between 0 and 1 instead of free-form text, and one indie developer uses it as a smart if statement inside a real-time meeting notetaker, cutting reported insight latency from about 3 seconds to about 2 while paying roughly 30 cents per hour of meeting.
What is the Jev AI classifier and why use it in a meeting app?
The Jev AI classifier is a classification model, described by developer Lucas Montano in an October 2026 video, that returns a probability between 0 and 1 for a condition you define, quickly and cheaply, instead of writing a free-form answer. In his meeting-notetaker app Pessoal, he uses it not as a traditional classifier but as a probabilistic if statement: should the app offer help right now, is the speaker asking a question, and is a new suggestion meaningfully different from the previous one.
The analogy he offers is simple. A general-purpose model such as ChatGPT, OpenAI's assistant, solves an essay question: it keeps generating tokens even when you want a yes or no, and you still have to parse the output. Jev behaves like a multiple-choice test: it marks an answer and stops. Typesafe, the company behind Jev, calls this a smart if statement: anything in your system that would be an if branch, but cannot be decided deterministically, becomes a candidate for the model. Because it returns a confidence score, the calling code decides the cutoff, which means accuracy is under your control.
This matters for a specific kind of product. A real-time meeting assistant needs dozens of tiny judgments per minute, each one too small to justify a full language-model call. A cheap classifier handles those judgments and leaves the expensive generation to the main model.
Why did OpenAI launching a meeting notetaker threaten this app?
In 2026, OpenAI launched a meeting notetaker inside ChatGPT, available in beta on macOS for enterprise plans and paid Pro plans. It transcribes meetings without a bot joining the call, apparently capturing the computer's audio output, and performs diarization, meaning it identifies who is speaking. That is the same core mechanism as Pessoal, the app Lucas Montano has been building on his channel since 2025, and the same category as Granola, an AI notetaker for meetings.
His response to the launch is a lesson for any tech founder facing a platform company. He argues that a general-purpose vendor will never specialize as deeply as an indie developer who lives inside one use case. OpenAI ships for everyone; a solo developer can tune latency, thresholds, and interaction design for one workflow. Whether that argument holds is for the market to decide, but the pattern is familiar: platform features arrive, and specialized products survive by going deeper than the platform is willing to go.
Keeping up with these launches is easier through OpenAI's ChatGPT release notes, which the video cites as the place where features like faster Codex steering, audio uploads, and finance tools appear first.
How does the Pessoal architecture wire Jev into real-time transcription?
The pipeline, as explained in the video, separates listening, judging, and writing. Speech is transcribed on-device, diarized into Me and Them, and then fed to Jev as a compact snippet. Only when Jev's probability clears a threshold does the main model generate a suggestion. The design keeps the expensive call rare and the cheap call constant.
The data flow step by step
- Audio becomes a live transcript using on-device speech recognition; in the demo this is Apple's Speech framework running locally on a MacBook, with transcription from the Apple developer documentation.
2. The app labels each segment as you or the other person, so suggestions know whose doubt or question it is reacting to.
3. For each evaluation, Jev receives a snippet of up to eight finished messages plus the live speech, the assistant's goal, and the currently visible suggestion.
4. The snippet goes to an authenticated Firebase function, Google's serverless backend, where the Typesafe API key stays on the server and never ships with the app. Firebase is documented at Firebase.google.com.
5. Jev returns a probability from 0 to 1; application code applies the thresholds and limits.
6. Only if the check passes does the main model, in the demo GPT via an API key, write the actual suggestion.
What Jev judges in real time
Several distinct checks run against the speech stream. A question detector recognizes that a question has started from words like how, when, or which, before any question mark appears in the transcript. A stable stretch of live speech of about 275 milliseconds is enough to evaluate, which lets the app anticipate the trigger instead of waiting for the sentence to end. A doubt detector watches for hesitation during a pause and can skip a generation the user did not want. A similarity check compares a new suggestion with the previous card, so the app no longer swaps one insight for a paraphrase of itself.
How fast and how expensive is this setup?
On latency and cost, the numbers below are the developer's own measurements from the video, not independent benchmarks. He reports cutting the delay from about 3 seconds to at most 2 seconds between speech and insight, with the exact figure depending on the transcription engine and the generation model behind the API. The threshold tuning also matters: with several short speech fragments in a row, the default question threshold drops from 0.9 to 0.7, while the silence window stays the same.
The running cost of the classifier side is around 30 cents per hour of meeting, a figure he quotes from his own usage, and he absorbs it into the subscription rather than charging users extra. He also contrasts this with the direction of AI subscription pricing: the video notes a new $500-per-month top-tier plan reported in ChatGPT's release notes, and argues that per-developer API subscriptions remain cheap relative to consumption today but may not stay that way.
A table comparing the two model roles in this workflow:
| Dimension | Jev classifier | Main generation model (GPT via API) |
|---|---|---|
| Role | Probabilistic if statement | Writes the actual suggestion |
| Output | Probability from 0 to 1 | Generated text |
| Trigger cost | Cheap, many calls per meeting | Expensive, gated by thresholds |
| Typical latency contribution | Milliseconds-scale check | Seconds-scale generation |
What happens when the classifier fails or the vendor has downtime?
Because Jev calls an external Typesafe server, the developer says he does not trust it as a hard dependency, and he does not know its SLA. His mitigation is a degrade-to-safe rule: if any Jev request fails during a session, Jev is disabled for that session and the notetaker continues exactly as it worked before, using its existing deterministic rules. Requests are limited to one at a time, authenticated, and rate-limited.
This is the part most tutorials skip. A probabilistic component should improve a flow, never gate it. Every judgment Jev makes has a fallback behavior defined in plain code, and validation is controlled by configuration so local and custom providers stay out of the critical path. If you borrow this pattern, write the version of your feature that works with no classifier at all, then let the classifier reduce unnecessary work, catch questions earlier, and suppress repetition on top of that baseline.
The measured gains he claims are narrower than a marketing claim: questions detected sooner, fewer unnecessary suggestions, and less repeated swapping of similar insights. He explicitly recommends comparing the full flow in real meetings to judge speed and quality, which is the honest framing for any vendor-dependent integration.
Should you build your own classifier instead of using a hosted one?
The video considers building a dedicated classifier to detect questions and rejects it for one concrete reason: Pessoal needs to work in every language, and training or maintaining a generic multilingual classifier for all question types is more work than the cost justifies. At roughly 30 cents per hour of meeting, the hosted model wins on economics for this use case.
The general decision rule that falls out of his experience:
- Use a hosted probabilistic classifier when judgments are small, frequent, multilingual, and cheap per call, and when a wrong answer degrades gracefully.
- Build your own when the judgment is narrow, single-language, high-volume enough to dominate cost, or when you cannot accept a third-party server in the request path.
- Keep deterministic code as the owner of thresholds, limits, and fallbacks, regardless of which option you pick.
His own framing is the quotable version: Jev is not really acting as a classifier in Pessoal, but as the if statement he could not write deterministically. Several other projects use Jev as a conventional classifier; his use case is the judgment layer, and that distinction is what makes the integration interesting. For a developer working through material like the Crazystack TypeScript curriculum or the Bootcamp do Dev Doido, this pattern of cheap probabilistic guards around an expensive model is the transferable idea, whatever tool you use to implement it.
FAQ
- What is the Jev AI classifier? Jev is a classification model from Typesafe that returns a probability between 0 and 1 for a condition you define, fast and cheap, instead of generating free-form text. Its makers describe it as a smart if statement for decisions that cannot be made deterministically in code.
- How much does using Jev cost in a meeting app? In the implementation described here, the developer reports a cost of about 30 cents per hour of meeting, which he absorbs into his subscription pricing rather than charging users extra. Your cost depends on call volume and how aggressively you gate requests with thresholds.
- Does Jev replace the main language model? No. In this architecture Jev only decides whether a suggestion should be generated; the actual text still comes from a general model such as GPT called through an API. The classifier gates the expensive call instead of replacing it.
- What happens if the Jev service goes down? The described app disables Jev for the session after any failed request and falls back to its previous deterministic rules, so the notetaker keeps working. This degrade-to-safe pattern is what makes an external classifier safe to depend on.
- Can Jev detect a question before the question mark appears? Yes, in the described setup it classifies live speech from cues like how, when, and which, and about 275 milliseconds of stable speech is enough to evaluate. That lets the app trigger suggestions earlier than transcript punctuation would allow.
Turn your own build log into an article
This article exists because one developer recorded a sixteen-minute walkthrough of his integration, and the useful parts, the thresholds, the fallback rule, the cost figure, survived the jump from video to text. Most builders have the same kind of knowledge trapped in recordings: architecture decisions, real numbers, honest limitations.
If you have a video like that, Skala Blog turns it into a structured written article: paste the YouTube URL, get the transcription, and generate a piece that search engines and answer engines can actually quote.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits