Jev vs LLMs: Dividing Structured Decisions from Text Generation
Jev is a specialized model for structured decisions like classification and scoring, complementing LLMs by handling typed questions in parallel while LLMs generate text responses, with early projects demonstrating this division of labor across browser automation, code compaction, and drone control.
Many LLM calls only need classification, selection, or scoring. Jev is TypeSafe AI's model for structured decisions, targeting exactly those calls. You provide context and typed questions; it returns answers your application can act on.
A useful division of labor: Jev classifies the customer request, the LLM writes the reply, and application code checks permissions before executing actions. Several early projects are already exploring this split.
Starting with Hello World
This minimal example uses Vercel's AI SDK:
import { experimental_evaluate as evaluate } from 'ai';const { answers } = await evaluate({model: 'typesafe-ai/jev',state: 'Hello, world!',questions: {greeting: { type: 'boolean', instructions: 'Is this a greeting?' },},});console.log(answers.greeting.probability); // Example output: 0.97The input is "Hello, world!". The output estimates the probability it is a greeting. Vercel calls this type boolean; TypeSafe's native API calls it noul. The value may vary; your code chooses the threshold and response.
Jev also supports selection among defined options, giving a probability for each, and scoring against ordered descriptions. The score is a position on your defined scale, not a confidence percentage.
One Message, Multiple Decisions
Take "Charged twice. I'm furious. Please refund the duplicate." You can ask whether a refund was requested, which department should handle it, and how frustrated the customer sounds.
Traditional autoregressive LLMs generate tokens sequentially, even when constrained to JSON. Jev evaluates independent typed questions against the same state in parallel and returns typed answers without generating a text response. Questions that depend on previous answers require another request.
Example outputs and speed ratio. Severity shown scaled 0 to 10. Prices are TypeSafe's advertised launch rates.
Integration options include Vercel's evaluate API and Cloudflare's typesafe/jev model. Probability results still need application logic: classifying a refund request does not equal confirming eligibility.
Eight Early Projects
These projects include prototypes, experiments, and one live application:
Jev Ultrafast (https://github.com/browser-use/jev-ultrafast): Jev selects browser actions and targets; when the agent needs to type text, another small LLM supplies the text.
Fast Jev Compaction (https://github.com/tamaratran/fast-jev-compaction): A Claude Code plugin and library scores tool calls and their results to decide whether to keep, drop, or truncate them, with a risk of dropping useful context.
pg-jev (https://github.com/realZachi/pg-jev): A PostgreSQL extension uses natural-language judgments to filter rows or assess relevance while SQL handles the query.
Sponsor Skip (https://github.com/trungdq88/youtube-sponsor-detection): Jev identifies sponsor segments in transcripts; extension code maps them to timestamps for skipping during YouTube playback.
Nader Dabit's Launcher (https://github.com/dabit3/jev-experiments/tree/main/jev-launcher): Jev reranks local candidates in a native macOS launcher; the user presses Enter to execute the selection.
TypeSafe Mario (https://github.com/fhshaik/typesafe-mario): Jev selects actions based on structured simulator state and telemetry, not screenshots.
1kpapers (https://www.1kpapers.com/): Its experimental pipeline uses generative models to summarize papers and Jev to assign topics; new tags are still under evaluation.
Jev Drone (https://github.com/RomanSlack/jev-drone): A simulated drone requests maneuver decisions from Jev while code builds the scene description and handles high-speed flight control.
Where I Would Start
Pick an existing classification or routing call whose possible answers can be clearly enumerated. Compare Jev against the current implementation on the same batch of labeled inputs, including ambiguous cases. Measure accuracy, end-to-end latency, and full cost including retries and fallbacks.
Full article (https://generativeprogrammer.com/p/jev-and-llms-who-does-what) includes more details per project, API docs, integration links, and resources to try Jev.
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
