Jeff: o modelo de 0,8B que decide em 22 ms

O Jeff é um modelo pequeno de decisão. Em vez de gerar uma resposta longa ou conduzir uma conversa, ele recebe um contexto e escolhe uma opção entre alternativas que você apresenta.

A proposta é usar o modelo dentro do código da aplicação, em situações nas quais você precisa classificar, encaminhar ou selecionar um caminho. Ele funciona em modo zero-shot: você não precisa treiná-lo antes para começar a testar o caso de uso.

Jeff não é apresentado como um modelo geral de raciocínio. A força dele está em tomar decisões delimitadas com rapidez.

O projeto chamou atenção ao passar de 500 pontos no Hacker News. Os números e características abaixo vêm do README oficial do projeto e das informações publicadas no Hacker News em 29/09/2026.

Números conforme o README oficial do Jeff e as informações do post. Resultados podem depender das condições de avaliação.

Em uma tarefa tradicional de classificação, você poderia treinar um modelo com exemplos rotulados. No caso do Jeff, a ideia é diferente: o código apresenta o contexto e uma lista de alternativas, e o modelo escolhe uma delas sem que você tenha feito um treinamento específico para aquela aplicação.

1. Defina o contexto: informe ao modelo o evento, a entrada ou o estado atual.
2. Liste as opções válidas: apresente as alternativas que a aplicação pode aceitar.
3. Peça uma única escolha: use a saída para encaminhar o próximo passo do fluxo.
4. Valide o resultado: trate a resposta como uma decisão de modelo e tenha um caminho seguro para erros.

Exemplo ilustrativo: um aplicativo recebe uma solicitação e precisa escolher entre “encaminhar para suporte”, “pedir mais informações” ou “resolver automaticamente”. O Jeff pode atuar como a camada que seleciona uma dessas opções, enquanto as ações continuam sob controle do seu código.

O limite informado pelo projeto é de até 26 opções. Portanto, a lista de escolhas precisa ser finita, explícita e compatível com esse limite.

Nos cinco benchmarks apresentados pelo projeto, o Jeff de 0,8B alcançou 79,1%, enquanto o Jev, produto comercial que o Jeff imita, marcou 83,0%. A diferença mostra que o modelo menor se aproxima da referência, mas não a iguala nesse conjunto de avaliações.

Já a versão de 2B chegou a 83,1% nos mesmos cinco benchmarks, praticamente empatando com os 83,0% do Jev.

Essa comparação ajuda a separar duas perguntas:

• O modelo consegue tomar decisões úteis? Os resultados do 0,8B indicam que vale testá-lo em tarefas delimitadas.
• Ele alcança o desempenho da referência em qualquer situação? Não dá para concluir isso apenas com esses números, especialmente diante dos resultados mais fracos em tarefas difíceis.

Os percentuais são resultados de benchmark, não uma garantia de desempenho no seu produto. Antes de trocar uma solução existente, avalie o comportamento com entradas reais e com as opções que sua aplicação de fato oferece.

O Jeff pode ser rápido em uma decisão curta e ainda assim não ser bom em raciocinar sobre problemas complexos. O próprio conjunto de resultados apresentado pelo projeto deixa essa distinção clara.

No nível difícil do JevBench, o Jeff marcou 47,6%. No Pac-Man, coletou 57 de 98 bolinhas, enquanto um bot baseado em regras chegou a 94. Esses resultados não tornam o modelo inútil: eles mostram que velocidade e tamanho pequeno não equivalem a planejamento geral.

Na prática, não use o Jeff como substituto automático de um modelo grande para:

• resolver problemas abertos que exigem várias etapas de raciocínio;
• planejar uma sequência longa de ações;
• interpretar uma situação sem opções bem definidas;
• substituir regras determinísticas quando elas já resolvem o caso com mais previsibilidade.

Para esses cenários, o post recomenda uma abordagem diferente: modelo grande para raciocínio e Jeff para decisões rápidas e delimitadas.

O melhor cenário para o Jeff é uma decisão pequena, repetida e embutida no fluxo de uma aplicação. O modelo não precisa produzir uma resposta elaborada: precisa escolher corretamente uma alternativa aceita pelo sistema.

• Roteamento: decidir qual fila ou fluxo deve receber uma solicitação.
• Classificação: selecionar uma categoria entre opções previamente definidas.
• Seleção de ferramenta: escolher qual caminho disponível deve ser acionado.
• Triagem: separar casos simples dos que precisam de análise mais profunda.
• Fallback: escolher entre respostas ou próximos passos que o produto já conhece.

Os exemplos acima são possibilidades de aplicação, não resultados específicos publicados pelo projeto. A validação precisa ser feita no seu domínio, com suas entradas, suas opções e seu critério de erro.

Se a tarefa puder ser resolvida por uma tabela, uma regra ou uma máquina de estados, compare essas alternativas antes de adicionar um modelo. O Jeff é mais interessante quando existe ambiguidade suficiente para exigir uma decisão de modelo, mas as saídas continuam limitadas.

1. Escolha uma decisão concreta: não comece com “usar IA”; comece com uma escolha que já acontece no produto.
2. Escreva as opções permitidas: cada saída deve corresponder a um caminho que o sistema sabe executar.
3. Registre exemplos reais: separe entradas representativas, casos fáceis e casos ambíguos.
4. Compare com uma referência: pode ser uma regra existente, uma decisão humana ou o Jev, dependendo do que você está avaliando.
5. Meça os erros importantes: uma decisão errada pode ter impacto muito diferente de uma decisão apenas subótima.
6. Teste o limite de opções: mantenha a lista dentro das 26 opções informadas pelo projeto.
7. Crie um fallback: quando a confiança operacional não for suficiente, encaminhe o caso para uma regra, revisão humana ou modelo maior.

O objetivo do teste não é provar que o Jeff é melhor em tudo. É descobrir se uma decisão específica pode ser feita com custo e latência menores sem comprometer o resultado que o produto precisa.

• As opções de saída estão claramente definidas?
• O fluxo aceita no máximo 26 opções?
• Existe uma resposta segura para entradas ambíguas ou inválidas?
• Você comparou o Jeff com uma regra simples?
• Você testou o modelo de 0,8B e considerou o de 2B?
• O caso exige decisão ou exige raciocínio?
• Você mediu qualidade no seu próprio conjunto de entradas?
• O time sabe quando encaminhar a tarefa para um modelo maior?

Os pesos do projeto estão sob a licença Apache 2.0. Ainda assim, revise o repositório e as condições aplicáveis ao seu uso antes de distribuir ou operar a solução em um produto.

Acesse o repositório oficial do Jeff para consultar o README, os pesos e os detalhes publicados pelo projeto.