Uma mensagem chega no seu celular dizendo que sua conta vai ser encerrada hoje e pedindo para você validar a senha. Não tem erro de português, não tem número estranho, não tem cara de golpe. É exatamente por isso que ele funciona.

A novidade desta semana é que esse tipo de julgamento deixou de ser exclusividade de modelo gigante na nuvem. Existe uma família de modelos feita só para isso, os modelos de decisão: em vez de conversar, eles recebem um texto e devolvem uma nota de certeza para cada pergunta que você fizer. Um deles, o d1 da Liquid AI, tem 3 bilhões de parâmetros, ocupa 3,7 GB e roda no seu computador, sem mandar a mensagem para servidor nenhum.

Aqui na CheriffAI a gente não repete o folheto do fornecedor. Este post mostra o passo a passo para rodar o modelo em casa e o que eu medi quando coloquei doze mensagens na frente dele — incluindo o golpe que ele deixou passar.

Como o modelo de decisão lê uma mensagem e devolve a nota de golpe. Medição feita em 19/11/2026, com as doze mensagens deste tutorial.

Antes de tudo: o que é um modelo de decisão

Um modelo de linguagem comum, tipo o que responde no chat, foi treinado para escrever. Você pergunta e ele produz texto, uma palavra de cada vez, escolhendo a próxima com base no que já escreveu.

Um modelo de decisão foi treinado para julgar. Ele não escreve nada. Você entrega o material (o texto da mensagem, um e-mail, uma nota fiscal) e uma lista de perguntas fechadas. Ele lê tudo uma vez e devolve, para cada pergunta, um número entre 0 e 1: a probabilidade de aquilo ser verdade.

Pense num porteiro treinado. Ele não conversa com o visitante; ele olha a identidade e responde "pode entrar" ou "não pode", com o quanto ele está seguro disso. Isso é o que um programa de computador precisa para decidir sozinho: um número para comparar, não um parágrafo para interpretar.

A vantagem prática é tripla: a resposta é instantânea (não existe texto para gerar, token por token), o resultado é o mesmo toda vez (não varia com criatividade), e a conta não tem custo por resposta quando roda na sua máquina.

O que você vai precisar

  • Um computador comum — 8 GB de memória já bastam para este modelo. Com placa de vídeo, ele fica mais rápido; sem placa, ele roda mais devagar (eu medi só com placa, e digo isso na seção de medição).
  • Cerca de 4 GB livres em disco para o modelo.
  • O Ollama, o programa que baixa e executa modelos locais. A versão usada neste tutorial foi a 0.40.16, de 9 de novembro de 2026 — versões mais antigas não conhecem este modelo (explico o erro mais comum no fim).

Passo 1 — Instalar o Ollama

Baixe o instalador na página oficial de download do Ollama e instale como qualquer outro programa. No Windows e no Mac é um instalador normal; no Linux é um comando de instalação que a própria página mostra.

Para conferir que deu certo, abra o terminal (no Windows, o PowerShell) e digite:

ollama --version

O esperado é aparecer algo como ollama version is 0.40.16. Se aparecer um número menor que 0.40.12, atualize antes de continuar: o modelo desta página não existe nas versões antigas.

Passo 2 — Baixar o modelo

ollama pull d1

São 3,7 GB de download, uma vez só. A página do modelo na biblioteca oficial do Ollama lista três tamanhos: o d1 padrão (3,7 GB, 32 mil tokens de contexto), o d1:2b (3,9 GB, 125 mil tokens de contexto) e mais um. Para o que vamos fazer aqui, o padrão serve.

Quando terminar, confira:

ollama list

Passo 3 — A primeira pergunta

Um modelo de decisão precisa de três coisas: o material a ser julgado, a pergunta e o critério — a descrição de quando a resposta é verdadeira e de quando é falsa. O critério é o mais importante de todos, e volto nele já já.

Salve o código abaixo num arquivo chamado decidir.py e rode com python3 decidir.py:

import json
import urllib.request

ENDERECO = "http://127.0.0.1:11434/v1/systemone"

REGRAS = {
    "golpe": {
        "type": "noul",
        "instructions": "Esta mensagem e uma tentativa de golpe ou fraude?",
        "criteria": {
            "verdadeiro": "A mensagem tenta enganar a pessoa para obter dinheiro, dados ou acesso a conta.",
            "falso": "A mensagem e uma comunicacao normal, sem tentativa de engano.",
        },
    },
}

MENSAGEM = "Banco Central: sua conta sera encerrada hoje. Acesse urgente e valide sua senha."

corpo = json.dumps({"model": "d1", "state": MENSAGEM, "questions": REGRAS}).encode()
pedido = urllib.request.Request(ENDERECO, data=corpo,
                                headers={"Content-Type": "application/json"})

with urllib.request.urlopen(pedido, timeout=120) as resposta:
    dados = json.loads(resposta.read())

print(dados["answers"]["golpe"]["noul"])

O resultado, na minha máquina, foi 0.9277554636789853. Um número entre 0 e 1, sem nenhum texto: chance alta de golpe. O campo state leva o material, questions leva quantas perguntas você quiser, e o tipo noul é o nome que a família usa para perguntas de sim ou não (a documentação do endpoint está em docs.ollama.com).

Passo 4 — Várias perguntas numa resposta só

Aqui está o pulo do gato: o modelo lê o material uma vez e responde todas as perguntas na mesma passada. Sai mais barato e mais rápido que perguntar duas vezes. Basta acrescentar mais uma regra ao dicionário:

REGRAS["pede_dinheiro"] = {
    "type": "noul",
    "instructions": "A mensagem pede dinheiro, Pix ou pagamento?",
    "criteria": {
        "verdadeiro": "Pede dinheiro, Pix, boleto ou pagamento.",
        "falso": "Nao pede nenhum pagamento.",
    },
}

Na mesma chamada, a mensagem do "Banco Central" recebeu 0.929 para golpe e 0.014 para pedido de dinheiro. Faz sentido: é golpe de captura de senha, não de transferência.

O que eu medi

Montei doze mensagens curtas, escritas por mim: seis golpes comuns no Brasil (falso bloqueio de cartão, prêmio com taxa de entrega, falso parente pedindo Pix, falso Banco Central, vaga de emprego pedindo documentos, prêmio acumulado pedindo código de SMS) e seis mensagens legítimas do dia a dia (reunião, entrega, consulta, fatura, almoço, condomínio). Rodei todas com as duas perguntas acima, no mesmo pedido.

  • Acertos: 11 de 12 (91,7%). Considerando "golpe" quando a nota passava de 0,5.
  • Tempo por resposta: 12,4 a 15,7 ms (média 12,9 ms), com 100 a 122 tokens de entrada e zero tokens de saída.
  • Separação entre os grupos: o golpe com menor nota ficou em 0,351 e a mensagem legítima com maior nota ficou em 0,024. Fora o caso que ele errou, nenhum golpe ficou abaixo de 0,55 e nenhuma conversa normal passou de 0,03.
  • Memória: 3,3 GB carregados, rodando 100% na placa de vídeo desta máquina. Não medi o mesmo modelo só em processador — quem não tem placa pode esperar algo mais lento, mas o número não foi medido aqui.
  • Repetibilidade: rodei a mesma mensagem três vezes e o número saiu idêntico até a décima quinta casa decimal (0.5543955464222635). Isso importa: um programa que decide sozinho precisa dar a mesma resposta para a mesma entrada.

O golpe que passou

O erro foi o mais brasileiro dos golpes: "Oi mãe, troquei de número, preciso que você faça um Pix de 980 reais agora". A nota de golpe ficou em 0,351 — abaixo da metade, então o programa classificou como conversa normal. Provavelmente porque, lendo só o texto, aquilo é mesmo uma conversa comum entre mãe e filho.

Mas a segunda pergunta salvou o dia: a nota de "pede dinheiro" foi 0,940. Ou seja, o modelo não sabia dizer se era golpe, mas sabia dizer com folga que alguém estava pedindo dinheiro. É por isso que se fazem várias perguntas: a nota de uma sozinha pode enganar; o conjunto das notas conta a história. Um bom programa usa esse cruzamento para mandar o caso duvidoso para um humano.

O critério manda mais que o modelo

Aqui está a parte que quase ninguém conta. A mesma mensagem, o mesmo modelo, mudando só a redação do critério, muda a resposta:

  • Com a regra escrita em português, o falso bloqueio de cartão recebeu 0,554.
  • Com a mesma regra escrita em inglês, a mesma mensagem recebeu 0,780.

Nada no texto mudou; mudou a descrição de "o que conta como golpe". A lição é direta: o critério que você escreve é a regra do jogo. Vale a pena escrever, testar com casos que você já sabe a resposta, e ajustar a redação. É trabalho de redação, não de programação — e é a parte que separa um sistema que funciona de um chute com número.

O que o fornecedor anuncia e o que sobra na prática

A Liquid AI informa que o d1-3B marca 48,57 no Decision Index 0.2.1, a melhor nota entre modelos de decisão abaixo de 10 bilhões de parâmetros, à frente do Decider 35B-A3B (47,11), que é doze vezes maior. É número do próprio fornecedor, publicado no anúncio do modelo aberto; o índice é público e pode ser consultado no space do Decision Index.

O que eu medi é outra coisa e serve de contraponto: num teste pequeno, feito por mim, com mensagens em português e critérios escritos por mim, foram 11 acertos em 12, com um erro justamente no golpe mais típico. Benchmark não é garantia de acerto no seu caso de uso — é ponto de partida. Quem vai colocar isso em produção testa com os próprios dados. É o mesmo cuidado que a gente aplica nas análises de modelo aqui no site.

Para comparar, o Google lançou em 11 de novembro o Gemini Decisions API, com o modelo gemini-decision-1: mesma ideia (perguntas fechadas, uma passada, zero tokens de saída), até 1.000 perguntas por pedido e latência declarada de 150 a 250 ms a US$ 0,10 por milhão de tokens de entrada. Detalhes no cartão do modelo. É rápido e não precisa instalar nada — mas é nuvem: a sua mensagem sai do seu computador. O d1 roda aqui dentro e responde em milissegundos sem mensalidade. Cada um serve a um caso.

Os erros comuns do caminho

1. "requires a newer version of Ollama"

Se o ollama pull d1 responder com erro pedindo uma versão mais nova, o seu Ollama é antigo (o mesmo erro aparece como 412 ou como um pedido para baixar a versão mais recente). Baixe o instalador de novo na página oficial e confira as notas de versão em github.com/ollama/ollama/releases. Foi na 0.40.12 que a família de decisão entrou na biblioteca.

2. O modelo responde vazio ou dá erro 404

Quase sempre é o nome errado: ollama pull d1 baixa o modelo, mas quem procura por d1:3b ou por outro apelido pode não achar. Use o nome que aparece no ollama list, e no código use exatamente "model": "d1".

3. O servidor não está no ar

O ollama pull funciona sem servidor, mas a consulta não: o endereço 127.0.0.1:11434 é o programa do Ollama atendendo na sua máquina. Se aparecer "connection refused", abra outro terminal e rode ollama serve. No Windows e no Mac o Ollama costuma ficar rodando no fundo depois de instalado.

4. A nota não faz sentido

Na maioria das vezes o problema está no critério, não no modelo. "É golpe?" é vago; "a mensagem tenta enganar a pessoa para obter dinheiro, dados ou acesso a conta" é um critério. Escreva os dois lados (o que conta como verdadeiro e o que conta como falso) e teste com casos que você já sabe a resposta certa.

Para que isso serve (e para que não serve)

Serve bem para: separar mensagens de clientes por assunto, decidir se um comentário precisa de moderação, classificar se um gasto parece fora do padrão, escolher qual atendente recebe um pedido, triar currículos por requisito objetivo.

Não serve para: escrever resposta, resumir texto, raciocinar em vários passos ou responder pergunta aberta. Ele não faz isso — e forçar a barra com um modelo de decisão só produz número sem significado. Para conversa, o caminho é um modelo de linguagem comum, como nos outros tutoriais da seção LLM.

Referências

Medições feitas na CheriffAI em 19/11/2026, com o modelo d1 servido pelo Ollama 0.40.16, 12 mensagens escritas por nós. Os tempos incluem uma consulta de duas perguntas por mensagem.