The author argues that Jev and similar classifiers are interesting not for their novelty but for highlighting how LLMs are often used for simple decision-making tasks, suggesting a more efficient architecture with smaller models for routing and evaluation.
Ok maybe im missing something here but after reading what feels like 20 Jev threads in 2 days lol Half the discussion seems to be: "bro this is literally just a classifier" and then the other half is arguing that no, its different because it has general world knowledge / zero shot / doesnt need task specific training etc etc. Honestly I was part of that crowd so decided to take it for a spin myself. Here are my thoughts. I feel both sides are kinda arguing about the wrong thing? The more interesting realization for me is how ridiculously often we're using a full generative LLM for something that isn't actually a generation problem. Like think about a normal agent pipeline. Should I call tool A or tool B? Is this request billing/support/refund? Did the previous step actually succeed? Should I send this to the 4B model or the 70B one. Is this answer good enough or should I retry? Does this PR look risky enough that a human needs to check it? And what do we normally do? Call an LLM, make it "reason" about it, then ask it to spit out some JSON saying true or "tool_31414225" When you write it like that it actually sounds kinda stupid. We're basically hiring a novelist every time we need someone to tick a checkbox. Thats the bit about Jev (or even Laya / whatever other models inevitably show up next) that I find interesting. Not "omg classifiers have been invented in 2026". More like... maybe a lot of agent architectures are backwards right now? Maybe the big expensive autoregressive model shouldn't be sitting in the middle making literally every decision. Could be tons of tiny decision models doing routing, gating, validation, state transitions etc, and then you wake up the big LLM only when you actually need it to generate or properly reason about something So instead of basically: user -> LLM -> LLM -> LLM -> tool -> LLM -> LLM you end up with something more like: user -> cheap router -> tool/model -> cheap evaluator -> big LLM only if needed And if those "decision" models can actually be tiny + local + fast... idk, that seems pretty damn useful. Ironically the fact that people are already building open versions and doing similar stuff with normal LLM logits makes me less convinced Jev itself has some crazy moat, but more convinced the pattern might actually matter. Curious about people here who are actually building agents though? How much of your current LLM usage is basically just an expensive yes/no or choose-one-of-N decision? Because I'm looking at some systems I've worked on and... probably more than I'd like to admit lol
The article shares production insights on using Jev, a semantic decision engine, to enhance AI agent systems by handling routine decisions efficiently alongside LLMs, without replacing generative models.
The author discusses the use of classical ML versus LLMs for business classification and regression problems, evaluates the Jev model as a potential tool, and compares it with existing techniques like Structured Outputs and DSPy, highlighting accessibility and effectiveness concerns.
The article introduces Jev, an AI model designed to make decisions rather than generate answers, using structured outputs for applications like fraud detection and risk assessment, positioning it as a routing layer for larger reasoning models.
The article critiques Jev, arguing that it is not a new AI paradigm but a specialized classifier with marketing targeting those who equate AI with LLMs.
Jev is a novel AI model that outputs scores, choices, or binary decisions, praised for its speed, affordability, and accuracy when queried creatively, unlike traditional frontier models.