Antes da lista, o alerta que evita a frustração mais comum: "caber na VRAM" não é "rodar bem". Além dos pesos, a memória precisa acomodar cache KV (que cresce com o contexto), buffers de execução e o overhead das ferramentas de agente. Um GGUF de 15,8 GB numa GPU de 16 GB sobra tão pouco que o contexto útil desaba. E o detalhe técnico que confunde: nos modelos MoE, os parâmetros ativos afetam a velocidade por token, mas os pesos totais continuam contando para a VRAM. Com isso em mente, o mapa por faixa:
8 GB: o ponto de entrada honesto
Comece por: Qwen3.5-9B em Q4_K_M (cerca de 6 GB). Melhor equilíbrio da faixa para conclusão de código, depuração e scripts. Não espere navegar repositórios grandes ou sustentar fluxos agentivos longos: o contexto prático fica entre 8K e 16K tokens. Alternativa: Gemma 4 E4B, mais leve, com a queda de qualidade que o tamanho cobra (no LiveCodeBench v6, 52,0 contra 72,0 do irmão 12B). O veterano Qwen2.5-Coder 7B ainda funciona, mas perdeu o lugar de recomendação automática: os 9B mais recentes trazem raciocínio e suporte a agentes melhores.
12 GB: o dilema da precisão
Comece por: Gemma 4 12B em Q5/Q6 (LiveCodeBench v6: 72,0): o melhor equilíbrio da faixa, com precisão saudável e contexto prático de 16K a 32K. Alternativa: Devstral Small 2 24B com quantização agressiva (IQ3_XS a IQ3_M, cerca de 9,9 a 10,7 GB): 68,0% no SWE-bench Verified e capacidade de trabalho multi-arquivo, ao custo de rodar em aproximadamente 3 bits. O dilema central do 12 GB é esse: um 12B de alta precisão ou um 24B de baixa precisão, e não existe resposta universal: depende se o seu uso pune mais erros ou mais miopia de contexto.
16 GB: a faixa da programação agêntica
Comece por: Devstral Small 2 em IQ4_XS (cerca de 12,8 GB): a escolha equilibrada para repositórios e programação agêntica, sobrando espaço para contexto e execução. Alternativa: gpt-oss-20b, com quantização MXFP4 nativa (21B totais, 3,6B ativos): projetado para rodar em 16 GB, com raciocínio configurável, chamadas de funções e saídas estruturadas. Para quem vive de código agêntico, Qwen3-Coder-30B-A3B em Q3_K_M (30,5B totais, 3,3B ativos por token) cabe na casa dos 14-15 GB: possível, apertado.
24 GB: o território dos agentes de código
Comece por: Qwen3-Coder-30B-A3B em Q4_K_M (cerca de 18 GB) numa RTX 4090: otimizado para agentes de programação, compreensão de repositórios, ferramentas e contexto longo (prático até 32K-64K). Alternativa: Qwen3.8-27B em Q4_K_M para raciocínio mais amplo junto com o código (LiveCodeBench v6: 90,3; SWE-bench Pro: 61,7). A Gemma 4 26B A4B cobre cargas mistas de raciocínio e código. E a armadilha da faixa: o Qwen3-Coder-Next de 80B não cabe: mesmo com apenas 3B ativos por token, os pesos exigem quantizações extremas (1 a 2 bits) em 24 GB, competindo com o próprio contexto. Modelo grande com memória espremida perde para modelo médio respirando.
A avaliação usada nos testes cobre seis tarefas reais: conclusão sem quebrar a API pública, depuração com causa-raiz, refatoração multi-arquivo, geração de testes que reproduzem a falha, navegação em repositório sem inventar caminhos e o ciclo de reparo agentivo (editar, testar, corrigir, retestar). A conclusão que vale para qualquer stack: a infraestrutura do agente pesa tanto quanto o modelo, e o benchmark mais honesto é o seu: teste os candidatos com o mesmo conjunto de tarefas do seu dia a dia antes de decidir.
O contexto prático (e o custo Brasil da conta)
Contextos anunciados de 128K/256K são marketing quando o assunto é rodar local: o plano realista por faixa é 8K-16K (8 GB), 16K-32K (12 e 16 GB) e 32K-64K (24 GB). O argumento econômico para o desenvolvedor brasileiro: a assinatura das ferramentas de código em nuvem cobra em dólar todo mês, enquanto a GPU que você já tem roda o assistente a custo marginal, com o código saindo da máquina (relevante para código proprietário e para o sigilo de cliente). Para as decisões de arquitetura de IA na sua operação (do modelo ao agente que atende o cliente), a automação com IA da M&C e os agentes de IA cobrem a camada de negócio; e a leitura do modelo de decisão Laya mostra a outra ponta da IA local: a das decisões, não do código.