srsaiombo

Modelos de IA em 2026: rankings, e porque prefiro os básicos

Quem lidera os rankings de IA em 2026, o que dá para correr no teu computador e um caso prático: o Qwen3.8-27B numa RTX 5090, com velocidades reais, o truque MTP e como ligá-lo ao OpenCode.

Imagem de capa: Modelos de IA em 2026: rankings,  e porque prefiro os básicos

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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:

  1. Testa o --spec-draft-n-max de 2 a 4. Várias 5090 ficaram mais rápidas com 4 do que com 2.
  2. Nas 5090, o filtro --spec-draft-p-min costuma atrapalhar. Três 5090 independentes correram mais depressa sem ele. Mede antes de adoptares.
  3. Isto só ajuda com um pedido de cada vez. Usa --parallel 1. Com vários pedidos em simultâneo, a vantagem desaparece.
  4. Ajuda mais em código do que em prosa. Em texto corrido o ganho é menor, e em respostas muito curtas pode nem compensar.
  5. Actualiza o llama.cpp antes de mexer em flags. O suporte a esta arquitectura melhora todas as semanas.
  6. 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.
  7. 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.md bem 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

  1. Não confies cegamente nos rankings. Eles medem tarefas específicas, e a tua pode ser diferente. Testa com o teu projecto.
  2. 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.
  3. Começa pequeno. Experimenta um modelo básico (local ou barato) com regras boas antes de pagares pelo topo.
  4. Revê sempre. Qualquer modelo erra, os fortes também.
  5. 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

Achaste útil?

Leva esta ideia contigo.

Novidades sem ruído

A próxima ideia
chega à tua caixa.

Recebe um email quando sair um novo artigo. Sem frequência inventada e podes cancelar quando quiseres.

Só usamos o email para enviar novidades do blogue.