Novos decision models do Ollama: tev1 + nimble (testados em 8 GB)

Autoria: Prompt Engineer 48 · 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: Ollama’s New Decision Models: tev1 + nimble (Tested on 8 GB) · Canal: Prompt Engineer 48 · 08:03 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Avaliação e benchmarks de IA, Modelos locais e open source

Resumo

O vídeo apresenta tev1 e Nimble, decision models que retornam classificações e probabilidades em vez de respostas conversacionais, e mostra como usá-los localmente com Ollama. O apresentador testa triagem de tickets, moderação, roteamento e avaliação de respostas, além de comparar velocidade, uso de memória e desempenho em um conjunto próprio de 30 tickets. Nos testes, tev1 4B e Nimble têm pontos fortes diferentes, enquanto Nimble não cabe totalmente em uma GPU de 8 GB. O vídeo também compara os modelos a um modelo pequeno que gera JSON e destaca que as probabilidades dos decision models podem ajudar a encaminhar casos incertos para revisão humana.

Pontos-chave

tev1 e Nimble são decision models: recebem um texto e perguntas, e retornam respostas com probabilidades, sem gerar parágrafos.
O endpoint usado é /v1/system1, e cada pergunta precisa incluir instruções; perguntas do tipo choice e score exigem formatos de critérios diferentes.
O apresentador demonstra usos em triagem de tickets, moderação, roteamento de solicitações e avaliação de respostas.
No teste próprio com 30 tickets, tev1 4B acertou 100% na equipe e 83,3% na classificação de tom; Nimble alcançou 96,7% em ambas as métricas.
Nimble levou cerca de 1,5 segundo por chamada e não coube totalmente na GPU de 8 GB, usando também a CPU.
O modelo tev1 0.8B é a opção mais leve, mas com menor precisão nos testes; tev1 4B é a recomendação do apresentador para um laptop com 8 GB.
Um teste com Qwen 3.5 4B usando um schema JSON igualou Nimble nas métricas do conjunto de tickets e foi mais rápido.
Probabilidades podem apoiar limites de confiança, como encaminhar respostas abaixo de 0,9 para uma pessoa, mas não devem ser a única verificação em decisões de alto risco.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação dos decision models	O vídeo apresenta tev1 e Nimble, explica o conceito de System 1 models e compara suas versões e origens.
02:14	Instalação e chamadas ao endpoint	O apresentador baixa os modelos, testa o endpoint /v1/system1 e corrige os formatos exigidos para as perguntas.
03:19	Demonstrações práticas	Uma aplicação Gradio demonstra triagem, moderação, roteamento e avaliação de respostas com tev1 e Nimble.
04:57	Desempenho, memória e comparação	O apresentador compara os modelos em 30 tickets, relata o uso de CPU e GPU e testa Qwen 3.5 4B com JSON.
06:33	Probabilidades, limitações e conclusão	O vídeo discute confiança e consistência, resume vantagens e limitações e recomenda cautela em decisões de alto risco.

Citações

Eles não conversam. Eles decidem. — 00:00

O critério de score precisa ser uma lista, não um mapa. — 02:46

Este é o meu pequeno teste, não um benchmark público. — 05:30

Em precisão e velocidade, ele igualou o Nimble e foi mais rápido. — 06:33

Não deixe que ele seja a única verificação em uma decisão de alto risco. — 07:33

Conceitos e entidades

Ollama (ferramenta): Ferramenta usada para baixar e executar localmente os decision models demonstrados.
tev1 (modelo): Família de decision models da Together AI, apresentada nas versões de 4B e 0.8B.
Nimble (modelo): Decision model de 9 bilhões de parâmetros da Bespoke Labs, comparado a tev1 nos testes.
TypeSafe (empresa): Empresa associada aos modelos System 1 descritos no vídeo.
Together AI (empresa): Empresa de origem do tev1, conforme apresentado no vídeo.
Bespoke Labs (empresa): Empresa de origem do Nimble, conforme apresentado no vídeo.
System 1 models (conceito): Modelos que recebem um texto e perguntas e retornam respostas com probabilidades, em vez de produzir conversa.
Qwen3.5 (modelo): Família de modelos indicada como base de fine-tuning para tev1 e Nimble.
Gradio (ferramenta): Ferramenta usada para montar um aplicativo de demonstração com abas para diferentes tarefas.

Tradução completa (pt-BR)

00:00 Certo. Neste vídeo, vamos ver dois modelos novíssimos no Ollama: Tev 1 e Nimble. E você pode ver aqui que digito um chamado de suporte, e ele me diz a equipe e o nível de confiança em cerca de meio segundo. Vale lembrar que estes não são modelos de chat. Eles não conversam. Eles decidem. E tudo aqui está rodando no meu sistema local, neste laptop com GPU de 8 GB que tenho aqui. Se você assistiu aos meus vídeos em que treinei meu próprio modelo no estilo Jev, esta é a mesma ideia, e agora o Ollama oferece suporte a ela. Vamos testar. Então, o que é isso? O Ollama publicou uma postagem no blog dizendo que agora oferece suporte a modelos de decisão no estilo Jev.

00:34 Eles vêm de uma empresa chamada Type-Safe, que os chama de modelos System 1. A ideia é bem simples. Você fornece um texto, que eles chamam de estado, e faz perguntas; em resposta, recebe uma resposta com uma probabilidade. Nada de parágrafo, nada de JSON que você precisa torcer para ser válido. Há três tipos de pergunta: escolha, em que você seleciona uma opção de uma lista; nula, que é basicamente verdadeiro ou falso; e pontuação, em que você a avalia com base em uma rubrica. E você pode fazer até 64 perguntas sobre o mesmo texto em uma única chamada. Agora, há dois modelos. Nimble tem 9 bilhões de parâmetros, é da Bespoke Labs e está sob a licença Apache 2.0. Tev 1 é da

01:08 Together AI e vem nos tamanhos de 4 bilhões e 0,8 bilhão. Ambos são fine-tuned a partir do Qwen 3.5. Eles dizem que o Nimble obtém 75,7% no benchmark público deles, e o Tev 1 4B obtém 73,3%. Esses são os números deles, não os meus. Daqui a pouco, vamos fazer nosso próprio teste. Primeiro, se você não tem o Ollama, acesse ollama.com, clique em download e instale no seu sistema. É bem simples: no Windows, é um único instalador. Agora, há uma etapa extra que você precisa seguir. Esses modelos exigem o Ollama 0.35 ou posterior, então abra um terminal e digite ollama {dash}

01:42 {dash} version. O meu mostra 0.35.0, então estamos no mínimo exigido. Agora, baixe os modelos. Digito ollama pull tev1, depois ollama pull nimble e ollama pull tev1:0.8b. Eu já os tenho, então isso termina em um segundo. Do seu lado, vai levar algum tempo dependendo da sua conexão. E, se eu digitar all na minha lista, você pode ver os três aqui. Tev one tem 4,5 GB. O pequeno tem 811 MB. E Nimble tem 9,5 GB. Lembre-se desse

02:14 número, porque minha placa tem apenas 8 GB. Agora, vamos fazer nossa primeira chamada. Não é o endpoint de chat. É /v1/system1 na porta 11434. Envio um modelo, um estado e perguntas. Então, escrevi uma pergunta chamada team, do tipo escolha, e pergunto qual equipe deve cuidar disso. Pressiono Enter e recebemos um erro. Ele diz que instructions precisa ser uma string não vazia. Então, toda pergunta precisa de um campo instructions. Certo, vamos adicioná-lo. Executo de novo. Agora, diz que os critérios de choice precisam associar as chaves das opções a descrições. Então, para uma

02:46 escolha, preciso fornecer um mapa de critérios: billing, pagamentos e reembolsos; tech, bugs e interrupções; sales, preços e upgrades. Vamos executar de novo. E agora, uma pergunta de pontuação. Adicionei uma, e aparece que os critérios de score precisam ser um array de descrições. Então, para score, os critérios são uma lista, não um mapa. Na terceira tentativa dá certo. Agora, se você olhar aqui, temos billing com 0,9975, o cliente está irritado com 0,87 e a urgência está em 0,65. E o modelo escreveu apenas quatro tokens. É por isso que isso é rápido. Em Python, é igual. Eu uso

03:19 requests, envio o modelo, o estado e as perguntas, e leio as respostas. Seis linhas. Vou colocar esse arquivo na descrição. Agora, coloquei isso em um pequeno app Gradio com quatro abas, para você poder testar. A primeira aba é a triagem de chamados. Digito: “Meu cartão foi cobrado duas vezes, e quero um reembolso agora.” Clico na lateral, e você pode ver que ele diz billing com 0,99. As barras aqui são as probabilidades. Tech e sales estão praticamente em zero. Agora, vamos testar a API. A API retorna um erro 500, a produção está fora do ar, e And vai para

03:50 tech. Ótimo. E agora, um caso difícil. “Vocês têm desconto para organizações sem fins lucrativos?” Tev1 diz sales, e muito bem. Ele não está se prendendo à palavra billing. Está entendendo o que quero dizer. A segunda aba é de moderação. Três perguntas de sim ou não sobre a mesma mensagem: spam, dados pessoais, abusiva; uma mensagem de golpe com um número de cartão. Spam está em 0,97, dados pessoais em 0,95, e bloqueio qualquer coisa acima de 0,8. Agora, aqui vai um caso em que quero ser sincero. “Oi, sou o John. Ligue para mim neste número de telefone.” Dados pessoais está em 0,98, o que está certo. Mas Tev1 deu 0,66 para spam em uma mensagem amigável. Nimble

04:27 deu 0,49. É por isso que defini o limite em 0,8, e não em 0,5. A terceira aba é um roteador. Um modelo barato ou um caro. “Qual é a capital da Austrália?” Modelo pequeno. “Uma arquitetura de event sourcing tolerante a falhas.” Modelo grande. 0,85. É aqui que eu usaria isso nos meus próprios apps, porque você economiza dinheiro antes mesmo de fazer a chamada cara. A última aba é um avaliador. Uma resposta clara sobre fotossíntese recebe 2,03 de 3 em clareza. E a resposta confusa, com “IDK”

04:57 nela, recebe 0,81. E a correção também cai, de 0,84 para 0,44. Agora, vou mudar para Nimble. Mesmo chamado, mesma aba. É mais lento. E também indica sales com 0,89. Vamos ver por quê nos números. Agora, a parte que eu mais queria ver: escrevi 30 chamados de suporte, cada um com a equipe correta e indicando se o cliente estava irritado ou não. Este é meu pequeno teste, não um benchmark público. Então, considere-o um bom começo. Tev1 0.8b, o minúsculo, acertou 86,7%

05:30 na equipe, 76,7 na irritação, 235 milissegundos, e usa cerca de 900 megabytes da minha GPU. Tev1 4b acertou 100% na equipe, 83,3 na irritação, 470 milissegundos, e usa 4,7 gigabytes, tudo na GPU. Nimble acertou 96,7 na equipe e 96,7 na irritação. Então, é o melhor para identificar o estado emocional, mas leva 1,5 segundo por chamada. E, se você olhar aqui no Ollama PS, verá 40% de CPU e 60% de GPU. Esses 10 GB

06:02 não cabem na minha placa de 8 GB. Então, parte do processamento roda na CPU. Minha opinião para um laptop com 8 GB: Tev1 4B é o modelo para baixar. Se você tem 12 GB ou mais, vale a pena usar Nimble. E o 0.8B serve quando a memória está bem limitada. Mais uma coisa a observar. Se Tev 1 já estiver carregado e você chamar Nimble, recebi um erro 500 de falta de memória no host. Depois que Tev 1 foi descarregado, a mesma chamada funcionou. Então, em uma placa pequena, o Ollama parou o primeiro modelo. Agora, você pode perguntar: “Por que não pedir JSON a um modelo pequeno

06:33 normal?” Então, testei. Baixei o Qwen 3.54B, dei a ele os mesmos 30 chamados e forcei um schema JSON. E preciso ser sincero: ele acertou 96,7 na equipe e 96,7 na irritação, em 268 milissegundos. Então, em precisão e velocidade, igualou o Nimble e foi mais rápido. Então, o que o modelo de decisão oferece? Duas coisas. Primeiro, a probabilidade. Tev1 4B não errou nenhuma vez na equipe, mas o 0.8B errou quatro vezes, e em todos esses casos a probabilidade estava abaixo de

07:03 0,77. O único erro do Nimble foi com uma probabilidade de 0,83. Então, você pode dizer: “Se estiver abaixo de 0,9, encaminhe para uma pessoa.” Segundo, consistência. Enviei um chamado ao modelo de chat oito vezes. Em sete, ele disse billing; uma vez, disse tech, e o modelo de chat não informa nada sobre o nível de confiança. Essa é a diferença. Então, os pontos positivos: local, grátis, sem chave de API, respostas em algumas centenas de milissegundos, probabilidades que você pode usar para tomar decisões e a possibilidade de agrupar 64 perguntas em uma chamada. Os

07:33 pontos negativos: o formato da requisição é exigente. Se você adivinhar como eu fiz, vai encontrar aqueles três erros, embora as mensagens indiquem o que está faltando. Nimble não cabe em uma placa de 8 GB. Os modelos TEV 1 estão marcados como experimentais, e a página oficial diz que podem errar. Portanto, não deixe que sejam a única verificação em uma decisão de alto risco. Então, neste vídeo, vimos como instalar o Ollama, baixar TEV 1 e Nimble, fazer uma chamada ao endpoint system 1 e usá-los em um app. Se tiver interesse, pode testar por conta própria

08:03 o sistema também e me avisem como foi. No próximo vídeo, vou executar meu próprio modelo TEV treinado nos mesmos 30 tickets, comparando-o com Nimble e TEV 1. Vejo vocês em outro vídeo. Confiram o próximo vídeo. Obrigado.

Transcrição original

[00:00] All right. In this video, we will see two brand new models on Ollama, Tev 1 and Nimble. And you can see here that I type a support ticket and it tells me the team and how sure it is in about half a second. Now, mind you, these are not chat models. They don’t talk. They decide. And everything here is running on my local system on this 8 GB GPU laptop that I have here. If you watched my videos where I trained my own Jeff style model, this is the same idea and now Ollama supports it. Let’s go ahead and test this out. So, what is this? Ollama put out a blog post that says it now supports Jeff style decision models.

[00:34] These come from a company called Type-Safe and they call them System 1 models. The idea is really simple. You give it some text, they call that the state, and you give it questions and you get back an answer with a probability. No paragraph, no JSON that you have to hope is valid. There are three kinds of question choice, where you pick from a list, null, which is basically true or false, and score, where you place it on a rubric. And you can ask up to 64 questions about the same text in one call. Now, there are two models. Nimble is 9 billion parameters from Bespoke Labs and it is Apache 2.0. Tev 1 is from

[01:08] Together AI and it comes in a 4 billion and a 0.8 billion size. Both are fine-tuned from Qwen 3.5. They say Nimble gets a 75.7% on their public benchmark and Tev 1 4B gets 73.3. Those are their numbers, not mine. In a minute, we will run our own. First, if you do not have Ollama, go to ollama.com, click download and install it for your system. Really simple, on Windows, it is one installer. Now, this is one extra step that you need to do. These models need Ollama 0.35 or later, so open a terminal and say ollama {dash}

[01:42] {dash} version. Mine says 0.35.0, so we are right at the minimum. Now, go ahead and pull the models. I say ollama pull tev1, then ollama pull nimble, and ollama pull tev1:0.8b. I already have them, so this finishes in a second on your side. Nimble is a 9.5 GB file. So, it will take some time on your connection. And if I say all on my list, you can see all three here. Tev one is 4.5 GB. The small one is 811 MB. And Nimble is 9.5 GB. Remember that

[02:14] number because my card has only 8 GB. Now, let’s make our first call. It is not the chat endpoint. It is /v1/system1 on port 11434. I send a model, a state, and questions. So, what I have done is I have written a question called team, type choice, and I ask which team should handle this, and I hit enter, and we get an error. It says instructions must be a non-empty string. So, every question needs an instructions field. Fine, let’s add it. Run again. Now, it says choice criteria must map option keys to descriptions. So, for a

[02:46] choice, I need to give a criteria map, billing, payments, and refunds. Tech, bugs, and outages. Sales, pricing, and upgrades. Go ahead and run it again. And now a score question. I added and it says score criteria must be an array of descriptions. So, for a score criteria is a list, not a map. Third time is the charm. Now, if you look here, we get billing at 0.9975, the customer is angry at 0.87, and the urgency at 0.65. And the model wrote only four tokens. That is why this is fast. In Python, it is the same. I use

[03:19] requests, I post the model, the state, and the questions, and I read the answers. Six lines. I will put this file in the description. Now, I have put this into one small Gradio app with four tabs, so you can try it. First tab is ticket triage. I type, “My card was charged twice, and I want a refund now.” Click the side, and you can see it says billing at 0.99. The bars here are the probabilities. Tech and sales are basically zero. Now, let’s try the API one. The API returns a 500 error, production is down, and And goes to

[03:50] tech. Good. And now a hard one. Do you have a discount for nonprofits? Tev1 says sales really good. It is not matching the word billing. It is reading what I mean. Second tab is moderation. Three yes or no questions on the same message. Spam, personal data, abusive, a scam message with a card number. Spam is 0.97, personal data 0.95, and I block anything above 0.8. Now, here’s one where I want to be honest. Hi, I’m John. Call me on a phone number. Personal data is 0.98, which is right. But, Tev1 gave spam 0.66 for a friendly message. Nimble

[04:27] gave 0.49. That is why I set the threshold at 0.8 and not at 0.5. Third tab is a router. A cheap model or an expensive one. What is the capital of Australia? Small model. A fault-tolerant event sourcing architecture. Big model. 0.85. This is where I would use it in my own apps because you save money before the expensive call even happens. Last tab is a grader. A clean answer about photosynthesis gets 2.03 out of three on clarity. And the messy one with the IDK

[04:57] in it gets 0.81. And correctness drops, too, from 0.84 to 0.44. Now, let me switch to Nimble. Same ticket, same tab. It is slower. And it also says sales at 0.89. We will see why in the numbers. Now, the part I really wanted to see, I wrote 30 support tickets myself, each with a correct team and a correct angry or not. This is my small test, not a public benchmark. So, treat it as a good start. Tev1 0.8b, the tiny one, 86.7%

[05:30] on the team, 76.7 on angry, 235 milliseconds, and it takes about 900 megabytes of my GPU. Tev1 4b, 100% on the team, 83.3 on angry, 470 milliseconds, and 4.7 gigabytes all on the GPU. Nimble 96.7 on the team and 96.7 on angry. So, it is best at reading the mood, but it is 1.5 seconds per call. And if you look here at Ollama PS, it says 40% CPU, 60% GPU. That 10 GB

[06:02] does not fit my 8 GB card. So, part of it runs on the CPU. So, my take on an 8 GB laptop TV 14B is the one to pull. If you have 12 GB or more, Nimble is worth it. And the 0.8B is for when memory is really tight. Also, one gotcha. If Tev 1 is already loaded and you call Nimble, I got a 500 error out of memory on the host side. Once Tev 1 unloaded, the same call worked. So, on a small card, Ollama stopped the first one. Now, you might say, “Why not just ask a normal small

[06:33] model for JSON?” So, I tried it. I pulled Qwen 3.54B, gave it the same 30 tickets, and forced a JSON schema. And I have to be honest with you, it got 96.7 on the team and 96.7 on angry in 268 milliseconds. So, on accuracy and speed, it matched Nimble and beat it on speed. So, what does the decision model give you? Two things. First, the probability Tev 14B made no mistakes on the team, but the 0.8B did make four, and every one of them had a probability below

[07:03] 0.77. Nimble’s one miss was at 0.83. So, you can say, “If it is under 0.9, send it to a human.” Second, consistency. I sent one ticket to the chat model eight times. Seven times it said billing, once it said tech, and the chat model tells you nothing about how sure it was. That is a difference. So, the good things. Local, free, no API key, answers in a few hundred milliseconds, you get probabilities you can act on, and you can batch 64 questions in one call. The

[07:33] not-so-good things. The request shape is picky. If you guess it like I did, you will hit those three errors, though the messages do tell you what is missing. Nimble does not fit an 8 GB card. The TEV 1 models are marked experimental and the official page says it can be wrong. So, do not let it be the only check on a high-stakes decision. So, in this video we have seen how to install Ollama, pull TEV 1 and Nimble, make a call to the system 1 endpoint and use them in an app. If you’re interested, you can go ahead and try this out on your own

[08:03] system as well and let me know how it goes. In the next video, I will run my own trained TEV model on the same 30 tickets against Nimble and TEV 1. I will see you in another one. Check out the next video. Thank you.