Há duas escolas no mundo da IA para programar. Os que só querem o modelo mais forte do planeta e os que, como eu, acham que um modelo mais fraco te obriga a pensar. Neste artigo vou mostrar-te quem lidera a tabela agora, o que consegues correr no teu próprio computador (mesmo que ele seja uma carroça) e porque é que eu, por opção, ando de bicicleta quando podia ir de Ferrari.
Aviso já: os rankings mudam quase todas as semanas. Tudo o que está aqui reflecte 29 de Outubro de 2026. Se estiveres a ler isto daqui a seis meses, usa as referências no fim para ver o que mudou.
Quem manda hoje
A tabela que mais uso como referência é a do Artificial Analysis, que testa os modelos de forma independente. Em Outubro de 2026 eles lançaram a versão 5 do seu Intelligence Index e mudaram as regras: 60% do índice passou a usar testes privados, para os modelos não "decorarem" as respostas. Os resultados, nos dias em que escrevo:
| Modelo | Índice v5 |
|---|---|
| Gemini 4 Carbon (Google)* | 59 |
| Claude Opus 5.5 (Anthropic) | 58 |
| GPT-6 Astra (OpenAI) | 57 |
| GPT-6.1 Sol (OpenAI) | 55 |
| Gemini 4 Argon (Google) | 50 |
* O Gemini 4 Carbon está a ser lançado para utilizadores seleccionados e ainda não é público.
Alguns pormenores que acho mais interessantes do que a tabela em si:
- Ninguém ganha em tudo. Segundo o Artificial Analysis, nenhum modelo lidera os nove testes. O Claude Opus 5.5 lidera o teste de código em repositórios reais (FrontierCode 2.0, 46%), enquanto o GPT-6 Astra lidera os de ciência em terminal e física.
- O preço varia imenso. Entre os melhores, o custo por tarefa varia mais de 13 vezes. O GPT-6.1 Sol fica a 4 pontos do Opus 5.5 por cerca de um oitavo do custo.
- O "esforço" de raciocínio muda tudo. O Opus 5.5 pontua 35 no esforço baixo e 58 no máximo, mas o máximo custa cerca de 10 vezes mais por tarefa.
- Para código, o modelo é só metade. A outra metade é a ferramenta à volta. No índice de agentes de código do mesmo site, o Claude Code com Opus 5.5 marca 62 e o Antigravity CLI com Gemini 4 Carbon marca 59.
E os modelos abertos (os que podes descarregar)?
Aqui a história é menos bonita. Com a v5, o melhor modelo aberto, o Kimi K3.1 Pro, marca 46, mas os pesos ainda não foram publicados, ou seja, ainda não o consegues descarregar. Entre os que já têm pesos públicos, o DeepSeek V4.1 Flash e o GLM-5.3 lideram com 32 e ficam abaixo do Claude Haiku 5.5, que marca 36.
Traduzindo: a distância entre os modelos de topo fechados e os abertos aumentou. Mas atenção, "abertos" não quer dizer que correm no teu portátil. Os maiores precisam de servidores a sério. Para o teu PC, vamos à secção seguinte.
Modelos locais: o que cabe no teu computador
Correr um modelo localmente quer dizer que ele funciona na tua máquina, sem internet, sem pagar por token e sem enviar o teu código a ninguém. A base de quase tudo é o llama.cpp, e ferramentas como o Ollama e o LM Studio usam o mesmo motor, por isso a velocidade é praticamente igual. Escolhe a que te der mais conforto: o Ollama para terminal, o LM Studio se preferires janelas com botões.
O truque que torna isto possível é a quantização. Ela comprime o modelo (por exemplo, no formato Q4_K_M) para ocupar menos memória, com uma perda de qualidade pequena. É por causa dela que um modelo de 14 mil milhões de parâmetros ocupa cerca de 8,5 GB em vez de dezenas.
Hardware, do pior caso ao bom
| O que tens | O que consegues correr | Para que serve |
|---|---|---|
| Sem placa gráfica, 8 GB de RAM | Modelos de 1B a 4B (como Qwen 3.5 4B ou Granite 4.2 3B) | Explicar código, mensagens de commit, tarefas pequenas |
| 16 GB de RAM (sem GPU) ou Mac com 16 GB | Modelos de 8B a 12B (como Gemma 4 12B, cerca de 7,4 GB) e o gpt-oss 20B | Autocompletar, funções isoladas, ajuda no dia a dia |
| GPU com 12 a 16 GB de VRAM | Modelos até 20B a 35B, conforme a quantização | Código a sério, com boa velocidade |
| GPU com 24 GB (ou Mac com 32 GB) | Qwen 3.8 27B (sucessor do 3.6 27B, que já era apontado como o melhor modelo local de código de 2026) | O mais perto de um assistente "a sério" local |
| 48 GB de VRAM ou Mac com 64 GB | Qwen3-Coder-Next, quase de nível topo | Quase tudo, sem sair de casa |
Quatro avisos de quem já tropeçou nisto:
- Sem GPU funciona, mas é lento. Num portátil normal, um modelo de 8B corre mais ou menos à velocidade de leitura. Dá para começar, mas não esperes milagres.
- A RAM do sistema não é VRAM. Quando a memória da placa se esgota, as camadas passam para o processador e tudo fica entre 10 e 100 vezes mais lento.
- O contexto também come memória. Quanto mais código lhe deres para ler, mais memória a "cache" ocupa. Um contexto de 32 mil tokens pode custar vários GB.
- Local ainda perde nas tarefas longas. Para agentes que trabalham durante muito tempo, e para o raciocínio de topo, os modelos hospedados continuam à frente. O local brilha no autocompletar, no código simples e em quando a privacidade é o mais importante.
Ligar um modelo local ao OpenCode é fácil: ele aceita qualquer fornecedor compatível, e o Ollama e o LM Studio expõem uma API local que podes configurar como um fornecedor normal.
Caso prático: Qwen3.8-27B numa RTX 5090
Chega de teoria. Vamos pegar num modelo concreto e numa placa concreta. O modelo é o Qwen3.8-27B, da Alibaba, e a placa é uma RTX 5090 de 32 GB. Aviso honesto: isto não é o caso "carroça". Para esse, volta à tabela de cima. Aqui o objectivo é ver até onde um modelo local consegue ir quando tem hardware a sério.
O modelo em poucas linhas
- Denso, 27 mil milhões de parâmetros. Denso quer dizer que todos os parâmetros trabalham em cada token, ao contrário dos modelos MoE, que só activam uma parte.
- Multimodal: aceita texto, imagens e vídeo.
- Licença Apache 2.0, lançado a 14 de Agosto de 2026, com 262.144 tokens de contexto nativos.
- Os números da Alibaba: 61,7 no SWE-bench Pro e 73,0 no Terminal-Bench 2.1, contra 53,5 e 63,4 do antecessor, o Qwen3.6-27B.
Dois avisos antes de te empolgares. Primeiro, estes números são da própria Alibaba, e quando li sobre o modelo ainda não havia avaliação independente. Não o vi nomeado no artigo do índice v5 do Artificial Analysis, por isso não sei onde ele fica na tabela independente. Segundo, a Alibaba compara-o com modelos mais antigos (como o Claude Opus 4.6), e não com os de topo de hoje. É um modelo muito bom para o tamanho, mas não o confundas com o Opus 5.5 ou com o Gemini 4.
Porque é que a 5090 é a casa ideal
- A memória chega e sobra. Em Q4, o ficheiro pesa cerca de 16 a 18 GB. Sobra espaço para o contexto, que é o que realmente interessa a um agente de código. Com a cache de contexto comprimida (q4_0), a comunidade corre a janela inteira de 262K usando cerca de 23 a 26 GB.
- Quantizações maiores comem contexto. Num relato, com a quantização UD-Q6_K_XL só coube 48K de contexto numa 5090, e com a UD-Q5_K_XL, 128K. Mais qualidade por token, menos janela.
- A Blackwell tem formato nativo para isto. A arquitectura da 5090 suporta o NVFP4, e um guia da DataCamp reporta mais de 100 tokens por segundo com ele combinado com MTP (explico já a seguir).
Velocidade: os números reais
Estes números vêm de um repositório comunitário no GitHub onde dezenas de pessoas medem a mesma coisa com a mesma ferramenta. São em tokens por segundo (quanto maior, melhor), numa RTX 5090 de 32 GB com o llama.cpp:
| Configuração | Sem MTP | Com MTP |
|---|---|---|
| Q4_K_M, contexto 131K | 76,9 | 155,5 |
| UD-Q4_K_XL, contexto 262K | 74,3 | 179,7 |
| UD-Q5_K_XL, contexto 262K | 69,6 | 147,5 |
| Q6_K, contexto 256K | 62,0 | 121,7 |
Para teres referência: uma RTX 4090 aparece nesse repositório a ir de cerca de 48 para 76, e uma RTX 3090 de cerca de 31 a 41 para 41 a 64. E até uma placa de 16 GB (uma RTX 5080, com quantização Q3 e contexto de 64K) chegou a cerca de 101 tokens por segundo.
Agora a dose de realidade. Alguém que montou um agente de código a sério (Claude Code ligado a este modelo local, com 128K de contexto e um projecto de verdade) mediu cerca de 95 tokens por segundo em respostas longas e à volta de 3.000 tokens por segundo a processar o prompt, usando cerca de 27 GB de VRAM. Ou seja, os picos dos benchmarks são mais bonitos do que a vida de todos os dias, mas continua a ser uma velocidade excelente para trabalhar.
O truque do MTP (e é quase de borla)
O Qwen3.8 foi treinado com camadas de previsão de vários tokens (multi-token prediction, MTP). Os ficheiros GGUF da Unsloth já trazem essas camadas, mas o llama.cpp ignorava-as se não lhe pedisses. Desde Julho de 2026 ele sabe usá-las como "rascunho": o servidor adivinha vários tokens de uma vez e o modelo principal só os verifica. O que for aceite sai muito mais barato do que gerar token a token.
Resultado, segundo o repositório: entre +33% e +145% de velocidade, conforme a placa, sem ficheiros novos e sem converter nada. Um comando para iniciar o servidor:
llama-server -m Qwen3.8-27B-Q4_K_M.gguf \
-c 131072 -ngl 999 -fa 1 \
--cache-type-k q4_0 --cache-type-v q4_0 \
--spec-type draft-mtp --spec-draft-n-max 2 --parallel 1
Também podes deixar o llama.cpp descarregar o modelo directamente: llama-server -hf unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_M. (Instala o llama.cpp com o gestor de pacotes do teu sistema ou compila-o a partir do repositório oficial.)
Regras que a comunidade descobriu e que vale a pena guardar:
- Testa o
--spec-draft-n-maxde 2 a 4. Várias 5090 ficaram mais rápidas com 4 do que com 2. - Nas 5090, o filtro
--spec-draft-p-mincostuma atrapalhar. Três 5090 independentes correram mais depressa sem ele. Mede antes de adoptares. - Isto só ajuda com um pedido de cada vez. Usa
--parallel 1. Com vários pedidos em simultâneo, a vantagem desaparece. - Ajuda mais em código do que em prosa. Em texto corrido o ganho é menor, e em respostas muito curtas pode nem compensar.
- Actualiza o llama.cpp antes de mexer em flags. O suporte a esta arquitectura melhora todas as semanas.
- Cuidado com o ambiente de trabalho. Se o ecrã (e o navegador) usarem a mesma placa, parte dos pesos pode cair para a RAM do sistema e a velocidade corta-se a meio, sem nenhum erro à vista. Mede com a placa livre, ou confirma que os pesos estão mesmo na VRAM.
- A cache comprimida (q4_0) compra espaço, não velocidade. Usa-a para caber mais contexto. Se sobrar memória, uma cache mais precisa é a escolha por omissão.
Ligar ao OpenCode
O llama-server fala a mesma "língua" que a API da OpenAI, por isso o OpenCode liga-se a ele como a qualquer fornecedor compatível. Exemplo de configuração (sintaxe da V1; na V2, confirma a página de fornecedores da documentação):
{
"$schema": "https://opencode.ai/config.json",
"provider": {
"llamacpp": {
"npm": "@ai-sdk/openai-compatible",
"name": "llama.cpp (local)",
"options": { "baseURL": "http://127.0.0.1:8080/v1" },
"models": {
"qwen3.8-27b": {
"name": "Qwen3.8 27B (local)",
"limit": { "context": 131072, "output": 8192 }
}
}
}
}
}
Depois escolhes o modelo com /models. Podes ver o nome exacto que o servidor expõe em http://127.0.0.1:8080/v1/models. Combina com o que expliquei lá atrás: planeia com um modelo de topo e implementa com este, local e grátis por token, com o teu AGENTS.md a mandar nele.
Para ser honesto
- A qualidade medida é da Alibaba. Testa com o teu projecto antes de confiares.
- As velocidades são relatos de utilizadores. Dependem do driver, da versão do llama.cpp, da quantização e do contexto. A ordem de grandeza é fiável, o número exacto na tua máquina não.
- Um 27B local não substitui o topo nas tarefas longas e difíceis. Mas, para quem gosta de modelos mais "básicos" com regras bem escritas, é um parceiro e tanto.
A minha filosofia: modelos básicos para pensar mais
Agora a parte pessoal, e é só a minha opinião, não é lei.
Eu gosto dos modelos mais básicos. Não por serem melhores. Gosto deles porque me obrigam a escrever regras detalhadas sobre o código que querem que escreva.
Com um modelo poderosíssimo é fácil cair numa armadilha: escreves "faz um login" e ele adivinha tudo. A estrutura, os nomes, a validação, até as decisões de arquitectura. Funciona, tu aceitas, e quando dás por ela entraste na associação dos preguiçosos: já não sabes porque é que o código está assim, não revês, não aprendes.
Com um modelo básico isso não acontece. Ele não adivinha o que tu queres, e se não lhe disseres, faz asneira. Então és obrigado a:
- decidir a estrutura de pastas antes de começar;
- definir os padrões de código (nomes, tratamento de erros, validação);
- dizer o que nunca deve fazer;
- explicar quando uma tarefa está terminada (testes que têm de passar, por exemplo);
- partir o trabalho em passos pequenos.
Ou seja, ele obriga-te a projectar antes de programar. E isso é exactamente o que faz de ti um melhor programador. O modelo é o teu professor mais chato: só aceita trabalho bem especificado.
Um exemplo do tipo de regras que escrevo para o AGENTS.md:
# Regras do projecto
## Stack
- Node.js 22, Fastify, TypeBox, PostgreSQL
- Nunca adicionar dependências sem perguntar
## Estrutura
- Um módulo por pasta em `src/modules/<nome>/`
- Cada módulo tem: `routes.ts`, `schema.ts`, `service.ts`
## Código
- Validar toda a entrada com TypeBox
- Erros devolvem sempre `{ code, message }`
- Funções com no máximo 40 linhas
- Nomes em inglês; comentários em português
## Nunca
- Nunca escrever senhas ou chaves no código
- Nunca apagar ficheiros sem pedir confirmação
## Terminado quando
- Os testes do módulo passam
- Não existem erros de tipos
A dica de ouro: cada modelo no seu lugar
Isto não quer dizer que eu fuja dos modelos fortes. Quer dizer que os uso onde fazem diferença. No OpenCode cada agente pode ter o seu modelo. Por isso:
- Planear e decidir a arquitectura: modelo mais forte, porque é aqui que um erro sai caro.
- Escrever o código seguindo as regras: modelo barato e básico, com o
AGENTS.mdbem escrito. - Rever e testar: subagentes especialistas, cada um com permissões limitadas.
Resultado: gasto menos, aprendo mais e o código segue as minhas regras, não as adivinhações do modelo.
Para ser honesto: isto também tem custos
- Se escreveres regras vagas, um modelo básico dá-te código mau. A qualidade do resultado é proporcional à qualidade das tuas regras.
- Leva mais tempo ao início. Escrever regras detalhadas dá trabalho.
- Há tarefas difíceis (raciocínio complexo, depuração de erros obscuros) em que um modelo básico simplesmente não chega, e aí vale a pena subir de nível.
E ser preguiçoso não é pecado, desde que seja uma escolha consciente. O problema é a preguiça de não saber o que se está a aceitar.
Como escolher sem enlouquecer
- Não confies cegamente nos rankings. Eles medem tarefas específicas, e a tua pode ser diferente. Testa com o teu projecto.
- Olha para o custo por tarefa, não só para o preço por token. Um modelo barato que precisa de dez tentativas pode sair mais caro.
- Começa pequeno. Experimenta um modelo básico (local ou barato) com regras boas antes de pagares pelo topo.
- Revê sempre. Qualquer modelo erra, os fortes também.
- Guarda as tuas regras. O
AGENTS.mdé um activo teu e funciona com qualquer modelo que venhas a usar.
Conclusão
Os modelos de topo estão cada vez melhores e mais caros, os abertos correm atrás, e os locais já cabem em computadores normais, mesmo que com limites. Mas a melhor ferramenta continua a ser a mesma: saberes o que queres. Um modelo básico, com regras claras, treina esse músculo. Um modelo poderoso, sem regras, deixa-o atrofiar.
Escolhe tu a Ferrari ou a bicicleta. Eu fico com a bicicleta e o mapa que desenhei, e chego lá a saber o caminho.
— Sr. Saiombo
Referências
- Artificial Analysis, Intelligence Index v5: https://artificialanalysis.ai/articles/artificial-analysis-intelligence-index-v5
- Artificial Analysis, Gemini 4 Carbon: https://artificialanalysis.ai/articles/gemini-4-carbon-new-number-1
- Artificial Analysis, tabela de modelos: https://artificialanalysis.ai/leaderboards/models
- Artificial Analysis, modelos abertos: https://artificialanalysis.ai/models/open-source
- llama.cpp: https://github.com/ggerganov/llama.cpp
- Ollama: https://ollama.com
- LM Studio: https://lmstudio.ai
- Melhores modelos locais de código (Kilo): https://blog.kilo.ai/p/the-best-local-coding-models-for
- Modelos Ollama por VRAM e SWE-bench (Morph): https://www.morphllm.com/best-ollama-models
- Modelos locais para código: hardware e programas (env.dev): https://env.dev/guides/local-llms-for-coding
- Modelos locais sem GPU, por RAM: https://bestllmfor.com/guide/llm-local-cpu-sans-gpu/
- Melhores modelos locais por RAM (FrankX): https://frankx.ai/blog/best-local-llm-2026
- Melhores modelos para 16 GB (Atomic Chat): https://atomic.chat/blog/guides/best-local-llm-16gb
- OpenCode, fornecedores de modelos: https://opencode.ai/v2/docs/providers/
- Qwen3.8-27B: ficha, licença e benchmarks (Morph): https://www.morphllm.com/qwen-3-8
- Alibaba lança o Qwen3.8-27B (DataNorth): https://datanorth.ai/news/alibaba-releases-qwen3-8-27b
- Qwen3.8-27B + MTP no llama.cpp, medições da comunidade: https://github.com/sudoingX/qwen38-mtp
- Qwen3.8-27B na RTX 5090 com NVFP4 e MTP (DataCamp): https://www.datacamp.com/tutorial/how-to-run-qwen3-8-27b-locally
- Qwen3.8-27B com Claude Code numa RTX 5090 (relato): https://medium.com/@mehmetalisepici/running-qwen3-8-27b-locally-with-claude-code-on-an-rtx-5090-9ccbea8ae49c
- Requisitos de hardware do Qwen3.8-27B (Kingy AI): https://kingy.ai/blog/qwen3-8-27b-local-hardware-requirements/
- Quantizações GGUF da Unsloth e relatos de contexto na 5090: https://huggingface.co/unsloth/Qwen3.8-27B-GGUF/discussions/14
- OpenCode com modelos locais (fornecedor compatível com OpenAI): https://learnopencode.com/en/appendix/providers