Com Jeff você pode executar em seu próprio código modelos de decisão compatíveis com Jev de TypeSafe e ajustá-los com seus próprios dados em meia hora com uma única GPU. São modelos open weights a partir de 0,8B parâmetros, o menor ocupa 1,7 GB e seu autor (firelex no GitHub) os treinou completamente em hardware local. O código é MIT e os pesos, Apache-2.0.
Antes de começar: Jeff funciona apenas com texto em inglês. Se seus dados estão em espanhol ou português, mais abaixo contamos qual alternativa usar.
Se ainda não conhece Jev, a ideia é simples: você descreve uma situação, enumera as opções em linguagem natural e o modelo retorna uma probabilidade calibrada para cada uma em uma única passada. Não gera texto, então não há nada para fazer parse. Explicamos como funciona em Jev de TypeSafe: como funciona a IA que toma decisões sem gerar texto. Os pesos de Jev não são públicos. Os de Jeff são, e também a receita com a qual foram treinados.
O que é Jeff e qual é sua relação com Jev?
Jeff é uma família de fine-tunes de Qwen3.5 e Gemma 4 treinados para zero-shot classification e disponibilizados atrás de uma API compatível com a de Jev. É um projeto independente: o autor esclarece que não está afiliado a TypeSafe nem conta com seu respaldo.
Nasceu como um fork de AutoJev, uma receita aberta de Denis Yarats que ajusta um modelo Qwen de 27B para retornar decisões ao estilo de Jev. Jeff manteve o design central de AutoJev:
- uma única passada do modelo por decisão
- uma leitura da resposta treinada
- uma temperatura ajustada para a calibração
A partir daí, levou a ideia para modelos pequenos (small language models). Há três publicados no Hugging Face:
| Modelo | Parâmetros | Pesos (16 bits) |
|---|---|---|
| Jeff-Qwen3.5-0.8B | 0,8B | 1,7 GB |
| Jeff-Qwen3.5-2B | 2B | 4,2 GB |
| Jeff-Gemma4-E2B | 2B efetivos (4,6B armazenados) | 9,3 GB |
Zero-shot significa que suas categorias não precisam aparecer nos dados de treinamento: filas de suporte, intenções de usuário, rótulos de moderação, comandos de voz ou até jogadas de um videogame. Você descreve as opções e Jeff escolhe.
Jeff é tão bom quanto Jev?
Em classificação, sim; em raciocínio, fica claramente atrás, e o próprio autor diz isso. Os números a seguir são publicados pelo projeto e comparam Jeff com os números publicados de Jev, que foram medidos em outra amostra dos mesmos benchmarks.
Onde Jeff vai na frente:
- No Financial PhraseBank, os três modelos de Jeff rondam os 96%, frente aos 77% publicados para Jev.
- No RAGTruth obtêm entre 86% e 89%, frente aos 77%.
- Na pontuação global de cinco benchmarks, Jeff-2B chega a 83,1%, frente aos 83,0% de Jev.
Onde fica atrás:
- No BBH, Jeff tira entre 64% e 68%, frente aos 94%.
- No nível difícil de JevBench, entre 48% e 53%, frente aos 73%.
A conclusão do autor é que os modelos pequenos não raciocinam. Com 0,8B–2B parâmetros você obtém escolhas rápidas e calibradas entre opções que você descreve, não raciocínio em várias etapas.
Há dois dados externos. Um usuário que abriu uma issue no repositório reconstruiu o painel de benchmarks do autor e reproduziu suas pontuações com uma margem de 0,6 pontos, então os números de Jeff se sustentam. Em contrapartida, um comentarista do Hacker News que comparou Jeff com Jev em suas próprias tarefas de classificação reportou 70% frente a 94%. É um caso isolado, mas mostra que a precisão zero-shot depende muito da tarefa. Por isso importa a seção de fine-tuning que vem mais abaixo.
Jeff deixa além disso um resultado curioso: maior não é melhor. O modelo de 2B supera o de 0,8B nos benchmarks, mas joga pior nos testes com videogames do autor, que o descreve como mais avesso ao risco. Para escolher opções rápido, o autor recomenda o de 0,8B.
Quão rápido é Jeff?
Estas são as medianas por decisão que o autor publica, medidas em 200 perguntas de cerca de 200 tokens de entrada cada uma:
| Modelo | RTX PRO 6000 | Apple M4 Max (MLX) | CPU (32 threads) |
|---|---|---|---|
| Jeff-Qwen3.5-0.8B | 22 ms | 28 ms | 463 ms |
| Jeff-Qwen3.5-2B | 24 ms | 60 ms | 708 ms |
| Jeff-Gemma4-E2B | 29 ms | — (MLX executa apenas Qwen) | 1,0 s |
Como referência, as execuções de Doom publicadas por Jev levaram entre 114 e 212 ms por chamada, incluindo a rede. As duas medições não foram feitas no mesmo hardware. São os números do autor em 29 de setembro de 2026.
Como fazer fine-tuning de Jeff com seus próprios dados?
O caminho realista é ajustar um checkpoint de Jeff com seus próprios exemplos etiquetados, não retreiná-lo do zero.
O exemplo do autor é um app de navegação por voz. Um fine-tuning com cerca de 11.000 exemplos próprios do app, em uma única época, levou em torno de meia hora em uma GPU. Aumentou a precisão em dados reservados de 31,7% para 95,8%, com cerca de 40 ms por decisão em um M4 Max. O README indica que se faz com autojev-train de AutoJev, usando a opção --initial-checkpoint para partir de um checkpoint de Jeff.
A receita completa também é pública e vale a pena lê-la mesmo que você não a execute:
- Método de treinamento: fine-tuning de todos os pesos, uma época, lotes de 256, entropia cruzada sobre as letras das opções e, ao final, uma única temperatura ajustada para calibração. Os checkpoints são escolhidos com um conjunto de desenvolvimento reservado, nunca com o painel de benchmarks.
- Dados: 271.000 perguntas. A maioria são datasets públicos convertidos em decisões (inferência, perguntas e respostas, sentimento, segurança, verificação de fatos). Cerca de 31.000 são perguntas sintéticas escritas e revisadas por um modelo aberto, Qwen3.8-Flash-Next. Nenhum resultado de um modelo fechado entrou no treinamento; apenas um foi usado para revisar a qualidade de uma amostra.
- Filtro de vazamento: cada pergunta de treinamento é contrastada com o painel de benchmarks e com JevBench. Assim, 50 quase duplicatas foram eliminadas.
- Hardware: uma RTX PRO 6000 (96 GB) para treinar, dois DGX Spark com o modelo mestre e um MacBook para testes. O modelo de 0,8B é treinado em cerca de duas horas e o de 2B, em cerca de três horas e meia.
É hardware local, mas de gama alta; no Hacker News alguém apontou isso com ironia. A receita funciona sem GPU na nuvem, mas um retreinamento completo exige uma estação de trabalho séria. A parte que a maioria dos times realmente usará é o fine-tuning com seus próprios exemplos.
Dois detalhes a mais. Os dados de treinamento não são publicados: apenas o código, os pesos e a lista de fontes com suas licenças, em docs/data-sources.md, e algumas dessas fontes são share-alike (CC BY-SA). O autor também reconhece que pelo menos metade de cada família de dados segue as convenções de formato do painel de benchmarks, o que ajuda a pontuação.
Como instalar e usar Jeff?
Jeff é executado como um servidor local que fala o endpoint /v1/systemone de Jev. Segundo o README:
uv sync
uv run hf download mstrasser/Jeff-Qwen3.5-0.8B --local-dir checkpoints/jeff-0.8b
# NVIDIA GPU or CPU (PyTorch)
JEFF_CHECKPOINT=checkpoints/jeff-0.8b PORT=8765 uv run jeff-serve
# Apple silicon (MLX, much faster on a Mac; Qwen models only)
uv sync --extra mac
JEFF_BACKEND=mlx JEFF_CHECKPOINT=checkpoints/jeff-0.8b PORT=8765 uv run jeff-serve
Uma requisição tem esta forma:
curl -s localhost:8765/v1/systemone -H 'content-type: application/json' -d '{
"model": "jeff-latest",
"state": "Refund request: the customer says the parcel arrived crushed and wants their money back.",
"questions": {
"route": {"type": "choice", "instructions": "Which team should handle this?",
"criteria": {"1": "Refunds and payments", "2": "Damaged or lost parcels", "3": "Account and login problems"}},
"angry": {"type": "noul", "instructions": "Is the customer angry?"}
}
}'
Cada resposta inclui uma probabilidade por opção, a opção escolhida e um nível de confiança. Existem três tipos de pergunta:
choiceescolhe uma opção de uma lista.noulresponde sim ou não, como uma probabilidade.scoreretorna um ponto em uma escala que você descreve.
Você pode enviar várias perguntas independentes na mesma requisição.
Quantas opções Jeff pode lidar?
Na prática, 26. O README admite até 255 opções em uma pergunta choice e o servidor as aceita, mas em 29 de setembro de 2026 há uma issue aberta que relata que os modelos Qwen3.5 nunca escolhem uma opção além da número 26 (as codificadas como AA ou posteriores).
O teste do usuário é claro. Com 30 cidades e Zurique na posição 28, o modelo de 0,8B escolheu Atenas e deu a Zurique uma probabilidade de 0,0004. Com Zurique na posição 3, a escolheu com 0,998. Em datasets reais de intenções, como BANKING77, CLINC150 e MASSIVE, os modelos acertaram entre 69% e 80% quando a resposta estava entre as primeiras 26 opções, e 0% quando estava além. O usuário suspeita que o treinamento nunca incluiu perguntas com mais de 26 opções, embora o apresente como hipótese. Jeff-Gemma4-E2B não foi testado.
Enquanto o autor não resolver isso, se sua lista for mais longa, filtre antes uma lista curta de candidatos.
Como aproveitar melhor?
Os conselhos de uso do README funcionam como um pequeno guia de estilo:
- Raciocine no código e decida com Jeff. É um classificador, não um planejador. Descreva aonde leva cada opção; se você pedir que preveja o futuro, não faz melhor que o acaso.
- A redação é muito importante. Em Frogger, dar à opção de meta as mesmas palavras que ao resto dos avanços para frente levou um episódio de 15 travessias a 23.
- Use chaves curtas e texto descritivo. Escreva
{"1": "Engagement letter"}, não identificadores longos.
Jeff serve para classificação de texto em português?
Não. A ficha do modelo indica que Jeff só funciona com texto em inglês e sua calibração está ajustada com os dados de desenvolvimento do autor. Se suas entradas são tickets de suporte, e-mails ou comandos de voz em português, atualmente Jeff não é a ferramenta adequada.
Para texto que não está em inglês, a opção local mais próxima é Ollaya. Serve modelos de decisão abertos atrás da mesma API compatível com Jev, e seu router laya envia o texto em outros idiomas para um modelo multilíngue.
Para quem faz sentido Jeff?
Jeff se encaixa com quem quer um passo de decisão dentro de seu próprio código (rotear tickets, detectar intenções, moderar) que se execute em local em dezenas de milissegundos, com um modelo que pode ser retreinado quando a precisão zero-shot não é suficiente. Não substitui Jev em julgamentos que exigem raciocínio, não é multilíngue e atualmente não serve para classificar entre dezenas de intenções sem filtrar antes.
O que justifica dedicar uma tarde é que todo o pipeline é aberto: pesos, código de treinamento, filtro de vazamento e passo de calibração. Você pode pegar um modelo de 1,7 GB, apontá-lo para seus próprios dados etiquetados e medir o resultado você mesmo.