Pergunte ao Gemini 2.5 Pro quem é o presidente da França e ele provavelmente vai errar. Não por falta de capacidade, mas porque os engenheiros do Google deliberadamente sacrificaram esse tipo de conhecimento. O resultado? Um modelo que tira 53% em recall factual, mas resolve problemas de olimpíada de matemática que deixariam engenheiros seniores no chão.

Parece contraintuitivo, e é. Mas essa decisão de design está por trás de uma revolução silenciosa que vai mudar fundamentalmente como a gente pensa sobre inteligência artificial.

O paradoxo: mais inteligente e mais ignorante ao mesmo tempo

Em 2023, o GPT-4 precisava de cerca de 280 bilhões de parâmetros ativos para tentar resolver problemas do AIME (American Invitational Mathematics Examination). Tentava, porque o desempenho era sofrível. Avança para 2026: o GLM-5.2 alcança 99,2% no AIME 2026 com apenas 40 bilhões de parâmetros ativos. Mais impressionante ainda, o Qwen3.5 de 9 bilhões de parâmetros consegue resultados comparáveis com 13 bilhões de parâmetros ativos.

Os modelos encolheram 7x em tamanho e ficaram ordens de magnitude melhores em raciocínio. Só que, se você perguntar em que ano começou a Revolução Francesa, eles vão inventar uma resposta com a confiança de um estagiário no primeiro dia.

Isso não é um bug. É a feature mais importante da história recente da IA.

Olha essa tabela e me diz que não é bizarro. O modelo que melhor responde perguntas factuais é o que pior raciocina. E vice-versa.

Por que guardar fatos na rede neural é um péssimo negócio

Cada fato armazenado nos pesos de um modelo ocupa aproximadamente dois bits por parâmetro. Parece pouco, mas pense na escala: para um modelo “saber” uma fração relevante da Wikipedia, você precisa de bilhões de parâmetros dedicados exclusivamente a memorizar informação.

Agora pense no custo disso. Cada parâmetro consome memória, energia e tempo de inferência. Você está literalmente queimando GPU para que o modelo lembre o nome do vice-presidente do Paraguai, quando um curl na Wikipedia resolve isso em 50 milissegundos.

A matemática é cruel:

Custo de armazenar 1 fato nos pesos:
- ~2 bits/parâmetro de capacidade
- Requer re-treinamento para atualizar (meses, centenas de milhões de USD)
- Fica desatualizado no dia seguinte ao treinamento

Custo de buscar 1 fato externamente:
- 1 chamada de API (~50ms)
- Sempre atualizado
- Custo marginal próximo de zero

Procedimentos de raciocínio, por outro lado, comprimem absurdamente melhor. Decomposição de problemas, verificação de erros, backtracking, analogia: são técnicas reutilizáveis que funcionam independente do domínio. Um modelo que aprendeu a decompor um problema de matemática usa exatamente a mesma habilidade para debugar código ou analisar uma planilha financeira.

O framework de “runtime harness”: como modelos burros ficam geniais

Se o modelo não sabe os fatos, de onde eles vêm? Da mesma fonte que você usa: buscando na internet.

O conceito de “runtime harness” é simples, mas poderoso. Em vez de tentar ser uma enciclopédia ambulante, o modelo vira um motor de raciocínio que delega a busca de informação para sistemas externos. Bancos de dados, APIs, busca na web, documentação local, qualquer fonte que possa ser consultada em tempo real.

Na prática, funciona assim:

# Modelo antigo (tudo nos pesos)
resposta = modelo.gerar("Qual a população do Brasil em 2026?")
# Resultado: "215 milhões" (dados de 2023, desatualizado)

# Modelo novo (raciocínio + ferramentas)
plan = modelo.raciocinar("Preciso da população atual do Brasil")
dados = buscar_web("população Brasil 2026 IBGE")
resposta = modelo.sintetizar(plan, dados)
# Resultado: dado correto e com fonte

Isso já acontece com agentes de código. Quando o Claude Code precisa saber qual versão do React tem determinada API, ele não “lembra”: ele consulta a documentação real. E esse comportamento é infinitamente mais confiável do que confiar na memória de um treinamento que aconteceu meses atrás.

Alucinação: o problema que se resolve mudando a arquitetura, não o modelo

Aqui mora um dos insights mais contraintuitivos do paper. O Qwen3.5 de 4B e 9B parâmetros apresenta taxas de alucinação entre 80% e 82% em tarefas de conhecimento factual. Isso parece catastrófico. Mas pense por dois segundos.

Quando um fato está errado nos pesos do modelo, a única forma de corrigir é retreinar. Estamos falando de meses de trabalho, centenas de milhões de dólares e uma equipe inteira de engenheiros. É como se cada “bug factual” fosse um bug em firmware: você precisa flashar o chip inteiro para corrigir uma linha.

Agora, quando o fato vem de uma base de dados externa, corrigir é trivial. Atualizou a fonte, corrigiu o erro. É manutenção de software tradicional: você tem logs, versionamento, rollback. Tudo que a engenharia de software já sabe fazer há décadas.

“Factual errors baked into weights are unfixable without retraining. External knowledge bases allow addressable, correctable bugs.”

Trocar alucinação por retrieval não elimina erros (a fonte pode estar errada), mas transforma erros misteriosos e não-reproduzíveis em bugs rastreáveis e corrigíveis. Qualquer dev sabe que a segunda categoria é infinitamente mais gerenciável que a primeira.

IA frontier rodando na sua GPU: o que muda na prática

Essa é a parte que deixa qualquer dev empolgado. Se você remove a necessidade de armazenar conhecimento nos pesos, o modelo encolhe drasticamente. E modelos menores rodam em hardware acessível.

Hoje, uma placa de vídeo com 24GB de VRAM (uma RTX 4090 ou equivalente) já consegue rodar modelos de raciocínio com qualidade competitiva. O Qwen3.5 de 9B, por exemplo, cabe confortavelmente em 16GB quantizado. E estamos falando de um modelo que compete com o GPT-4 em raciocínio.

As implicações são enormes:

• Privacidade: seus dados nunca saem da sua máquina. Zero chamadas de API, zero logs em servidores de terceiros. Para quem trabalha com dados sensíveis (saúde, finanças, jurídico), isso é game changer.
• Custo: sem tokens por requisição. Roda 24/7 na sua máquina pelo custo da energia elétrica. Para startups e devs independentes, a conta fecha de um jeito que não fechava com APIs pagas.
• Latência: nada de esperar 3 segundos por uma resposta de API. Inferência local em GPUs modernas é praticamente instantânea para modelos desse tamanho.
• Personalização: fine-tuning de um modelo de 9B é viável com hardware de consumidor. Tente fazer isso com um modelo de 70B.

# Rodando Qwen3.5 9B localmente com llama.cpp
./llama-server -m qwen3.5-9b-q4_k_m.gguf \
  --ctx-size 32768 \
  --n-gpu-layers 99 \
  --port 8080

# Agora conecte suas ferramentas externas
# e você tem um agente de raciocínio local

A guerra de preços que ninguém esperava

Enquanto os modelos encolhem, as empresas de IA estão numa corrida para baixo nos preços. O Google lançou o Gemini 3.7 Flash esta semana com preço pela metade do Flash anterior. OpenAI e Anthropic estão cortando custos de inferência conforme competidores chineses ganham market share. O DeepSeek, por sua vez, aumentou os preços do V4 Pro em até 1.100% em certos workloads, mas manteve alternativas baratas.

Isso confirma a tese: o valor está migrando do modelo em si para o ecossistema ao redor. Quando o raciocínio vira commodity (modelos pequenos e baratos resolvem 90% dos problemas), o diferencial competitivo passa a ser:

1. Qualidade das ferramentas conectadas ao modelo
2. Velocidade de inferência (o novo tier ultrafast da OpenAI roda GPT-5.6 Sol 14x mais rápido)
3. Orquestração eficiente (a startup Writer alega reduzir consumo de tokens em 50% com melhor orquestração)

Não é mais sobre quem tem o modelo maior. É sobre quem monta o melhor pipeline.

O pesquisador que provou que raciocínio desbloqueia conhecimento

Um paper recente de Stanford com o título “Thinking to Recall” trouxe um plot twist interessante. Os pesquisadores descobriram que, paradoxalmente, modelos de raciocínio podem recuperar conhecimento factual melhor do que modelos otimizados para recall, desde que recebam o prompt certo.

A técnica se chama “factual priming”: antes de responder uma pergunta factual, o modelo gera contexto relevante, ativando caminhos na rede neural que estavam “adormecidos”. É como se o ato de pensar sobre o tema destravasse memórias que uma pergunta direta não conseguiria acessar.

Na prática:

# Pergunta direta (recall puro)
Q: "Qual foi a batalha decisiva da Guerra do Peloponeso?"
A: "A batalha de Thermopylae" ❌ (alucinação)

# Com factual priming (raciocínio ativado)
Q: "Pense sobre a Guerra do Peloponeso: quem eram os lados,
    quanto tempo durou, e qual foi a batalha decisiva?"
A: "A guerra entre Atenas e Esparta durou 27 anos...
    a batalha decisiva foi Aegospotami em 405 a.C." ✅

Isso sugere que o trade-off entre raciocínio e conhecimento não é tão binário quanto parece. Modelos de raciocínio não “esquecem” os fatos: eles precisam de mais contexto para acessá-los. E esse contexto pode vir tanto do próprio chain-of-thought quanto de fontes externas.

O que isso significa para devs que usam IA no dia a dia

Se você usa Claude, GPT, Gemini ou qualquer outro modelo no seu workflow de desenvolvimento, essa tendência muda algumas coisas:

Pare de esperar que o modelo saiba tudo. Ele não sabe, e essa é a direção correta. Em vez de ficar frustrado quando o modelo inventa uma API que não existe, monte um pipeline onde ele consulta a documentação real antes de responder.

Modelos locais estão cada vez mais viáveis. Se privacidade ou custo são preocupações, vale a pena testar um Qwen3.5 ou equivalente com ferramentas de retrieval. O gap de qualidade para os modelos frontier está diminuindo rápido, especialmente em tarefas de raciocínio e código.

Invista em tooling, não em modelo maior. O diferencial competitivo de um agente de IA não é qual modelo ele usa, mas quais ferramentas ele tem acesso. Um modelo mediano com acesso a documentação atualizada, linter, testes e CI/CD vai performar melhor que um modelo frontier sem ferramentas.

Alucinação vai virar um problema de infraestrutura, não de modelo. Conforme modelos delegam mais para retrieval, a qualidade das suas fontes de dados passa a ser o gargalo. Invista em boas bases de conhecimento, documentação atualizada e pipelines de retrieval robustos.

E agora, quem é o burro?

A ironia dessa história toda é que “burro” virou elogio no mundo dos LLMs. Um modelo que esquece quem inventou o telefone mas consegue derivar a fórmula de Black-Scholes do zero é, objetivamente, mais útil para quase qualquer tarefa profissional.

Fatos estão a um Google de distância. Raciocínio não.

Os labs de IA entenderam isso antes de todo mundo. E enquanto a gente fica reclamando que “o GPT não sabe mais quem é fulano”, eles estão construindo modelos que cabem no seu notebook e resolvem problemas que nenhum humano conseguiria resolver sozinho.

A pergunta não é se seu modelo sabe a capital da Mongólia. A pergunta é se ele consegue pensar. E pela primeira vez na história, modelos de 9 bilhões de parâmetros estão respondendo que sim.

Fonte de inspiração: Models Are Getting Dumber on Purpose