LLMs locais de pequeno porte

Entre 2025 e 2026 a conversa sobre LLMs locais deixou de ser hobby e virou infraestrutura. As razões se acumularam: a qualidade dos modelos abertos de pequeno porte subiu o bastante para igualar ou superar APIs mid-tier em tarefas do dia a dia, o custo de tokens em cloud tornou-se um problema real para quem processa milhões deles por dia, e a latência de uma ida e volta de rede virou o calcanhar de aquiles de loops agênticos que encadeiam dezenas de chamadas pequenas. O resultado é que “rodo um modelo na minha máquina” deixou de ser curiosoidade de entusiasta e virou decisão de arquitetura, com ferramentas (Ollama, llama.cpp), formatos (GGUF, quants K e IQ) e uma régua clara de quanto cada faixa de tamanho entrega e onde ela fica aquém.

Este conjunto de notas fotografa esse estado. Cada faixa de tamanho tem seu próprio equilíbrio entre capacidade e custo, e a régua útil não é “qual modelo é o melhor” e sim “qual modelo faz sentido para esta tarefa, neste hardware”. A faixa de 8B e menores é onde a privacidade vira um caso de uso estrutural e a edição de texto ganha throughput. A faixa de 27B a 30B é onde o coding agêntico sério e a escrita que humanos vão ler ficam genuinamente competitivos com cloud mid-tier. As tarefas transversais que atravessam todas as faixas, RAG, fala, visão, têm dinâmicas próprias. E o roteador híbrido é o que costura tudo, decidindo por tarefa quando a resposta é local ou cloud, e é onde mora a maior parte da economia real.

O que mudou, em uma régua

A primeira coisa que se aprende sobre modelos locais é que “tamanho do modelo” não predefine qualidade, mas predefine fit. Uma régua empírica simples governa quase tudo: na quantização Q4_K_M, hoje o ponto de equilíbrio da indústria, consomem-se cerca de 0,6 a 0,8 GB por bilhão de parâmetros. Essa única regra diz o que cabe:

• 4 a 8 GB de VRAM aguenta modelos de 3B a 7B (Phi-4-mini, Qwen3 8B, Gemma 3 4B).
• 12 a 16 GB acomoda 7B a 14B (Qwen 2.5 14B, Gemma 3 12B), e é onde uma GPU intermediária começa a ficar oeconômica.
• 24 GB é o território de 27B a 35B-A3B (Qwen 3.5 27B denso, Qwen3-Coder 30B-A3B, Gemma 3 27B), e é onde uma RTX 3090 usada ou uma 4090 deixam de ser luxo.
• 48 GB ou mais abre a classe 70B, que compete com GPT-4 mid-tier.

A consequência operacional dessa régua é mais importante do que a memória dos números: a escolha do modelo começa pelo hardware que se tem, e o que se pede ao modelo vem depois. Inverter essa ordem, escolher um modelo e só então descobrir que ele não cabe, é o erro mais comum de quem migra do mundo da API para o local.

Uma segunda regra complementa a primeira e ajuda a localizar a fronteira do útil. O throughput de geração, em tokens por segundo, aproxima-se da largura de banda de memória da placa dividida pelo tamanho quantizado do modelo. Uma 3090 com 936 GB/s rodando um 13B em Q4 dá um teto de pouco mais de 100 tok/s na teoria, e a medição real fica em torno de um terço disso depois de sampling e overhead de attention. A mesma lógica explica porque um Apple M2 Max com 400 GB/s de banda unificada roda os mesmos modelos em velocidades comparáveis, apesar de uma arquitetura completamente diferente: a largura de banda de memória, não os FLOPS, é o que decide velocidade de geração. Para agência e interatividade, isso é o que importa.

A quantização como variável escondida

A maior parte da discussão sobre “qual modelo usar” passa por cima de uma variável que merece entrar na frente: a quantização. Um 27B em Q4_K_M não é a mesma coisa que o mesmo 27B em Q3_XXS, e um teste comparativo de 2026 mostrou isso de forma contundente. O mesmo Qwen 3.5 27B, na mão de dois quantizadores diferentes no mesmo nível nominal (Q3_XXS), variou de 5% de erro numa tarefa de migração estruturada para 100% de erro com colapso de categoria. O modelo é o mesmo; o que muda é como os bits foram alocados por camada.

A régua prática para 2026 é a mesma que se consolidou em 2024, só mais clara: Q4_K_M é o ponto de equilíbrio recomendado para a maioria dos casos. Reduz o tamanho do modelo em aproximadamente 75% com perda de qualidade moderada. Se há folga de VRAM, Q5_K_M ou Q6_K compram o resto da qualidade; se não há absolutamente como caber, Q3_K_M aperta o pé com custo mais alto. Q2_K é o último recurso, com perda de qualidade material. A família IQ (importance-weighted quants, como IQ3_XXS e IQ4_XS) é o estado da arte para encaixar modelos em VRAM apertada, com qualidade entre Q3 e Q4 padrão num footprint menor, mas a escolha do quantizador importa tanto quanto o nível, e builds mal feitos podem produzir modelos inúteis.

A observação seguinte, menos óbvia, é que combinar a régua de tamanho com a quantização gera uma escolha contraintuitiva: em um mesmo orçamento de VRAM, um modelo maior em Q4 tipicamente vence um modelo menor em Q8. Qwen 2.5 14B em Q4 ocupa 8 GB, e costuma superar Qwen 2.5 7B em Q8, que ocupa 7,5 GB. A exceção é quando o objetivo é saída estruturada perfeita (JSON, slugs, paths), onde quants mais agressivos às vezes degradam muito mais do que o esperado, e vale testar antes de confiar.

A arquitetura que emerge: roteamento por tarefa

O padrão mais repetido nas fontes de 2026, e que organiza as notas a parte, é que ninguém escolhe mais entre local e cloud. Isso foi a pergunta de 2024 e deixou de ser. A pergunta de 2026 é “para esta tarefa, desta vez, quem responde?”, e a resposta é uma configuração, não um modelo. As duas pontas do stack rodam falam o protocolo OpenAI-compatible, então rotear entre elas é uma troca de base URL numa variável de ambiente, não um rework arquitetural.

A divisão do trabalho que emerge nas equipes serias é estável o bastante para virar regra:

• Local para dados sensíveis, alto volume e baixa complexidade por item. Logs com IPs internos, documentos confidenciais, transformações de texto repetitivas em pipelines ETL, mensagens de commit a partir de diffs, autocomplete de código em repositórios proprietários. O local ganha não porque é mais esperto, mas porque a privacidade é estrutural e o custo por item é zero.
• Local para loops agênticos latência-críticos. Agentes que encadeiam dezenas de chamadas pequenas sofrem com o custo de latência de rede em cada passo. Rodar contra um modelo local derruba o tempo por step de centenas de milissegundos para dezenas, e isso compõe rápido em sessões longas.
• Cloud para raciocínio difícil, contexto massivo e novidade pós-cutoff. Onde a qualidade de frontier ainda manda, onde o que se pede não cabe no contexto, e onde a pergunta depende de conhecimento que não estava no treino, a API continua sendo a ferramenta certa. Não há vergonha nisso; é reservar o mais caro para onde ele ganha sua manutenção.

O relato de engenharia mais direto sobre isso, registado por uma equipe que mistura local e cloud há um ano, resume a economia: “sem o stack local, o gasto em cloud seria 10 a 30 vezes maior. Com ele, o gasto em cloud é nas coisas em que esse gosto claramente ganha sua manutenção”. É a leitura madura: não é local ou cloud, é local e cloud com roteamento deliberado, e é onde mora o unlock que a maioria das equipes ainda está dormindo.

Onde ler com cuidado

O mesmo caveat que atravessa a pesquisa de agentes em DevOps atravessa esta: a maior parte da evidência sobre o que modelos locais fazem bem vem de blogues de entusiastas, perfis de usuários avançados, documentação de runtime (Ollama, llama.cpp, vLLM) e benchmarks publicados pelos próprios criadores de modelos (Qwen, Microsoft para Phi, Google para Gemma). São autoridade legítima para afirmar “este modelo existe, pesa X, roda em Y hardware”, e autoridade quase nenhuma para afirmar “este modelo é confiável na sua tarefa específica”. Os poucos números medidos por terceiros vêm de testes comparativos de uso real, e mesmo esses tem viés de amostra pequena, hardware específico e quants específicos.

A leitura útil aqui é a mesma daqui das outras pesquisas: tratar a lista de capacidades como real e a promessa de generalização como ainda não demonstrada. Que o Qwen3-Coder roda em 12 GB com offload MoE é fato. Que ele “resolve suas tarefas de coding agêntico com confiança” é asserção que merece validação no seu próprio workflow por uma tarde antes de virar aposta. A régua que se repete nas fontes mais honestas é: rode no seu trabalho real por uma tarde. Peça para ele corrigir um bug seu de verdade, escrever um email que você mandaria de verdade, resumir um documento que você conhece a fundo. Confira se o resumo inventou algo. Esse teste caseiro vale mais que qualquer leaderboard.

Palavras-chave

Conceitos: LLMs locais, pequenos modelos, quantização, Q4_K_M, IQ quants, MoE offload, throughput, largura de banda de memória, roteamento híbrido, OpenAI-compatible, GGUF Famílias de modelos: Qwen 3.5, Qwen3-Coder, Phi-4-mini, Gemma 3, Mistral Small, Llama 3.1 8B, Devstral Hardware: RTX 3090, RTX 4090, RTX 4070, RTX 3060 12GB, Apple Silicon, VRAM, unified memory Ferramentas: Ollama, llama.cpp, vLLM, LM Studio, Open-WebUI, huggingface-cli