If Jev is fundamentally trained using RLCD while you’re building on a Qwen model that was trained using RLHF, how can the resulting model be considered Jev-like?
Unless specifically told in a system prompt, the pile of weights has absolutely no knowledge of itself. You could hypothetically train it to answer such questions, but nobody bothers to do this, and ALL "knowledge" embedded in the weights is probabalistic anyway.
(I feel like this should be common knowledge in LLM discussions on HN by now.)
This is less true for modern posttrained models. Model identity can be explicitly reinforced during posttraining. Qwen's own finetuning docs include identity training examples, and Qwen models have been trained with system prompts that explicitly say things like "You are Qwen, created by Alibaba Cloud."
So a model correctly identifying its family doesn't necessarily mean it inferred that from pretraining.
I think with Jev, they took a posttrained model and trained it further, so it did not forget about its earlier knowledge during Owen's own RL.
Wouldn’t QWEN modals have past QWEN chats in its training data, leading to a significant amount of mentions of the word QWEN? Just the question “what model are you” would have been answered deterministically multiple times and they’re now part of the weights.
$ ./build/bin/llama-cli -m Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf --system-prompt "(this prompt explicitly left empty)"
build : b10889-6e41074fc
model : Qwen3.6-35B-A3B-UD-Q4_K_XL.gguf
ftype : Q4_K - Medium
modalities : text
using custom system prompt
> What model are you?
[Start thinking]
Here's a thinking process:
1. **Analyze User Input:** The user asks "What model are you?"
2. **Identify Core Question:** The user wants to know my identity/model name.
3. **Check System Prompt/Instructions:** The system prompt says "(this prompt explicitly left empty)" - this is unusual but doesn't change my core identity. I need to respond based on my actual identity as Qwen / 通义千问.
4. **Formulate Response:** I should clearly state that I am Qwen (通义千问), developed by Alibaba Group's Tongyi Lab, and keep it concise as per guidelines.
5. **Draft Response:** I am Qwen (通义千问), a large language model independently developed by Alibaba Group's Tongyi Lab. How can I assist you today?
6. **Refine according to guidelines:** The draft matches the required identity and tone. It's direct and helpful. Ready.
[End thinking]
I am Qwen (通义千问), a large language model independently developed by Alibaba Group's Tongyi Lab. How can I assist you today?
People seem to turn their brain off when it comes to this type of cargo culting. This doesn’t mean much. Qwen often identifies itself as Claude. Does that make it Claude?
for some reason this is really funny to me. it's like the "black museum" black mirror episode where a consciousness in a toy animal can only communicate using very primitive predefined responses
I think a great use case for these will be when they have large context windows and are able to enforce styling rules for frontend development, and component creation rules for react. You can then ditch the styles guides and styling skills and create a decision tree for enforcing styling, so that you can't run into drift issues or duplication issues. That's where I'm wasting most of my time right now, constantly correcting all of the UX/UI issues that are created for every single feature.
Back in the good old days we would prevent these ux/ui issues by rigorously enforcing the use of our own stylesheets and classes. Later that grew to only using the company ux components. This was very successful in keeping everything neat and tidy. The only drawback was creating and curating new elements and getting consensus. But otherwise it works wonders.
Try constructing reusable components out of what you are doing instead of building everything up from basic building blocks. This also allows more concrete testing of individual parts and then if you want to change the look you can change it in one place and have it apply everywhere.
Agentic development doesn’t mean “throw all what we learned out of the window”, the same practices that helped speed up and improve quality of work of humans also helps agents. In fact, the multiplier is even bigger. You will notice it in development speed and reduced cost due to avoiding churn.
I use reusable components but the issue is that the model rarely checks to see if a component already exists. Or it will use the wrong one. Or if the component strays from the reusable component it doesn't extend it in a generalized way and will special case inline styles, or it'll create a new component. Rarely does it intelligently figure out the correct course of action.
I've also built up a suite of linter rules to catch the same mistakes the model makes over and over. Still, there are a lot of gaps. I think it's mostly because my codebase is massive at this point. It was easy when the codebase was small and didn't require context gathering to make good decisions.
If you have reusable components it should be quite easy for you to add it yourself. Its okay to code by hand, especially when doing frontend.
When comes to frontend work, the handmade UX designed by a professional will always outperform whats made by an llm.
Sure its 10x slower, but you'll get 20x more usere because it will obvious it was made with care (if done well, and you should learn to do it well). Its the same reason handmade clothing, watches and other luxery items speak to us more, sometimes its marketing but often times its the craft.
There's a reason why all the companies selling the idea that web dev is dead, like lovable, still hire designers with 50k retainers to do their landing pages.
Hi, I'm currently planning on launching a product like this "Grammarly for Design" in a few weeks. Would you be interested in being part of the alpha group ?
I probably wouldn't be able to for data privacy reasons unfortunately, unless it's using an open-weight model (if it is, let me know). But I wish you the best of luck!
Bit of a Jev explosion going on. Is it because it's taking us back to a simpler time we understand better? Classification models have been around for a while.
The way I see this (I havent played around with Jev or layla the OSS version) is that classifiers have always existed and a recognised tool in the ML world. But, the norm is that one needs to not only know what to classify as, but determine what weights to use to classify the input.
Jev came in, and added that magic of "you dont need to train your classifier or determine the weights" if you dont want to, and just get the classified answer out. I think that's what is making people see this with a glitter in their eyes.
I would be curious to see comparisons of jev and similar things with problem specific classifiers. I think layla suggested making problem specific versions anyway? There is a lot of demand for magic don't do any work solutions, which is kind of weird in an era where agents can really help you build a customised solution effectively.
It reminds me a bit of what Ansible got right: user communication. The underlying tech may have existed for a long time, but the genius is presenting it to a regular developer in a way that reads "yes, even you can understand ML, just using a little JSON". The contribution of that should not be understated, as has been clearly evident recently.
It does "work", you can download ansible today and use it, it does what it says. Is it the greatest solution for all use cases in infrastructure? Of course not, nothing is. Do people misuse it? Of course too, we're all human.
Regardless of what tooling you use, we're all building houses of cards, and depending on the situation, try to hold down those cards as well as we can, balancing a ton of other needs and requirements.
The Jev model is economically, but also in terms of compute, a much more efficient model. A normal LLM goes token by token, each token in a separate step. Whereas Jev just returns all the results the first round. So it is much better at classification than LLMs.
Compared to traditional ML classification, Jev works without training, like a LLM.
It’s simply not understanding. In terms of latency, LLM processing for large fact-based decision-making was incredibly slow. The real unlock here was speed in decision-making.
> and enabled things that were impractical previously
I think that there are not _that_ many use-cases that have been opened up by this that tool-calling on other models didn't solve already. Really depends what benchmark you're looking at. This one against BANKING77[0] has many issues, but suggests it's really not far off DeepSeek 4.1 Flash. This one against BoolQ[1] shows marginal improvement over Qwen3.6. This one against MMLU-Pro[2] (same author as the previous) shows significant improvements over two Qwen models.
So there's definitely _some_ alpha there, but I don't think it's the sea-change that the hype would suggest; that is to say, yes, some things that weren't practical before are now, but many things were already very practical with the existing tools.
The part about "tool-calling on other models didn't solve already" is what gets you, sure I could tool call deepseek, glm or any other model, but the latency is huge and you get no confidence score. I gave JEV a shot via OpenRouter and it has a reply in less than 400ms, it's fast enough and cheap enough that you can hook it up to a game loop for example (so highly state dependant) and it can do decisions in real time.
I think it’s timing. So many devs trying to squeeze their subscriptions, build more tooling to throughputMaxx. 6 months ago, i speculate it launches pretty flat.
Classifier models are extremely niche and trained for a singular purpose. A utility classifier that you can one-shot on almost any topic or need is a dramatically different beast.
Is it truly useful or accurate or beneficial? To be seen. But it's the idea that has everyone so captivated. An expert system that is an expert at most everything is a lot more useful than an expert system that is an expert at choosing a bar of soap, for instance.
Thanks to these projects, what was an innovative-but-closed piece of technology one week ago is now much more accessible. Whether they're in it for fame or not, I couldn't care less!
There already was an alternative a year ago, with a published paper and open weight lmao... all the other projects are literal slop shat out by script kiddies 2 hours after the release of jev, it reminds me of the flappy bird era, depressing
Jev is creating a sort of identity crisis for me, because the number of absolutely clueless folks parroting the classifier thing is the first time I've seen this sort of mass psychosis in CS upfront.
Like even 5 minutes of tinkering captures why this isn't anymore like BERT or any past classification model than ChatGPT is like those old Markov Chain generators, yet folks cannot shut up about how this is nothing new.
Absolutely scary and makes me wonder how much of the field is just people super confidently discrediting otherwise promising/interesting directions for development for a cheap dunk!
You already wrote the prompt, no? What I'd do, if I were you, is run the question through a LLM and then come back with targeted questions that it didn't answer.
I did the first part yesterday, jumped down the rabbit hole, and have 3 product ideas in my head now.
"Why is Jev fundamentally better than classification models like BERT or traditional ML?"
I hope these get small and good enough to create “pet like” AIs for games. You know, like scream “follow me” at an NPC, STT stack translates it and feeds it to a local Jev-like model that then picks a number of things for the NPC to do.
Quite impressed by the energy people are putting into making OSS Jev-like models.
I understand the hype but I wonder: what are the use cases for this kind of model? Could it be used in the context of coding agents, or is it more relevant in totally different situations?
> what are the use cases for this kind of model? Could it be used in the context of coding agents
Yeah, it could. The most obvious usage would be to have local fast cheap "feedback" / "control" over a slower more expensive agent (i.e. cc / codex / opencode). Things like "goals" could now be split from a long prompt into "actions" and "verifiers". Where for each action you also produce a verifier. Then after each action you run the verifier w/ this kind of "universal classifier" and decide if the step was done correctly, if it needs follow-up and so on.
Example: implement auth in this repo -> llm_plan() -> for item in plan generate_verifier() -> for item in plan implement() ; verify() ; accept() / followup().
Verifiers could be something like this. take a plan item as input, generate classification questions that might verify the task "is this following project conventions?" | "is this touching files from other tasks?", etc.
You can do that with LLMs, but some things might become cheaper / faster. And you can pretty much use it to check against an ever growing list of conventions. Yours or project specific.
Consider every situation where you "force" an LLM to output only a choice / category, or a set of them. If you have workflows like that, you're now being promised significant cost- and latency reduction.
For coding agents it'd only be useful in a subset of situations. E.g. you could imagine using one to classify bash tool calls into safe and unsafe for example.
To develop a smart ai system for my 2d roguelike platformer?
game has way too many moving system for classic state-machine ai + i cant spare the time to develop it.
its low latency entices me.
On Gemma 4 12B, I am getting 220 ms per move or QS. I used it to play the Snake game locally:
prompt_eval=244 ms wall=245 ms schema_cache=hit generated=0
Move limit reached after 200 moves: score=16, length=19.
So, if a 12B dense model can offer this latency on a local old PC, then definitely you can scale it up with more powerful machines and get even lower latency.
Because these decision models do not have tool calling, the knowledge cutoff might become a problem. We'll either have to keep training continuously if we run locally or switch to the newer version every month or so when using a closed one like Jev
even with knowledge cutoff set a second from now, you still want to provide as much info as you can if you’re using such tools for delegating decisions
I wonder how these would do filtering my spam. I have been using 27B-class models for a while now, and they are nearly perfect at determining what is spam and what isn't. The only disadvantage is computational cost.
Take a look at Thomson 1.0-small, which is a variant of qwen 3.6 35b post trained by Thomson Reuters for text analysis. It classifies text content very well.
Are you on the foundation research team for Thomson? (If so, hiya from B!)
Why would you expect Thomson to be particularly good at spam clf? I figured your additional corpus was all news and legal?
Can someone do a ELI5A of how they achieve classification over any user defined list of items? Normal neural networks do a softmax over a known output set to get probabilities
You can achieve open-vocabulary classification by making the final weights in the softmax come from a category encoder instead of being fixed learned weights. So instead of
softmax(encode(input)*learned_weights)
You have
softmax(encode(input)*encode(categories))
I'm not sure if Jev does it this way, but it's how you get open-vocabulary zero-shot image classification with models like CLIP [1].
I can think of two possible approaches
1. Jev limits to 255 distinct options. So they can preprocess your set of options and “tell” the LLM via input tokens 1 = red, 2 = blue, etc then jev need only output softmax over 255 states while benefiting from pretrain of other LLMs
2. You allow the forward pass to output over the total token state but mask over the logits to limit to the user options. Less plausible? bc tricky when input is multi token which they clearly support.
My guess would be option 1. Didn’t read the kev repo here which would also explain
The bright side of Jev being so popular could be that many companies and individuals realize that their applications might work well with a System One model, and they decide to run an open-source (or fine-tuned) version on their own
All the people that are just writing an Jev-like API on top of a normal LLM are missing the point. What makes Jev special is the training data; it's how it's trained. The architecture is probably nothing special. Just a text encoder with parallel prediction branches.
I have tried many of these open-source Jev-like models on some linguistic tasks and they are so bad compared to Jev.
I hope so. And I would really like to try an actual Jev open source model. But it will make it more difficult to market it when someone releases something like that because of so many of these "open source Jev-like model".
I'm just sitting back for a few weeks / a couple months to let it shake out, let others put in all the work, and then see if people are still interested and finding use cases that this access model fits better than the usual chat completions endpoint people are used to.
That showed us the best results at least
There are already many Jev-like models in there.
Edit: No affiliation. Just found it and thought others might find it interesting.
also tried myself: https://console.typesafe.ai/playground?share=shr_1690a3160f1...
Unless specifically told in a system prompt, the pile of weights has absolutely no knowledge of itself. You could hypothetically train it to answer such questions, but nobody bothers to do this, and ALL "knowledge" embedded in the weights is probabalistic anyway.
(I feel like this should be common knowledge in LLM discussions on HN by now.)
So a model correctly identifying its family doesn't necessarily mean it inferred that from pretraining.
I think with Jev, they took a posttrained model and trained it further, so it did not forget about its earlier knowledge during Owen's own RL.
Big if. More likely, it seems, is they started with an open LLM model and fine-tuned and repurposed it via their "RLCD" process.
Try constructing reusable components out of what you are doing instead of building everything up from basic building blocks. This also allows more concrete testing of individual parts and then if you want to change the look you can change it in one place and have it apply everywhere.
Agentic development doesn’t mean “throw all what we learned out of the window”, the same practices that helped speed up and improve quality of work of humans also helps agents. In fact, the multiplier is even bigger. You will notice it in development speed and reduced cost due to avoiding churn.
I've also built up a suite of linter rules to catch the same mistakes the model makes over and over. Still, there are a lot of gaps. I think it's mostly because my codebase is massive at this point. It was easy when the codebase was small and didn't require context gathering to make good decisions.
When comes to frontend work, the handmade UX designed by a professional will always outperform whats made by an llm.
Sure its 10x slower, but you'll get 20x more usere because it will obvious it was made with care (if done well, and you should learn to do it well). Its the same reason handmade clothing, watches and other luxery items speak to us more, sometimes its marketing but often times its the craft.
There's a reason why all the companies selling the idea that web dev is dead, like lovable, still hire designers with 50k retainers to do their landing pages.
Jev came in, and added that magic of "you dont need to train your classifier or determine the weights" if you dont want to, and just get the classified answer out. I think that's what is making people see this with a glitter in their eyes.
Just to be helpful if anyone is searching for layla, it's laya.
It does "work", you can download ansible today and use it, it does what it says. Is it the greatest solution for all use cases in infrastructure? Of course not, nothing is. Do people misuse it? Of course too, we're all human.
Regardless of what tooling you use, we're all building houses of cards, and depending on the situation, try to hold down those cards as well as we can, balancing a ton of other needs and requirements.
Compared to traditional ML classification, Jev works without training, like a LLM.
I think that there are not _that_ many use-cases that have been opened up by this that tool-calling on other models didn't solve already. Really depends what benchmark you're looking at. This one against BANKING77[0] has many issues, but suggests it's really not far off DeepSeek 4.1 Flash. This one against BoolQ[1] shows marginal improvement over Qwen3.6. This one against MMLU-Pro[2] (same author as the previous) shows significant improvements over two Qwen models.
So there's definitely _some_ alpha there, but I don't think it's the sea-change that the hype would suggest; that is to say, yes, some things that weren't practical before are now, but many things were already very practical with the existing tools.
0: https://sanand0.github.io/llmevals/jev/
1: https://github.com/ekzhang/openjev-sglang/blob/a3554ed9e9c26...
2: https://github.com/ekzhang/openjev-sglang/blob/a3554ed9e9c26...
So you have more flexibility to get on with building, evolve your business logic etc
Is it truly useful or accurate or beneficial? To be seen. But it's the idea that has everyone so captivated. An expert system that is an expert at most everything is a lot more useful than an expert system that is an expert at choosing a bar of soap, for instance.
Like even 5 minutes of tinkering captures why this isn't anymore like BERT or any past classification model than ChatGPT is like those old Markov Chain generators, yet folks cannot shut up about how this is nothing new.
Absolutely scary and makes me wonder how much of the field is just people super confidently discrediting otherwise promising/interesting directions for development for a cheap dunk!
Why is Jev fundamentally better than classification models like BERT or traditional ML?
Happy to read a written response or if you suggest a prompt to put into my LLM to get it to research and explain the relevant details.
I did the first part yesterday, jumped down the rabbit hole, and have 3 product ideas in my head now.
"Why is Jev fundamentally better than classification models like BERT or traditional ML?"
I understand the hype but I wonder: what are the use cases for this kind of model? Could it be used in the context of coding agents, or is it more relevant in totally different situations?
Yeah, it could. The most obvious usage would be to have local fast cheap "feedback" / "control" over a slower more expensive agent (i.e. cc / codex / opencode). Things like "goals" could now be split from a long prompt into "actions" and "verifiers". Where for each action you also produce a verifier. Then after each action you run the verifier w/ this kind of "universal classifier" and decide if the step was done correctly, if it needs follow-up and so on.
Example: implement auth in this repo -> llm_plan() -> for item in plan generate_verifier() -> for item in plan implement() ; verify() ; accept() / followup().
Verifiers could be something like this. take a plan item as input, generate classification questions that might verify the task "is this following project conventions?" | "is this touching files from other tasks?", etc.
You can do that with LLMs, but some things might become cheaper / faster. And you can pretty much use it to check against an ever growing list of conventions. Yours or project specific.
The problem is that you want the model to carefully reason about the goal and code.
Zero shot classification with an approach like this isn’t going to do that. It’ll answer on first pass vibes.
For coding agents it'd only be useful in a subset of situations. E.g. you could imagine using one to classify bash tool calls into safe and unsafe for example.
Edit: I want to add that you can see Jev like a smart if-statement.
prompt_eval=244 ms wall=245 ms schema_cache=hit generated=0
Move limit reached after 200 moves: score=16, length=19.
So, if a 12B dense model can offer this latency on a local old PC, then definitely you can scale it up with more powerful machines and get even lower latency.
My understanding is: it takes text input and it does one shot classification (no training data)
As a corollary, the output classes can be any set, rather than needing to be set before training.
softmax(encode(input)*learned_weights)
You have
softmax(encode(input)*encode(categories))
I'm not sure if Jev does it this way, but it's how you get open-vocabulary zero-shot image classification with models like CLIP [1].
[1] https://openai.com/index/clip/
My guess would be option 1. Didn’t read the kev repo here which would also explain
I have tried many of these open-source Jev-like models on some linguistic tasks and they are so bad compared to Jev.
The number of people working on this is crazy. Something will coalesce.