Melhor LLM para programação em 2026: 9 modelos ranqueados

Em fevereiro de 2025, o Claude 3.7 Sonnet marcou 62,3% no SWE-bench Verified, ou 70,3% com scaffold customizado, enquanto o melhor modelo open weight do momento, DeepSeek-R1, reportou 49,2% em seu paper.

Era um gap de 13 a 21 pontos, dependendo de quão generoso você era com o scaffolding.

Em setembro de 2026, o quadro independente da Vals AI para o SWE-bench Verified mostra o Claude Opus 5 com 97,0% e o DeepSeek V4 Pro 0813 (open weight) com 96,4%, e a Vals arquivou o benchmark porque saturou.

A fronteira migrou para avaliações agentic mais difíceis como SWE-bench Pro e Terminal-Bench 4.0, os open weights alcançaram os benchmarks antigos, e a pergunta "melhor LLM para programar" virou "melhor para quê, em qual hardware e por qual preço".

Eu respondo essa pergunta para os 9 modelos que realmente considero usar hoje, e o resumo é que o Claude Opus 5.5 é aquele com o qual a maioria dos times deve começar.

Um aviso antes do ranking: este artigo é sobre os modelos em si, não as ferramentas em volta deles. Se você quer a comparação entre Cursor, Copilot e Windsurf, nosso apanhado dos melhores assistentes de IA para código em 2026 cobre isso.

Resumo: os melhores LLMs para programação em setembro de 2026

O Claude Opus 5.5 hoje é tanto o modelo mais forte nos principais benchmarks de código quanto aquele em que a maior parte dos devs deve padronizar; o Claude Fable 5.1 é a opção para escalar quando o trabalho tem horizonte mais longo; e o Qwen3.8-27B é o open weight para rodar em uma única GPU. Aqui estão as melhores escolhas por objetivo:

• Melhor no geral para programação agentic: Claude Opus 5.5 (Anthropic), 89,9% no SWE-bench Pro e 66,4% no Terminal-Bench 4.0, a US$ 4 de entrada e US$ 20 de saída por milhão de tokens.
• Melhor para trabalhos de horizonte mais longo: Claude Fable 5.1 (Anthropic), 81,2% no SWE-bench Pro e a maior nota no Terminal-Bench 2.1 no Artificial Analysis (91,4%), a US$ 10 de entrada e US$ 50 de saída por milhão de tokens.
• Melhor modelo da OpenAI para código: GPT-6 Astra (OpenAI), primeiro no ranking de agentes do Terminal-Bench 4.0 no tbench.ai com 58,2% e empatado com o Opus 5.5 em 59,6% na execução do Artificial Analysis.
• Melhor custo-benefício de um laboratório de fronteira: Gemini 3.8 Flash (Google), 89,4% no Terminal-Bench 2.1 por US$ 0,75 de entrada e US$ 3,75 de saída por milhão de tokens até 31 de dezembro de 2026.
• Melhor open weight via API: DeepSeek V4.1 Flash, licença MIT, 90,6% no Terminal-Bench 2.1, US$ 0,60 por milhão de tokens de saída fora do pico.
• Melhor open weight que você não consegue rodar em casa: Kimi K3 (Moonshot AI), 2,8 trilhões de parâmetros, 88,3% no Terminal-Bench 2.1.
• Melhor modelo local em uma GPU de 24 GB: Qwen3.8-27B (Alibaba), Apache 2.0, 73,0% no Terminal-Bench 2.1, 16,5 GB em UD-Q4_K_M.
• Melhor modelo local para uma workstation de 128 GB: Laguna S 2.1 (Poolside), 118B parâmetros com apenas 8B ativos, contexto de 1M.
• Melhor modelo local rápido para hardware mais antigo: Qwen3-Coder-Next, 80B no total mas 3B ativos, 70,6% no SWE-bench Verified.

Toda a pontuação acima é publicada pelos vendors, salvo indicação em contrário. O restante do artigo explica como cheguei a essas escolhas e onde cada uma delas falha.

Por que esta lista fala de modelos e não de assistentes de código?

Um LLM para código é o modelo que lê seu prompt e escreve tokens, enquanto um assistente de código é a armação (harness) que fornece arquivos, executa comandos e mostra os diffs.

Claude Code, Codex, Cursor, GitHub Copilot e Windsurf são harnesses. Claude Opus 5.5, GPT-6 Astra e Qwen3.8-27B são modelos — e o harness muda a pontuação mais do que a maioria espera.

O próprio post de lançamento do Claude Opus 4.8 da Anthropic deixa isso concreto em uma nota de rodapé.

Ele reporta a pontuação de Terminal-Bench 2.1 de cada modelo no harness público Terminus-2 e observa que o número do GPT-5.5 sobe para 83,4% dentro do Codex CLI da OpenAI. Mesmos pesos, encanamento diferente, resultado diferente.

É por isso que os rankings abaixo vêm com o harness anexado sempre que possível. Se você é novo em como esses modelos funcionam por baixo do capô, nosso guia sobre o que é um LLM (large language model) é uma leitura de 15 minutos que facilita acompanhar o resto.

Quais benchmarks realmente importam para LLMs de código?

Os benchmarks que importam para LLMs de código em 2026 são SWE-bench Pro, Terminal-Bench (versões 2.1 e 4.0) e, para os open weights que ainda reportam, LiveCodeBench v6. O SWE-bench Verified foi o padrão por 2 anos e hoje está saturado demais para separar os modelos do topo.

Antes de ranquear qualquer coisa, aqui vai o que cada número nas entradas dos modelos significa.

SWE-bench Verified está saturado

O SWE-bench Verified é um conjunto de 500 issues do GitHub validadas por humanos em repositórios Python populares; o modelo recebe o repo e o texto da issue e precisa produzir um patch que passe nos testes unitários ocultos.

A OpenAI introduziu o subconjunto Verified em 2024 porque o SWE-bench original continha tarefas com issues subespecificadas ou testes quebrados. Ainda é o número mais citado em código — e esse é exatamente o problema.

O ranking da Vals AI, que roda todo modelo com o mesmo agente mínimo apenas em bash, colocou o Claude Opus 5 em 97,0%, o DeepSeek V4 Pro 0813 em 96,4% e o GPT-5.6 Sol em 96,2% na atualização de 1º de setembro de 2026, e então marcou o benchmark como arquivado.

Quando 3 modelos de 3 labs ficam a menos de um ponto entre si e a 4 pontos do teto, a métrica para de discriminar. Eu ainda cito para modelos mais antigos e menores porque é o número que consta nos cards, mas não ranqueio por ele.

SWE-bench Pro é o substituto mais difícil

O SWE-bench Pro, mantido pela Scale AI, contém 1.865 tarefas em 41 repositórios profissionais, com um split público de 731 tarefas e conjuntos privados reservados. Em 22 de setembro de 2026, a Scale lançou o SWE-Bench Pro V2, que reduz o conjunto público para 642 tarefas após descartar 89 consideradas inválidas, então verifique em qual versão a pontuação foi rodada.

A correção média toca 107,4 linhas em 4,1 arquivos, e os repositórios abrangem várias linguagens, não só Python. Quando o paper do SWE-bench Pro saiu, em setembro de 2025, os melhores modelos marcavam por volta de 23%.

Um ano depois, o system card do Fable 5.1 reporta 81,2% para o Fable 5.1 e 79,2% para o Opus 5, e a tabela de lançamento do GPT-5.6 mostra 64,6% para o GPT-5.6 Sol. Três semanas após o card do Fable, o system card do Opus 5.5 empurrou o topo para 89,9%.

São execuções do vendor, com média de 5 tentativas no esforço máximo no caso da Anthropic. O ranking público da própria Scale fica meses atrás dos números dos vendors, então trato o número do vendor como teto e o leaderboard como piso.

Terminal-Bench 2.1 e 4.0

O Terminal-Bench dá ao modelo um shell vivo dentro de um container e uma tarefa como “treine este modelo”, “corrija este build” ou “recupere este arquivo corrompido”, e depois avalia os artefatos produzidos.

O release 2.1 traz 89 tarefas curadas em engenharia de software, administração de sistemas, processamento de dados e segurança, e o Artificial Analysis pontua com o harness Terminus 2 como pass@1, média de 3 execuções. É o número único que mais peso coloco para quem constrói ou usa agentes de código.

O Terminal-Bench 4.0, hospedado por Stanford, Harbor e o Laude Institute em tbench.ai, é o novo conjunto de fronteira.

O system card do Opus 5.5 da Anthropic o descreve como 66 tarefas com viés para biologia computacional, simulação física, CAD, provas formais e trabalho de performance em GPU, com timeouts mais longos, de modo que o harness importa menos.

No ranking de agentes do tbench.ai, o GPT-6 Astra ainda lidera com 58,2% e o Claude Fable 5.1 vem com 57,9%, mas o Claude Opus 5.5 ainda não tem entrada de agente lá. Em execuções no nível de modelo, o Artificial Analysis tem Opus 5.5 e Astra empatados em 59,6%, e a Vals AI coloca o Opus 5.5 em primeiro com 61,6%, embora a Vals observe que esse número cai para 53,5% se você contar como falhas as tarefas que seus guardrails repassaram para um modelo reserva. É aqui que a fronteira se separa do pelotão.

LiveCodeBench v6 flagra memorização

O LiveCodeBench, introduzido no paper de 2024 de Jain e colegas, coleta continuamente problemas do LeetCode, AtCoder e Codeforces, com carimbo de data para que você avalie o modelo apenas em problemas publicados após o cutoff de treinamento.

A versão 6 é a janela atual no ranking público. Ela mede raciocínio algorítmico, não engenharia em escala de repositório, por isso continuou útil para entrevistas e estruturas de dados.

Os labs de fronteira em sua maioria pararam de reportá-lo em 2026, então os números que tenho são de modelos open weight: o preview de abril do DeepSeek V4 Pro com 93,5%, o Qwen3.8-27B com 90,3% e o Kimi K2.6 com 89,6%. O Gemini 3.1 Pro reporta uma métrica relacionada, um Elo no LiveCodeBench Pro de 2.887.

Como leio uma tabela de benchmarks do vendor

Uma tabela de benchmarks do vendor é um melhor caso: o harness dele, o nível de esforço dele, o número de tentativas dele. Eu procuro uma replicação independente no Artificial Analysis, na Vals AI ou no ranking do tbench.ai antes de acreditar em um gap menor que 3 pontos.

Nosso guia de benchmarks de LLM e como comparar modelos percorre os principais rankings, e nosso texto sobre o que o MMLU mede é um bom lembrete de que um benchmark de conhecimento quase nada diz sobre se um modelo consegue consertar um teste flaky.

Para construir seu próprio harness de avaliação, nosso guia de métricas e metodologias de avaliação de LLMs é o que eu indico primeiro para colegas juniores.

Com esses benchmarks definidos, aqui está como os 9 modelos pontuam neles, começando pela fronteira em nuvem.

Quais são os melhores modelos de fronteira na nuvem para programar?

Os melhores modelos de fronteira na nuvem para programar em setembro de 2026 são Claude Opus 5.5, Claude Fable 5.1, GPT-6 Astra e Gemini 3.8 Flash — e todos os 4 oferecem uma janela de contexto de cerca de 1M de tokens.

As diferenças são preço, níveis de esforço e para quais benchmarks cada lab otimizou.

Eu os listo na ordem em que os recomendaria para um time que pode pagar por qualquer um deles.

1. Claude Opus 5.5 (Anthropic)

O Claude Opus 5.5 é o novo flagship da Anthropic na linha Opus, lançado em 22 de setembro de 2026, e hoje é o modelo de código que eu recomendaria para quase todo mundo. Eu não esperava escrever isso 2 meses após o Opus 5. O post de lançamento diz que ele performa no nível do Fable 5.1 na maior parte do trabalho, custando 40% menos que o Opus 5, e a visão geral de modelos agora orienta devs a começar com o Opus 5.5 e recorrer ao Fable 5.1 para trabalhos longos ou quando os seus evals no Opus 5.5 ficarem aquém.

O system card do Opus 5.5 reporta 89,9% no SWE-bench Pro, 74,2% no DeepSWE v1.1 e 66,4% no Terminal-Bench 4.0 em xhigh effort, à frente do Fable 5.1 em todas as linhas de código que a Anthropic publicou. Os números independentes são mais apertados: o Artificial Analysis coloca ele empatado com o GPT-6 Astra em 59,6% no Terminal-Bench 4.0, e a Vals AI o coloca em primeiro com 61,6% no Terminal-Bench 4.0 e 87,6% no Terminal-Bench 2.1. Ambos incluem fallbacks acionados por salvaguardas; contando esses casos como falhas, os números caem para 53,5% e 79,8%.

Destaques:

• US$ 4 por milhão de tokens de entrada e US$ 20 por milhão de saída, 20% abaixo do Opus 5, com leituras de cache 60% mais baratas (US$ 0,20 por milhão)
• Contexto de 1M de tokens, 128K de saída, pensamento adaptativo que não pode ser desligado e esforço padrão em médio em vez de alto
• 57,8% no CursorBench 4.0 em esforço máximo, maior nota no leaderboard do Cursor; em médio, marca 52,5%, ainda acima do Fable 5.1 no máximo
• Disponível na API do Claude como claude-opus-5-5, além de Amazon Bedrock, Google Cloud e Microsoft Foundry

Melhor para: codificação do dia a dia, migrações de código em toda a base e code review. Ele substitui o Opus 5 com preço menor, e o Claude Code agora o usa como modelo Opus padrão. Nosso guia do Claude Opus 5.5 cobre o lançamento, e nossa comparação GPT-6 Sol vs Claude Opus 5.5 traz um teste prático.

Trade-off: a economia de 40% vale no esforço padrão. No esforço máximo, o Artificial Analysis constatou que ele consumiu bem mais tokens que o Opus 5, então o custo por tarefa do Intelligence Index (US$ 5,98) ficou quase empatado com o do Opus 5 (US$ 5,86). Ele também vem com salvaguardas ao estilo Fable que redirecionam a maioria das tarefas de cibersegurança para o Opus 4.8, e migrações de código exigem cuidado, pois requisições com pensamento desligado ou uso de ferramenta forçado agora retornam erro.

2. Claude Fable 5.1 (Anthropic)

O Claude Fable 5.1 é a versão pública do modelo classe Mythos da Anthropic, lançado em 1º de setembro de 2026, e é o modelo para o qual escalo quando o Opus 5.5 chega ao limite. A página de lançamento afirma que Fable 5.1 e Claude Mythos 5.1 são o mesmo modelo com salvaguardas diferentes.

Os números do system card do Fable 5.1 são 81,2% no SWE-bench Pro e 55,8% no Terminal-Bench 4.0. O Artificial Analysis mediu independentemente 91,4% no Terminal-Bench 2.1 em esforço máximo, ainda a maior nota desse board.

Destaques:

• Janela de contexto de 1M de tokens e 128K de saída
• Pensamento adaptativo sempre ligado
• Leituras do prompt-cache caíram 75% para US$ 0,25 por milhão de tokens com o 5.1, o que a Anthropic estima cortar workloads agentic em até 45%
• Planejamento forte multi-arquivo e pensamento mais amplo com melhor uso de ferramentas

Melhor para: pipelines agentic em produção, refactors de vários dias e qualquer tarefa onde uma resposta errada custe mais do que os tokens, após seus evals mostrarem que o Opus 5.5 ficou aquém. Nosso guia do Claude Fable 5.1 cobre este release, e nossa visão geral do Claude Fable 5 cobre o original de junho.

Trade-off: US$ 10 por milhão de tokens de entrada e US$ 50 por milhão de saída é 2,5 vezes a tarifa do Opus 5.5, e na própria tabela da Anthropic o Fable 5.1 agora fica atrás do Opus 5.5 em SWE-bench Pro, Terminal-Bench 4.0 e CursorBench 4.0. A Anthropic diz que o gap no mundo real é menor do que esses scores sugerem, mas o ônus da prova inverteu. No CursorBench 3.2.0 (mais antigo), o Fable 5.1 em esforço médio marcou 68,0% por US$ 3,53 por tarefa.

3. GPT-6 Astra (OpenAI)

O GPT-6 Astra é o modelo de fronteira da OpenAI, lançado em 3 de setembro de 2026, e ainda está em primeiro no ranking de agentes do Terminal-Bench 4.0 no tbench.ai com 58,2% usando o harness do Codex em esforço máximo, embora o Opus 5.5 ainda não tenha entrada de agente lá.

A página do modelo lista janela de contexto de 1.050.000 tokens, 128.000 tokens de saída, cutoff de conhecimento em 30 de abril de 2026 e níveis de esforço de none a max. Preços: US$ 10 por milhão de tokens de entrada, US$ 1 para entrada em cache e US$ 50 por milhão de tokens de saída.

O material de lançamento da OpenAI se apoia em seus próprios testes e no system card, em vez de benchmarks cruzados entre labs. As avaliações deles são fortes, mas eu não chamaria o Astra de vencedor claro sobre o Opus 5.5 ou o Fable 5.1. Cobrimos os números de lançamento na nossa visão geral do GPT-6 Astra.

Destaques:

• A Responses API expõe hosted_shell, apply_patch, computer_use e tool_search, o conjunto de ferramentas no qual o próprio Codex roda.
• Entrada em cache a US$ 1 por milhão de tokens, um décimo do preço base — importante para loops agentic que relem le o mesmo repositório.
• O Astra é o primeiro modelo da OpenAI a alcançar o topo de cibersegurança do Preparedness Framework, então alguns prompts próximos a segurança são controlados.

Melhor para: times já no Codex, GitHub Copilot ou stack Microsoft, tarefas pesadas de ciência e engenharia e quem precisa de melhor suporte a ferramentas de terceiros. Se você quer a maior parte da capacidade por menos, o GPT-6 Sol, lançado em 22 de setembro a US$ 2 de entrada e US$ 10 de saída por milhão de tokens, sucede o GPT-5.6 Sol e, sem GPT-6 Terra, agora ocupa a antiga faixa de preço do Terra. Nas próprias tabelas da OpenAI ele marca 68,8% no DeepSWE 1.1 e 49,3% no FrontierCode, embora o GPT-5.6 Sol no esforço máximo ainda marque mais alto no DeepSWE.

Trade-off: preços na faixa do Fable, e o Opus 5.5 agora iguala o Astra no Terminal-Bench 4.0 por cerca de 40% do custo por tarefa segundo a Anthropic, com o Artificial Analysis pontuando os dois empatados. As lideranças mais claras do Astra estão em trabalhos pesados de ciência: 64,6% no Terminal-Bench-Science e 65,5% no FrontierSWE v2, ambos acima do Opus 5.5.

4. Gemini 3.8 Flash (Google)

O Gemini 3.8 Flash é o modelo faz-tudo do Google, lançado em 2 de setembro de 2026, e uma das formas mais baratas de obter uma pontuação agentic de fronteira (o GPT-6 Luna é mais barato por token, mas marca menos em agentic). O relatório de avaliação do Google mostra 89,4% no Terminal-Bench 2.1 e 73,7% no DeepSWE v1.1, um conjunto de 113 tarefas de longo horizonte no qual o Fable 5.1 marcou 67,4%. A mesma tabela traz o Opus 5 um pouco à frente com 74,0%, a Anthropic reporta 74,2% para o Opus 5.5, e o guia do desenvolvedor do Google adiciona 61,6% no SWE-bench Pro.

Os preços na página do Gemini API são US$ 0,75 por milhão de tokens de entrada e US$ 3,75 por milhão de saída até 31 de dezembro de 2026; depois, US$ 1,50 e US$ 7,50 a partir de 1º de janeiro de 2027. Mesmo no preço de 2027, isso é pouco mais de um terço da tarifa de saída do Opus 5.5. A janela de contexto é 1M de tokens de entrada com 64K de saída.

Destaques:

• Entrada multimodal nativa: dá para passar um diagrama de arquitetura ou um screenshot de uma UI falhando ao lado do código.
• O Google o posiciona como o modelo para workloads agentic de alto volume e precifica de acordo.
• Existe uma variante Cyber para vulnerabilidades, com acesso separado, que cobrimos na visão geral do Gemini 3.8 Flash e Flash Cyber.

Melhor para: loops agentic de alto volume, times sensíveis a custo e quem usa Vertex AI. O Gemini 3.1 Pro, lançado em 19 de fevereiro de 2026, continua sendo o modelo da linha Pro do Google com 54,2% no SWE-bench Pro a US$ 2 de entrada e US$ 12 de saída por milhão de tokens, mas, para código especificamente, hoje eu escolheria o 3.8 Flash em vez do 3.1 Pro.

Trade-off: 19,1% no Terminal-Bench 4.0. O Flash é forte em tarefas de terminal bem delimitadas e fraco nas tarefas de ciência de fronteira, então mantenha um modelo mais forte por perto para os tickets mais difíceis.

Isso cobre os modelos em nuvem. O resto da lista são modelos que você pode baixar.

Quais são os melhores LLMs open weight para código em 2026?

Os melhores LLMs open weight para código em 2026 se dividem em 2 grupos: modelos em escala de datacenter como DeepSeek V4.1 Flash e Kimi K3, que igualam scores de fronteira mas exigem hardware de servidor pesado, e modelos abaixo de 120B como Qwen3.8-27B e Laguna S 2.1, que você consegue rodar no seu próprio hardware.

“Open weight” aqui significa que os pesos são baixáveis. As licenças variam de MIT e Apache 2.0 a termos personalizados.

5. DeepSeek V4.1 Flash (DeepSeek)

O DeepSeek V4.1 Flash é o release de 10 de setembro de 2026, e apesar do nome Flash, hoje é o modelo da DeepSeek que eu usaria primeiro. A DeepSeek diz que ele supera o próprio V4 Pro 0813 em performance, custo, velocidade e tempo de conclusão de tarefas. O índice independente da Vals AI aponta na mesma direção, ranqueando-o como o melhor open weight com 57,9%, contra 52,4% que a Vals registrou para o V4 Pro 0813 em agosto.

É um modelo MoE com 552B parâmetros, com cerca de 8B ativos por token na entrada e 16B na saída, contexto de 1M de tokens, entrada nativa de imagem e pesos sob licença MIT. A DeepSeek reporta 90,6% no Terminal-Bench 2.1 e 74,2% no DeepSWE v1.1, as maiores pontuações open weight reportadas por vendor em ambos. A execução própria da Vals AI no Terminal-Bench 2.1 é menos generosa: 74,5%, segundo entre os open weights.

Cobrimos o lançamento em mais detalhes na nossa visão geral do DeepSeek V4.1 Flash.

Destaques:

• Preços de API na página de preços da DeepSeek: US$ 0,15 por milhão de tokens de entrada e US$ 0,60 por milhão de saída fora do pico, dobrando para US$ 0,30 e US$ 1,20 nos horários de pico de dias úteis (01:00–04:00 e 06:00–10:00 UTC). Hits de cache custam US$ 0,003 por milhão fora do pico.
• Servido como deepseek-flash em uma API compatível com OpenAI, então o script ask_coding_model.py mais adiante funciona com mudança de base URL.
• Um KV cache cerca de um quarto do tamanho do V4 Flash, o que permite precificar contexto longo tão baixo.

Melhor para: código em terminal com capacidade quase de fronteira por centavos e jobs em lote que você pode agendar fora do pico.

Trade-off: ele marca 31,2% no Terminal-Bench 4.0 no próprio relatório da DeepSeek, então o trabalho agentic mais difícil ainda é terreno dos labs de fronteira. O checkpoint tem cerca de 510 GB, então “open weights” aqui significa um servidor multi-GPU. Se você usa o V4 Pro 0813, a DeepSeek anunciou que rotearia esse modelo para o V4.1 Flash em 14 de setembro e depois recuou; o V4 Pro ainda é servido a US$ 0,66/US$ 1,98 fora do pico até novo aviso.

6. Kimi K3 (Moonshot AI)

O Kimi K3 é o flagship open weight de 2,8 trilhões de parâmetros da Moonshot AI, lançado em julho de 2026, e marca 88,3% no Terminal-Bench 2.1, segundo entre os modelos abertos, atrás dos 90,6% reportados pelo vendor do DeepSeek V4.1 Flash.

O card no Hugging Face lista 104B parâmetros ativos em 896 experts (16 roteados mais 2 compartilhados por token), contexto de 1.048.576 tokens e pesos MXFP4. A Vals AI mediu 93,4% no SWE-bench Verified.

Destaques:

• Contexto de 1M de tokens com visão nativa.
• Distribuído sob a Kimi K3 License, uma licença customizada em vez de MIT ou Apache — leia antes de uso comercial.
• Stacks de inferência recomendados: vLLM, SGLang e TokenSpeed; a Moonshot calibrado algumas tarefas de GPU para H20.

Melhor para: quem quer o agente de código aberto mais forte disponível.

Trade-off: capacidade quase de fronteira só vem em escala de datacenter. O gap de 3 pontos para o Fable 5.1 no Terminal-Bench 2.1 parece pequeno, mas não é comparação idêntica: a Moonshot mediu 88,3% no próprio harness Kimi Code, enquanto os 91,4% do Fable vêm do Terminus 2 do Artificial Analysis. Na prática, você vai alugá-lo via provedor hospedado ou rodar seu próprio cluster, além de alinhar a licença customizada com o jurídico.

7. Qwen3.8-27B (Alibaba)

O Qwen3.8-27B é um modelo denso de 27 bilhões de parâmetros lançado em agosto de 2026 sob Apache 2.0, e é o melhor LLM para código que você roda em uma única GPU de 24 GB.

O model card reporta 61,7% no SWE-bench Pro, 73,0% no Terminal-Bench 2.1, 90,3% no LiveCodeBench v6 e 42,2% no DeepSWE 1.1, com contexto nativo de 262.144 tokens, extensível a 1M com YaRN. Esses números de SWE-bench Pro e Terminal-Bench superam o Laguna S 2.1, um modelo 4 vezes maior, e superam o Gemini 3.1 Pro no SWE-bench Pro. Vale a ressalva: a Qwen rodou o SWE-bench Pro no seu próprio conjunto de tarefas corrigido, então trate comparações cross-lab como direcionais.

Destaques:

• O GGUF UD-Q4_K_M da comunidade (Unsloth) é um único arquivo de 16,5 GB, deixando espaço para contexto de 32K em uma placa de 24 GB. O UD-Q4_K_XL tem 17,6 GB.
• Arquitetura densa: mais lento por token que um MoE com 3B ativos, mas bem mais consistente em edições multi-arquivo.
• Apache 2.0, sem restrições de uso em produtos comerciais.

Melhor para: devs que não podem enviar código para uma API externa, profissionais solo com uma GPU classe RTX e quem quer comparar local versus Claude no próprio repo antes de pagar pela nuvem.

Trade-off: 73,0% versus 91,4% no Terminal-Bench 2.1 ainda é um gap de 18 pontos — isso aparece como mais tentativas em tarefas agentic longas.

8. Laguna S 2.1 (Poolside)

O Laguna S 2.1 é um modelo MoE de código com 118B parâmetros e 8B ativos, da Poolside, lançado em 21 de julho de 2026, e é o open weight indicado para um Mac Studio, DGX Spark ou workstation multi-GPU.

O post de lançamento da Poolside reporta 59,4% no conjunto público do SWE-bench Pro, 70,2% no Terminal-Bench 2.1 com pensamento no máximo (60,4% com pensamento desligado), 78,5% no SWE-bench Multilingual e 40,4% no DeepSWE.

O modelo foi treinado em 409.000 ambientes, incluindo 83.000 tarefas de terminal e 168.000 workflows de engenharia de software, em 4.096 H200s por menos de 9 semanas.

Destaques:

• Janela de contexto de 1M de tokens — incomum nesse porte.
• Licença OpenMDW-1.1, permissiva, mas vale passar pelo jurídico.
• O modo “thinking” vem ativado por padrão e vale cerca de 10 pontos no Terminal-Bench 2.1; o comprimento médio de conclusão variou de ~23K a ~249K tokens por tarefa nas execuções da Poolside — orce para isso.

Melhor para: times que querem um agente local no estilo Claude Code em uma máquina com 96 a 128 GB de memória unificada, e repositórios grandes o suficiente para precisar da janela de 1M localmente.

Trade-off: 118B parâmetros em 4 bits dá algo como 60 a 70 GB de pesos antes de alocar o KV cache, então uma GPU de 24 GB está fora. Em notas brutas, o Qwen3.8-27B leva vantagem, mas os 8B ativos do Laguna o tornam bem mais rápido quando os pesos cabem — que é o objetivo de um agente rodando à noite.

9. Qwen3-Coder-Next (Alibaba)

O Qwen3-Coder-Next é um modelo MoE de 80B parâmetros que ativa apenas 3B por token, lançado em 3 de fevereiro de 2026 sob Apache 2.0, e é o codificador local mais rápido e capaz para hardware que não sustenta um denso de 27B com velocidade.

O model card reporta 70,6% no SWE-bench Verified, 44,3% no SWE-bench Pro e 36,2% no Terminal-Bench 2.0, com 512 experts (10 ativos mais 1 compartilhado) e contexto de 262.144 tokens. Ele roda apenas em modo sem “thinking”.

Destaques:

• O GGUF Q4_K_M oficial tem cerca de 48 GB — fica melhor para um Mac de 64 GB ou setup com offload de CPU do que para uma única GPU de consumo.
• Atenção híbrida (3 camadas Gated DeltaNet por camada de atenção padrão) mantém o uso de memória de contexto longo baixo.
• Suportado em vLLM, SGLang, Ollama, LM Studio, MLX-LM, llama.cpp e KTransformers, segundo o card.

Melhor para: tarefas longas rodando à noite quando tokens por segundo importam mais que acurácia de pico, e laptops com 64 GB de memória unificada.

Trade-off: 44,3% no SWE-bench Pro está 17 pontos atrás do Qwen3.8-27B; para um bug difícil único eu iria de modelo denso.

Outros open weights que valem o olhar

Quatro modelos quase entraram na lista, e 2 deles podem atender times específicos melhor do que minhas escolhas:

• DeepSeek V4 Pro 0813 (DeepSeek): 1,6T no total, 49B ativos, contexto de 1M, licença MIT, 96,4% no SWE-bench Verified (Vals AI, arquivado). Ainda servido a US$ 0,66 de entrada e US$ 1,98 de saída por milhão de tokens fora do pico, mas a Vals mediu 54,7% no Terminal-Bench 2.1 contra 87,9% reportados pela DeepSeek — e a empresa agora aponta usuários para o V4.1 Flash. Nosso explicador do DeepSeek V4 cobre a arquitetura.
• Kimi K2.6 (Moonshot): 1T no total, 32B ativos, 256K de contexto, MIT modificado, 80,2% no SWE-bench Verified, 58,6% no SWE-bench Pro e 89,6% no LiveCodeBench v6. A licença mais limpa entre os modelos de trilhão, depois do MIT puro do DeepSeek V4 Pro.
• MiniMax M3: 428B no total, 23B ativos, 1M de contexto, entrada nativa de imagem e vídeo, 80,5% no SWE-bench Verified e 59% no SWE-bench Pro. Opção aberta se suas tarefas misturam código com screenshots.
• Qwen3.8-Flash-Next: 125B no total com 6B ativos, 62,5% no SWE-bench Pro e 58,7% no DeepSWE, sob a licença mais restritiva qwen-community-1.0. Mais forte que o Qwen3.8-27B no DeepSWE, mas a licença o tirou do meu top 9.

Se algum desses open weights combina com seu hardware, a próxima seção mostra como colocar para rodar.

Como rodar um modelo open weight de código localmente?

Rodar um modelo open weight de código localmente pede 3 passos: baixar um checkpoint quantizado, servi-lo atrás de um endpoint compatível com OpenAI e apontar seu cliente ou assistente de código para esse endpoint. Vou usar o Qwen3.8-27B no exemplo porque é o mais fácil dos 9 para caber em hardware de consumo.

Primeiro, o download. A biblioteca huggingface_hub cuida de transferências retomáveis e cache, o que ajuda com esses arquivos grandes:

"""Download a quantized coding model from Hugging Face.
 
Qwen3.8-27B at UD-Q4_K_M is a single 16.5 GB file, which leaves room for
a 32K context on a 24 GB GPU. Swap FILENAME for the UD-Q4_K_XL build if you
have the extra 1 GB to spare.
"""
 
from huggingface_hub import hf_hub_download
 
REPO_ID = "unsloth/Qwen3.8-27B-GGUF"
FILENAME = "Qwen3.8-27B-UD-Q4_K_M.gguf"
 
 
def fetch(repo_id: str = REPO_ID, filename: str = FILENAME) -> str:
    """Download one file from the Hub and return its local path."""
    path = hf_hub_download(repo_id=repo_id, filename=filename)
    print(f"Saved to {path}")
    return path
 
 
if __name__ == "__main__":
    fetch()

Salve como download_gguf.py e rode uv run --with huggingface_hub python download_gguf.py. No Windows você verá um aviso sobre symlinks se o Modo Desenvolvedor não estiver ativo.

Segundo, sirva o modelo.

Qualquer um entre llama-server do llama.cpp, LM Studio ou Ollama expõe um endpoint /v1 compatível com a OpenAI. No llama.cpp o comando é uma linha, e 2 flags fazem o serviço: -ngl 99 offloada todas as camadas para a GPU e -c 32768 define contexto de 32K.

llama-server -m Qwen3.8-27B-UD-Q4_K_M.gguf -c 32768 -ngl 99 --port 8080

Terceiro, o cliente. Eu mantenho um script por modelo que avalio, local ou hospedado, e alterno o alvo com 3 variáveis de ambiente. O mesmo arquivo fala com o servidor local acima, com a API da DeepSeek ou com a OpenAI:

"""Send one coding prompt to any OpenAI-compatible endpoint.
 
The same script talks to a local llama.cpp or vLLM server, to DeepSeek's
API, or to OpenAI itself. Only three environment variables change:
 
    LLM_BASE_URL   e.g. http://localhost:8080/v1  or  https://api.deepseek.com
    LLM_MODEL      e.g. qwen3.8-27b  or  deepseek-flash
    LLM_API_KEY    anything non-empty for a local server
"""
 
import os
 
from openai import OpenAI
 
PROMPT = (
    "Write a Python function top_n(df, col, n) that returns the n largest "
    "rows of a pandas DataFrame by column col, with a docstring and a "
    "ValueError if col is missing."
)
 
 
def ask(prompt: str = PROMPT) -> str:
    """Return the model's reply for a single-turn coding request."""
    client = OpenAI(
        base_url=os.environ["LLM_BASE_URL"],
        api_key=os.environ.get("LLM_API_KEY", "local"),
    )
    response = client.chat.completions.create(
        model=os.environ["LLM_MODEL"],
        messages=[{"role": "user", "content": prompt}],
        temperature=0.2,  # keep code generation close to deterministic
    )
    return response.choices[0].message.content
 
 
if __name__ == "__main__":
    print(ask())

Salve como ask_coding_model.py e rode com LLM_BASE_URL=http://localhost:8080/v1 LLM_MODEL=qwen3.8-27b uv run --with openai python ask_coding_model.py.

Se você for integrar vários desses endpoints em um app com roteamento, retries e tool calls, nosso curso de desenvolvimento de aplicações LLM com LangChain cobre as abstrações que evitam uma pilha de if por todo lado.

Como escolher o melhor LLM para programar?

Escolher o melhor LLM para programar depende de 4 restrições: se seu código pode sair da sua máquina, quanta memória você tem, quanto você paga por milhão de tokens de saída e quanto contexto uma tarefa precisa. A tabela abaixo coloca os 9 modelos lado a lado nos números em que mais confio, e o guia de decisão após ela mapeia essas restrições para uma escolha.

O guia de decisão

É assim que mapeio as 4 restrições para o ranking:

• Pipelines agentic onde correção pesa mais que custo: Claude Opus 5.5 em esforço alto ou xhigh, com Fable 5.1 de prontidão para tarefas longas nas quais seus evals mostrem o Opus 5.5 ficando aquém.
• Codificação assistida por IA no dia a dia, com preço em conta: Claude Opus 5.5 no esforço médio padrão primeiro; GPT-6 Sol em segundo se você vive no Codex.
• Ciência de fronteira, simulação ou trabalho de kernels de GPU: GPT-6 Astra ou Claude Opus 5.5. O Astra lidera no Terminal-Bench-Science; o Opus 5.5, no Terminal-Bench 4.0.
• Codebase enorme, prompts de 1M de tokens, orçamento apertado: Gemini 3.8 Flash pelo preço; Opus 5.5 quando as respostas do Flash perderem qualidade.
• Open weight via API: DeepSeek V4.1 Flash fora do pico.
• Local e privado em uma única GPU de 24 GB: Qwen3.8-27B em UD-Q4_K_M.
• Local e privado em máquina de 96 a 128 GB: Laguna S 2.1; ou Kimi K3 se “máquina” significar “cluster”.
• Local e rápido em laptop de 64 GB: Qwen3-Coder-Next.

Se você quer um framework mais geral para casar modelo e aplicação, incluindo opções de hosting e licenciamento, nosso guia sobre como escolher o melhor LLM para sua aplicação vai além de código.

E, seja qual for o modelo, as habilidades para extrair valor dele são as mesmas: nossa trilha de habilidades de IA para engenharia de software e o curso de programação assistida por IA para desenvolvedores ensinam o prompting, os testes e os hábitos de revisão que transformam um benchmark de 91% em um pull request aprovado.

Considerações finais

O Claude Opus 5.5 é o melhor LLM para programação em setembro de 2026 e, de forma incomum, também é aquele para colocar na conta do seu time. O Claude Fable 5.1 é a via de escalonamento para as tarefas mais longas, e o Qwen3.8-27B é o open weight que transforma uma GPU de 24 GB em um assistente de código privado que supera a fronteira do ano passado no SWE-bench Pro. O resto depende das suas restrições — e o guia de decisão acima é como eu as resolveria.

A mudança maior é que o benchmark que definiu essa categoria por 2 anos, o SWE-bench Verified, deixou de importar no mesmo período em que os open weights o alcançaram.

Isso não é coincidência.

Quando Opus 5 e DeepSeek V4 Pro ficam a 0,6 ponto num teste saturado, e um modelo de US$ 20 por milhão agora supera o de US$ 50 da própria Anthropic no SWE-bench Pro, o valor migrou para design de harness, orçamento de esforço e avaliação no seu próprio repositório — exatamente o trabalho que uma tabela de vendor não faz por você.

Então faça esse trabalho. Pegue o script ask_coding_model.py, aponte para 2 ou 3 desses modelos, rode em 20 tickets reais do seu backlog no nível de esforço que você realmente vai pagar, e deixe esse resultado prevalecer sobre qualquer coisa que eu escrevi aqui. Se “vibe coding” é mais a sua praia do que harnesses de avaliação, nosso texto sobre o que é vibe coding e onde ele falha traz um olhar honesto sobre os trade-offs — e o mesmo ranking de modelos se aplica.