Usando LLMs locais para codificação com agentes

• Em meio à forte alta de preços dos modelos flagship em nuvem, um guia de como usar modelos locais para continuar tarefas de programação sem peso no orçamento
• Modelos locais não alcançam o desempenho dos modelos SOTA, mas a relação custo-benefício e o reforço por meio de um harness determinístico podem elevar a qualidade em até 6 vezes
• Para programação, o Gemma 4 oferece bom equilíbrio entre tarefas gerais e geração de código, além de suporte a Tools Use, Vision e Reasoning, sendo adequado para integração com o VS Code
• Procedimento completo de configuração para subir um servidor de modelos com o LM Studio e conectá-lo aos endpoints personalizados do VS Code Copilot e do Pi
• Se o hardware for insuficiente, é possível usar os modelos gratuitos do OpenRouter como alternativa; ainda assim, modelos locais seguem superiores em aspectos de operação offline e privacidade

---

Contexto do aumento de preços

• O GitHub Copilot migrou de um modelo por créditos para cobrança baseada em uso, e até os modelos que antes eram gratuitos deixaram de ser
• Como o GitHub atua como revendedor de tokens, o impacto do aumento de preços é ainda mais perceptível. Os modelos flagship vêm sendo lançados sem que o ganho de desempenho acompanhe o ritmo da alta de preços
  • O Google Flash 3.5 é 3 vezes mais caro que o Flash 2.5
  • O GPT 5.5 é 3 vezes mais caro que o GPT 5
  • O Claude, por já ser caro demais, teve o preço reduzido

A realidade e os pontos fortes dos modelos locais

• Modelos locais não chegam ao nível dos modelos SOTA como Claude, GPT e Gemini, mas há algumas nuances
  • Relação preço/desempenho: nos modelos em nuvem, o custo cresce exponencialmente em comparação com os ganhos de desempenho
  • Harness determinístico: com ferramentas e instruções melhores, é possível melhorar em até 6 vezes a qualidade de modelos mais fracos
  • Armadilha dos benchmarks: é difícil reduzir um modelo a um único número, e cada laboratório de IA tende a focar em benchmarks favoráveis a si; por isso, é preciso avaliar diretamente com a própria carga de trabalho
  • Efeito geopolítico: o que os laboratórios dos EUA liberam gratuitamente não é o melhor que existe. O gpt-oss-20b já está velho demais, e a Anthropic não publica pesos abertos. O Gemma 4 é o único modelo realmente sério, e vale acompanhar a liberação de modelos competentes de laboratórios chineses, como Qwen, Kimi e GLM
• Do ponto de vista do fenômeno de "brain rot", modelos mais fracos exigem maior intervenção do usuário, o que faz bem para a saúde mental/cognitiva
  • É como andar de bicicleta: mais lento, mas melhor para a saúde. No trabalho intelectual, "devagar é rápido"
  • O objetivo não é maximizar a automação a ponto de terceirizar o pensamento para a máquina. Não sacrifique sua relevância futura em troca de velocidade no curto prazo
  • Técnicas para lidar com modelos fracos também se aplicam a modelos grandes. Trabalhar com modelos fracos é como jogar no modo difícil; ao dominar isso, fica mais fácil aproveitar ferramentas maiores com eficácia

Escolha do modelo — Gemma 4

• Para programação, modelos chineses ocupam o topo do leaderboard do Hugging Face, incluindo Qwen, DeepSeek, Kimi, Llama e Gemma
• O Gemma 4 é composto por várias versões
  • E2B: o "E" significa edge. Com 2B de parâmetros, roda na maioria dos hardwares, mas há alto risco de alucinação ou de não concluir tarefas
  • E4B: tem o dobro do tamanho do E2B. Como é barato de baixar e configurar, é recomendado para começar
  • 12B: entende imagens nativamente sem decoder, sendo mais rápido para frontend e programação visual. Também oferece suporte nativo a áudio, embora isso pouco importe para cargas de trabalho de código
  • 26B A4B: arquitetura MoE (mixture of experts) em que apenas 4B dos 26B parâmetros são ativados. É mais inteligente que o E4B e adequado para GPUs com 8 a 12 GB de VRAM (modelo preferido do autor)
  • 31B: maior modelo de pesos abertos do Google. Não é MoE e exige muita VRAM. Em um AMD APU, roda a 1–2 TPS, nível impraticável
  • Variantes QAT (por exemplo, E4B QAT) usam menos memória mantendo qualidade quase igual. A Unsloth está fazendo otimizações adicionais

Componentes necessários para rodar um modelo local

• Para executar um modelo local, são necessários harness, modelo, runtime e gerenciador de modelos
  • Harness: VS Code Copilot, Copilot CLI, Pi etc. É o componente determinístico (código tradicional) que envolve o modelo, que por si só é probabilístico
  • Modelo: arquivo de pesos de rede neural profunda. Quantização (Q8, Q4 etc.) é um conceito análogo à resolução de imagem, e os formatos se distinguem entre GGUF, MLX e outros

• Runtime (motor de inferência)

  • Llama.cpp: runtime open source mais popular, capaz de carregar GGUF e MLX. Não tem relação com os modelos Llama da Meta e é usado internamente pelo LM Studio
  • MLX: runtime da Apple, usado em Macs com M1, M2 etc.
  • ONNX Runtime: baseado em transformers.js, permite execução no navegador via WebGPU e também suporta mobile em iOS e Android
  • vLLM: projeto open source vindo da UC Berkeley, voltado principalmente a servidores de alto desempenho, com configuração mais complexa

• Gerenciador de modelos

  • Ollama: começou como CLI de terminal e depois ganhou uma GUI leve. É um wrapper em Go sobre o Llama.cpp. Open source
  • LM Studio: gratuito, mas não é open source. Oferece SDK (Python/TypeScript) e API REST, permitindo controlar recursos específicos de modelos locais, como carregamento dinâmico
  • Jan: alternativa gratuita e open source semelhante ao LM Studio, mas com menos recursos
  • Suporte à API compatível com OpenAI é o recurso central, pois muitos aplicativos de IA funcionam sobre esse padrão de fato

Configuração do servidor no LM Studio

• Inicie o servidor pelo botão "Developer" usando o toggle. Ao rodar em outra máquina ou contêiner, habilite Serve on Local Network; para acesso por app web, ative Enable CORS
• O LM Studio usa carregamento JIT (Just In Time), ou seja, o modelo é carregado no momento da requisição. É possível controlar por TTL por quanto tempo ele fica em memória
  • Cold start: se o modelo não estiver carregado, a primeira requisição leva cerca de 10 a 30 segundos extras, de forma semelhante ao cold start do AWS Lambda. Isso afeta a métrica TTFT (Time To First Token)
  • Janela de contexto curta: na configuração padrão, a janela de contexto pode ter apenas 4k, sendo necessário ampliá-la manualmente. A maioria dos modelos do VS Code Copilot tem 200k a 400k

• Comprimento de contexto e configuração de memória

  • Exigência de VRAM por tamanho de contexto: 262144 (máximo) = 25,74 GB, 4096 (padrão) = 18,16 GB, 150000 (preferência do autor) = 22,45 GB
  • Para programação, o prompt de sistema consome de 20k a 40k tokens, então é necessário carregar pelo menos 100k tokens
  • Se o contexto for grande demais, a velocidade de geração de tokens cai. O ponto ideal é quando o harness comprime automaticamente o contexto
  • O ideal é executar todas as camadas do modelo na GPU, com recomendação de maximizar o slider de GPU Offload. Rodar camadas na CPU exige cópia de dados entre CPU e GPU, exceto em Apple Silicon (UMA)

• Truque de quantização do cache KV

  • Defina K Cache Quantization Type como Q8_0 e V Cache Quantization Type como Q4_0
  • A ideia é manter as chaves em resolução maior que os valores. Com isso, o requisito de memória da GPU cai de 28,75 GB para 22,45 GB
  • É essencial salvar a configuração. Se não salvar, ela volta ao padrão no próximo carregamento de modelo
  • O VS Code Copilot não tem o conceito de solicitar uma janela de contexto customizada, então o LM Studio precisa lembrar a configuração ao atender chamadas da API REST
• Se o TPS ficar abaixo de 10, o uso para programação se torna difícil de tolerar, pois se perde tempo demais esperando o modelo

Conectando um endpoint personalizado ao Copilot

• É necessário usar uma versão recente do VS Code (na época da escrita, 1.122.1). O caminho é: seletor de modelo → engrenagem → "Add Models" → "Custom Endpoint"
  • Defina um nome (por exemplo, "Local LM Studio"), informe a API Key (ou apenas Enter se não houver), e escolha o formato da API de inferência
  • Entre os três tipos de API, apenas Chat Completions funciona bem
• No JSON de configuração, defina manualmente url, maxInputTokens, maxOutputTokens etc.
  • Configure corretamente a opção thinking (suportada pelo Gemma 4)
  • O array supportsReasoningEffort varia conforme o modelo, e a versão 26B permite controle mais refinado que a E4B
  • Para 4B, use maxInputTokens 64000/maxOutputTokens 16000; para 26B MoE, 100000/50000
• No primeiro prompt, o Copilot envia um enorme prompt de sistema e definições de ferramentas, causando atraso de 2 a 5 minutos na primeira interação. São cerca de 30 segundos para carregar o modelo e aproximadamente 5 minutos para processar a entrada do prompt
  • Isso acontece apenas uma vez por sessão, pois o LM Studio aplica cache de prompt. Pi não sofre com isso porque seu prompt de sistema é menor

• Teste rápido e ambiente

  • Demonstração de desempenho do Gemma 4 26B A4B gerando um jogo da cobrinha com prompt one-shot, sem AGENTS.md nem SKILL
  • Ambiente usado: Lenovo Thinkpad L16 Gen 2, AMD Ryzen 7 PRO 250 APU, 64 GB DDR5 (5.600 MT/s), Aurora Linux. O autor considera que 32 GB já seriam suficientes

Configuração do Pi

• Conectar ao servidor local do LM Studio é simples, e a configuração de contextWindow combina melhor com a forma como o LM Studio é configurado
• Defina baseUrl como http://host.containers.internal:1234/v1 e api como openai-completions
  • Para 4B, configure contextWindow 64000/maxTokens 16000; para 26B MoE, 150000/50000, além de mapear thinkingLevelMap

Resumo de vantagens e desvantagens dos modelos locais

• Vantagens: funcionamento offline, alta privacidade e respostas rápidas, dependendo do hardware, fluxo de trabalho, modelo e configuração
• Desvantagens
  • Modelos de pesos abertos não são tão inteligentes quanto modelos flagship proprietários, mas um harness com guardrails adequados (lint, testes, AGENTS.md) pode melhorar bastante a precisão na programação
  • Rodar o LLM na mesma máquina provoca queda de desempenho por causa da carga de hardware
  • Cold start, processamento inicial do primeiro prompt (cache miss) e alto custo inicial de hardware
• Depois de se acostumar com o LM Studio, é possível usar diretamente o Llama.cpp sem GUI. A maioria dos harnesses suporta endpoints personalizados, então dá para integrar com LLMs locais

Alternativa com modelos gratuitos do OpenRouter

• O OpenRouter é um serviço unificado de API e roteamento que expõe centenas de modelos com um único endpoint e uma única conta
• Copilot, Zed e Pi oferecem suporte nativo ao OpenRouter; basta gerar um token de API e conectar
  • Para evitar estouro de custos, crie guardrails personalizados com limite de US$ 1/mês e adicione à allowlist apenas os modelos gratuitos
  • Ao criar uma nova chave de API, recomenda-se definir max credit como 0
• Desvantagens: prompts e dados podem ser usados em treinamento (há configuração ZDR), exige conexão com a internet, e o OpenRouter pode deixar de oferecer modelos gratuitos
• Vantagens: não requer download nem configuração local, e o computador não fica lento durante o uso

• Atualização de 2026-06-09

  • Adoção do Deepseek V4 Pro. Desempenho quase no nível do Claude Opus 4.8, com janela de contexto 5 vezes maior e preço cerca de 17 a 86 vezes menor
  • Havia uma diferença de cerca de 3 vezes no preço entre Pi e OpenRouter, porque o OpenRouter estava enviando as requisições para um endpoint mais caro (GMICloud)
  • O autor abriu uma conta diretamente no Deepseek para tarefas complexas. Para tarefas simples, entendimento de comportamento e situações em que a privacidade importa, modelos locais continuam sendo a primeira opção

[click]

No fim, a conclusão foi que, depois de usar modelos locais, acabei indo para o DeepSeek v4 Pro.
Também não é fácil ficar trocando de modelo toda vez que vou trabalhar, então até a ideia de usar local só para tarefas simples acabou sendo difícil.

[kirinonakar]

Não precisa ser necessariamente local; há muitas alternativas de assinatura baratas, como opencode, ollama e cursor.

[kurthong]

Na era dos grandes LLMs, eu tenho usado um plugin feito por mim. Já cheguei a apresentar no GN SHOW uma vez, e acho que criar algo sob medida e usar desse jeito também é uma boa opção.

https://github.com/hang-in/tunaLlama