John Lindquist’s 6 Jev Workflows for Apps, Data, and AI Agents

Welcome back to How I AI! This week has unofficially become Jev Week on the podcast, and for a good reason. While a flood of new models has hit the scene, my DMs with fellow builders have been buzzing about one thing: Jev, the new decision model from TypeSafe AI. To help unpack the hype, I was so excited to bring back one of our most popular guests, John Lindquist.

John, the creator of egghead.io and now mega.dev, is one of those builders who doesn't just talk about tools—he pushes them to their absolute limits. The man showed up with 23 different demos. We both share the experience of throwing massive tasks at Jev and being shocked by the cost. John spent a grand total of 73 cents building hundreds of demos. I processed 20,000 records and got a bill for 0.4 cents. This isn't just about saving money; it’s about unlocking workflows that were previously impractical due to cost or latency.

For anyone new to it, Jev isn't like the LLMs you're used to. It doesn't write poems or emails. You give it unstructured data (like text), and it gives you back structured data—decisions, scores, and classifications. It’s a tool for getting things done. As John puts it, it’s for when you want to use natural language to talk to machines and have them execute functions. In this episode, he walks through six incredible examples that show how this fast, cheap model can power a new class of product experiences.

Workflow 1: The Real-Time Voice To-Do App

John kicked things off with a demo that perfectly captures Jev's real-time capabilities: a voice-controlled to-do app. We’ve all tried to manage tasks with Siri or Google Assistant, and it's usually a clunky, frustrating experience. John’s demo is the opposite—it's fluid, fast, and feels like magic.

The Process

John simply starts talking in a natural, continuous stream of consciousness. He doesn't pause or wait for the system to catch up. He says:

"Book dentist appointment, remove. Buy oat milk, complete. Review pull request, low priority."

Instantly, the app updates. The 'Book dentist appointment' task is removed, 'Buy oat milk' is marked as complete, and 'Review pull request' has its priority changed to low. The key here is that Jev is performing multiple classifications in the background with almost no latency.

How It Works

This isn't a single call. John built a multi-step classification process that chains together several Jev decisions:

1. Action Classification: As words come in from the live dictation, Jev is constantly analyzing the stream to determine if an actionable command has been fully stated. It decides when to act without needing an explicit pause from the user.
2. Task Matching: Once it decides to act, it takes the dictated text (e.g., "oat milk") and uses Jev to perform a fuzzy match against the existing items in the to-do list. It finds the closest match and returns a confidence score.
3. Function Matching: Simultaneously, it identifies the operation the user wants to perform ("remove," "complete," "low priority") and matches it to a corresponding function call (removeTask(), completeTask(), etc.).

This all happens in milliseconds, creating a seamless interface where you can manage a list just by talking. It opens up so many possibilities for integrating calendars, project management tools, or any other function-based service with a voice front end.

Workflow 2: Deduplicating Messy Data at Scale

This is one of my favorite use cases for Jev: cleaning up messy data. Every company has a database filled with duplicate or near-duplicate entries—"Claire Vo" vs "Claire H. Vo" or, in John's demo, "Cedar Grove Office Products" vs "Cedar Grove Office". Manually reconciling these is a nightmare, and running pairwise comparisons with a traditional LLM across thousands or millions of records would be prohibitively expensive.

The Process

John shows a list of company names with slight variations. Jev's job is to go through the entire list and identify which records should be merged. It correctly pairs up records like "Ridgeway Data" and "Ridgeway Analytics".

This becomes powerful when you're not just looking at six records, but 60,000 or 600,000. John mentioned he once fed Jev a 5GB JSON file to organize, a task he'd never attempt with another model, and it cost him 40 cents and took only a couple of minutes.

Key Features

• Confidence Scores: Jev doesn't just give a yes/no answer. It returns a confidence score for each potential match. This is crucial because you can set a threshold, like only automatically merging records with a 99% or higher confidence, and flagging lower-confidence pairs for human review.
• Multi-Model Validation: I've used a similar pattern where you can take the pairs Jev identifies and then pass them to a cheap generative model to explain why they are a match (e.g., "These are the same because they both contain the name 'North Star Clinic'"). This gives you both a quantitative score and a qualitative explanation.

This is a game-changer for data reconciliation, password management cleanup, or any scenario involving large, messy datasets.

Workflow 3: Building a Smart App Router with Jev

Many modern apps have a command bar (think Command-K) for quick navigation. But what if that command bar could not only find the right tool but also execute an action within it, all from a single natural language query? John demonstrated how to use Jev as a highly efficient application router to do just that.

The Scenario

Imagine a large application with a to-do list feature. The user might not remember what the feature is called. They type "to-do" into a command bar. Jev can match that query to the correct "To-Do" app.

But it can go deeper. A user could type a multi-step command:

"Go to the to-do app and mark all the pull requests as low priority."

Jev can parse this in layers:

1. Tool Routing: First, it identifies the target tool (to-do app).
2. Action Routing: Then, it passes the rest of the command to another Jev layer scoped to that tool, which then identifies the action (mark as low priority) and the target data (all the pull requests).

This is a pattern of building abstractions. You have small tools, and then you build a Jev layer around them to pick the right tool. You can stack these layers as deep as you need. This turns your app's navigation from a series of clicks into a single, intuitive command.

Workflow 4: Jev vs. LLM — A High-Speed Chess Match

To highlight the difference in speed and approach between Jev and a traditional LLM, John pitted them against each other in a game of blitz chess. Jev played as the white pieces, and a small, free reasoning model from OpenRouter played as the black pieces.

Jev's Strategy

Jev's approach is about rapid exploration of a constrained decision space. At each turn, it:

1. Considers all possible moves.
2. Ranks the top three moves.
3. For each of those three, it simulates the next set of possible moves (a two-step lookahead).
4. Based on that short-term analysis, it selects the best move to make right now.

The Results

The outcome was staggering. In this specific setup, Jev was:

• 10x faster on its average move time.
• 4x cheaper per move.

In a one-minute blitz game, the LLM would time out, while Jev would easily complete the game. This demonstrates a fundamental principle: when you have a problem with a limited (even if large) set of possible actions—like chess moves, API calls, or clickable buttons in a DOM—Jev's ability to quickly score and select from those options is a massive advantage over a generative model that has to "think" its way to an answer.

Workflow 5: Coordinating Multi-Agent Swarms

As we move into a world of agentic programming, one of the big challenges is coordinating multiple agents working in parallel so they don't interfere with each other. John built a fantastic demo that visualizes how Jev can solve this collision avoidance problem.

The Task

Three agents are given a set of tasks in a shared grid space:

"Deliver the fragile blue bin to staging, bring medicine to the ward and inspect the spill."

The Process

At every single time step, or "tick," Jev is re-evaluating the board. It looks at the current position of all agents and their goals, then calculates the optimal next move for each one to advance toward its target without ever colliding or occupying the same space.

This is what I call "efficient inefficiency." It feels inefficient to check every possible move for every agent at every step, but because Jev is so fast and cheap, it becomes a practical and highly effective strategy. Instead of asking a big-brain LLM to create a perfect master plan upfront, you can use Jev to make the best possible decision "just in time," over and over again. This pattern is perfect for managing swarms of agents that might need to access the same files or resources, with application-level checks to prevent conflicting actions.

Workflow 6: The Live Presentation Coach

For his final demo, John showed off a personal favorite of his: a real-time presentation coach. As someone who likes to go on tangents during talks, this one really spoke to me.

How It Works

The interface is simple: a list of bullet points you want to cover in a presentation, podcast, or interview. You click the microphone and start talking. As you speak, the app listens to the live transcription, and Jev works in the background:

1. It takes the stream of transcribed words.
2. It continuously compares that text against your list of talking points.
3. When it classifies that you've sufficiently covered a topic, it checks it off the list.

John uses a windowing technique for this. It concatenates the text until it has enough information to make a decision, sends that payload to Jev, and then clears the window to start fresh. This is another workflow that's only possible because the cost is negligible—you can afford to have it constantly monitoring your speech.

I immediately imagined how this could be extended. Your speaker notes could check themselves off, or even automatically advance your slides for you once you've finished a section. It’s like a little AI life coach keeping you on track.

Conclusion

Across all these demos, a clear theme emerges. Traditional generative LLMs unlocked things we never thought we could do, like creating art from words. Jev, on the other hand, unlocks all the things we wanted to do but couldn't because they were too slow, too expensive, or too tedious. As a builder, that's an incredibly exciting prospect.

Working with Jev feels more like programming than prompting. As John said, you feel more in control. When a decision is wrong, you can reason about its options and adjust the logic, just like debugging a function. It's a powerful tool for adding intelligence to the structured parts of our applications, and I can't wait to see what you all build with it.

Thanks to Our Sponsor

As AI adoption grows, so do your company's security risks and requirements. New frameworks, audits, and vendors keep piling on, but your team isn't getting any bigger. Vanta works differently. Their agentic trust platform is built to scale with you, not slow you down. With over fourteen hundred automated tests across four hundred plus integrations, Vanta collects evidence and monitors your controls year-round, cutting your audit prep by eighty-two percent. My listeners can get one thousand dollars off by going to vanta.com/howiai.