Red Hat testou Jev, e os resultados são constrangedores...

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Red Hat Tested Jev and the Results Are Awkward… · Canal: Better Stack · 02:37 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Modelos de IA, Segurança de IA

Resumo

A equipe de segurança de IA da Red Hat comparou nove guardrails em testes de detecção de prompt injection e conteúdo tóxico. Um classificador DeBERTa de apenas 200 milhões de parâmetros, executado na CPU de um laptop, quase alcançou o melhor resultado na detecção de prompt injection e respondeu muito mais rápido que Jev. Jev venceu o teste de segurança de conteúdo, mas o desempenho dos modelos também dependeu bastante do prompt usado. A conclusão foi que decision models não foram consistentemente mais rápidos, baratos ou precisos que um LLM as a judge, enquanto modelos pequenos podem ser difíceis de superar quando há dados rotulados e um problema bem definido.

Pontos-chave

A avaliação comparou nove guardrails em tarefas de detecção de prompt injection e conteúdo tóxico.
Qwen 3.6 35 billion obteve 89,31% na detecção de prompt injection; o classificador DeBERTa da Red Hat chegou a 89,01%.
O DeBERTa tinha cerca de 200 milhões de parâmetros, rodava na CPU de um laptop e respondia em aproximadamente 54 milissegundos.
Jev ficou em quarto lugar na detecção de prompt injection, com 86,35% e cerca de 348 milissegundos por chamada.
Jev venceu o teste de segurança de conteúdo, com 86,2%, superando o Granite Guardian pequeno da Red Hat por cerca de seis pontos.
Reescrever o prompt para LLaMA elevou seu resultado em segurança de conteúdo em quase 18 pontos; o mesmo prompt piorou o resultado de Jev.
A conclusão da Red Hat foi que decision models não eram consistentemente mais rápidos, baratos ou precisos que um LLM as a judge.
Decision models podem ser úteis quando não há um classificador pronto; com dados rotulados e uma tarefa clara, modelos pequenos em CPU continuam competitivos.

Capítulos

Início	Capítulo	Resumo
00:00	O teste de Jev e dos guardrails	O vídeo apresenta Jev e explica que a Red Hat comparou nove guardrails em duas tarefas de segurança.
00:30	Resultados na detecção de prompt injection	Qwen liderou por pouco, enquanto o pequeno classificador DeBERTa quase igualou sua precisão com latência menor.
01:32	Segurança de conteúdo e efeito do prompt	Jev venceu o teste de conteúdo, mas a adaptação do prompt ajudou LLaMA e prejudicou Jev.
02:05	Conclusões sobre decision models e modelos pequenos	A Red Hat não encontrou vantagem consistente para decision models e destacou a competitividade de modelos pequenos em CPU.

Citações

Um dos modelos que quase venceu tudo era um pequeno classificador de 200 milhões de parâmetros rodando na CPU de um MacBook. — 00:00

Isso dá cerca de 0,3 ponto atrás de um modelo mais de 100 vezes maior. — 01:01

O prompt que funciona para um modelo pode, discretamente, piorar o resultado de outro. — 01:32

Decision models não foram, de forma confiável, mais rápidos, baratos ou precisos que simplesmente usar um LLM as a judge. — 02:05

Se você tem dados rotulados e um problema claro, é muito difícil superar um modelo pequeno rodando na CPU. — 02:05

Conceitos e entidades

Jev (modelo): decision model zero-shot avaliado pela Red Hat em tarefas de segurança de conteúdo e detecção de prompt injection.
TypeSafe (empresa): Empresa que apresentou Jev como uma alternativa de menor custo e latência para LLM as a judge.
Red Hat (empresa): Empresa cuja equipe de segurança de IA conduziu a comparação entre nove guardrails.
DeBERTa (modelo): Classificador pequeno da Red Hat que obteve 89,01% na detecção de prompt injection.
Qwen3.6 35B A3B (modelo): Modelo com 35 bilhões de parâmetros que ficou em primeiro lugar na detecção de prompt injection, com 89,31%.
NVIDIA NeMo Tron (modelo): Um dos modelos incluídos na comparação de guardrails da Red Hat.
Llama (modelo): Modelo open source cujo resultado em segurança de conteúdo melhorou após a equipe adaptar o prompt.
Diffusion Gemma (modelo): Uma das alternativas open source de decision model incluídas na avaliação.
Granite Guardian (modelo): Modelo pequeno da Red Hat que Jev superou no teste de segurança de conteúdo por cerca de seis pontos.
LLM as a judge (conceito): Uso de um LLM para avaliar respostas ou identificar conteúdo que deve ser bloqueado.

Tradução completa (pt-BR)

00:00 Então, todo mundo tem exaltado o novo decision model Jev da Type-Safe como o futuro das proteções de IA, então a Red Hat decidiu colocá-lo à prova de verdade. E, sinceramente, os resultados são meio hilários, porque um dos modelos que quase venceu todos os outros era um pequeno classificador de 200 milhões de parâmetros rodando na CPU de um MacBook. Então, veja como foi o teste. A ideia por trás do Jev é bem legal. Em vez de gerar texto como um LLM normal, você fornece um estado e uma lista de perguntas, e ele simplesmente retorna decisões. Ele também funciona sem exemplos, então você não precisa treiná-lo nem nada, e a proposta da Type-Safe era que você

00:30 pode ter um LLM as a judge com a mesma qualidade por muito menos dinheiro e com muito menos latência. Então, a equipe de segurança de IA da Red Hat reuniu nove proteções diferentes e apresentou a elas dois problemas: detectar injeções de prompt e detectar conteúdo tóxico. Na seleção, havia alguns classificadores pré-treinados, grandes LLMs usados como juízes, como o Qwen 3.6 35 billion e o NeMo Tron da Nvidia, um antigo modelo sem exemplos de 2019 e, então, os decision models, que eram o Jev mais duas alternativas open source, LLaMA e Diffusion Gemma. Na detecção de injeção de prompt, o Qwen com 35

01:01 bilhões de parâmetros ficou em primeiro lugar, com 89,31%, mas o pequeno classificador DeBERTa da própria Red Hat, que tinha apenas cerca de 200 milhões de parâmetros e estava literalmente rodando na CPU de um laptop, chegou a 89,01%. Isso dá apenas 0,3 ponto a menos que um modelo mais de 100 vezes maior. E ele respondeu em cerca de 54 milissegundos. O Jev ficou em quarto lugar, com 86,35%, e levou cerca de 348 milissegundos por chamada. Agora, para dar algum crédito ao Jev, ele realmente venceu o teste de segurança de conteúdo, com 86,2%

01:32 e superou o pequeno modelo Granite Guardian da própria Red Hat por cerca de seis pontos. A Red Hat admitiu abertamente que precisa de um modelo pequeno melhor para esse caso. Mas a parte que achei mais interessante foi a criação dos prompts. O modelo open source LLaMA se saiu muito mal na segurança de conteúdo no começo, com cerca de 58%, então a equipe reescreveu o prompt especificamente para o LLaMA, e o resultado subiu quase 18 pontos. Depois, deram o mesmo prompt ao Jev, e o Jev teve um resultado pior. Então, mesmo com esses sofisticados decision models que funcionam sem exemplos, você ainda precisa fazer engenharia de prompt, e o prompt que funciona para um modelo pode, sem que você perceba, ter um resultado pior em

02:05 outro. Mas, para ser justo com o Jev mais uma vez, ele estava sendo chamado do Reino Unido para servidores nos EUA, então cada solicitação acumulava pelo menos 56 milissegundos extras de tempo de rede. Mas, mesmo levando tudo isso em conta, a conclusão da Red Hat foi que os decision models não eram, na prática, mais rápidos, mais baratos ou mais precisos de forma confiável do que simplesmente usar um LLM as a judge tradicional. Então, onde isso nos deixa? Bem, acho que os decision models fazem muito sentido quando não existe um classificador pronto para aquilo que você está tentando detectar. Mas, se você tem dados rotulados e um problema bem definido, ainda é muito difícil superar um modelo minúsculo rodando em uma CPU. E, pessoalmente, fico feliz em ver as pessoas se empolgando de novo com modelos pequenos, simples e rápidos, em vez de jogar um LLM gigante em todo problema. E, se quiser ficar por dentro das novidades em pesquisa e engenharia de IA, inscreva-se no canal Better Stack.

02:37 para superar. E, pessoalmente, fico feliz em ver as pessoas voltando a se empolgar com modelos pequenos, sem graça e rápidos, em vez de jogar um LLM gigante em todo problema. E, se você quer ficar por dentro das últimas novidades em pesquisa e engenharia de IA, não deixe de se inscrever no canal da Better Stack.

Transcrição original

[00:00] So, everyone’s been hyping up Type-Safe’s new Jev decision model as the future of AI guardrails, so Red Hat decided to actually put it to the test. And honestly, the results are kind of hilarious because one of the models that almost beat everything was a tiny 200 million parameter classifier running on a MacBook CPU. So, here’s how the test went. So, idea behind Jev is pretty cool. Instead of generating text like a normal LLM, you give it a state and a list of questions and it just gives you back decisions. It’s also zero-shot, so you don’t need to train it or anything, and Type-Safe’s whole pitch was that you

[00:30] can get an LLM as a judge with the same quality for a lot less money and a lot less latency. So, the Red Hat AI safety team lined up nine different guardrails and threw two problems at them: catching prompt injections and catching toxic content. In the lineup, you had some pre-trained classifiers, big LLM judges like Qwen 3.6 35 billion and Nvidia’s NeMo Tron, an old zero-shot model from 2019, and then the decision models, which were Jev plus two open-source alternatives, LLaMA and Diffusion Gemma. On prompt injection, Qwen with 35

[01:01] billion parameters came in first at 89.31%, but Red Hat’s own little DeBERTa classifier, which only had around 200 million parameters and was literally running on a laptop CPU, got 89.01%. That’s like 0.3 points behind a model that’s over 100 times bigger. And it answered in about 54 milliseconds. Jev came fourth at 86.35% and took around 348 milliseconds per call. Now, to give Jev some credit, it actually won the content safety test at 86.2%

[01:32] and it beat Red Hat’s own small Granite Guardian model by about six points. Red Hat was pretty upfront that they need a better small model for that one. But, the part that I found most interesting was the prompting. The open-source LLaMA model did really badly on content safety at first, around 58%, so the team rewrote the prompt specifically for LLaMA, and then it jumped almost 18 points. Then, they gave the same prompt to Jev, and Jev actually got worse. So, even with these fancy zero-shot decision models, you’re still stuck doing prompt engineering, and the prompt that works for one model can quietly do worse on

[02:05] another one. But, to be fair to Jev again, it was being called from the UK to servers in the US, so every request picked up at least 56 milliseconds of extra network time. But, even accounting for all of that, Red Hat’s conclusion was that decision models weren’t actually reliably faster, cheaper, or more accurate than just using a plain old LLM as the judge. So, where does that leave us? Well, I think decision models make a lot of sense when there’s no ready-made classifier for the thing you’re trying to catch. But, if you’ve got labeled data and a clear problem, a tiny model on a CPU is still really hard

[02:37] to beat. And personally, I’m just happy to see people getting excited about small, boring, fast models again, instead of throwing a giant LLM at every problem. And if you want to stay up-to-date with the latest in AI research and engineering, be sure to subscribe to the Better Stack channel.