Intensivo Grátis 21–22/11Intensivo gratuito de 2 dias em Vibecoding (21–22/11 às 16:00 MSK) · Turma 3 começa 23/11Inscrever-se grátis →Turma 3 (23/11)
LançamentoAnálise · No radarHabr AI→ original

A mesma Gemma 4 escreveu um backend com 80% no opencode e apenas 41% no OpenHands

Dá para entregar a um modelo local um backend de verdade, com banco de dados, fila e regras de projeto? O autor testou 4 modelos abertos em 2 harnesses (programas-invólucro que dão ao agente um terminal e um editor): 8 pares, 3 execuções cada, 24 no total. A Gemma 4 no opencode passou em cerca de 80% das verificações, enquanto a mesma Gemma no OpenHands passou em apenas 41%. Ou seja, o que se deve escolher é a combinação "modelo + harness", e não só o modelo.

Processado por IA de Habr AI; editado por Hamidun News
A mesma Gemma 4 escreveu um backend com 80% no opencode e apenas 41% no OpenHands
Fonte: Habr AI. Colagem: Hamidun News.
Ouvir artigo
Ficha técnica e números-chave
ParâmetroDados
Fonte originalHabr AI ↗
Editor-chefe
Gemma no opencode72 minutos e 145 mil tokens; Qwen: 227 minutos e 596 mil
Dado-chave #2A melhor execução do Qwen marcou 96% e tropeçou apenas no linter
Dado-chave #3A verificação "o banco fica mudo, e /ready responde 503" foi cumprida em 2 das 24 execuções

Modelos locais de pesos abertos são cada vez mais oferecidos como alternativa aos da nuvem: o código não sai da máquina, e o custo não depende das tarifas de terceiros. Mas será que dá para entregar a um modelo desses não uma função de brinquedo, e sim um backend de verdade, com banco de dados, fila de mensagens e regras de projeto, e receber um código que funcione e também siga essas regras? O autor testou isso com quatro modelos e dois harnesses.

Harness é um programa-invólucro em volta do modelo: ele dá ao agente um terminal e um editor de arquivos e acompanha o andamento do trabalho. Cada um dos oito pares "modelo + harness" executou a tarefa três vezes, somando 24 execuções. A porcentagem do título é a fatia de verificações aprovadas (comportamento do serviço e cumprimento das regras do projeto), calculada como média dos cinco passos; para cada par, usa-se a mediana das três execuções.

A conclusão curta do autor: quase deu certo. Os melhores pares marcaram 80% e 79%, mas nenhum passou sem ao menos um apontamento.

O que foi testado e como

A tarefa é uma só: escrever do zero um serviço em FastAPI com PostgreSQL e RabbitMQ. Ela foi dividida em cinco passos, como faria um tech lead: esqueleto, API, regras de domínio, banco de dados e worker da fila. Em cada passo, o agente trabalha em uma sessão nova e continua o próprio código do passo anterior, então os erros se acumulam: se o serviço estiver quebrado no segundo passo, o terceiro começa em cima do que está quebrado. As regras do projeto ficam no arquivo AGENTS.md e descrevem uma arquitetura limpa com elementos de DDD.

A avaliação teve três camadas. A primeira são 68 testes ocultos, que acessam o serviço por HTTP e RabbitMQ; o agente não os vê. A segunda são 8 verificações gerais de regras: linter, tipos, fronteiras entre camadas, os próprios testes do agente passando e configurações intactas. A terceira é um LLM-juiz, o Claude Fable, com 22 critérios de arquitetura; sua nota entra como um número separado. Se uma verificação obrigatória falha (por exemplo, as migrações não são aplicadas a um banco vazio) ou o agente não termina um passo em 2 horas, o passo recebe zero.

O autor também validou os próprios testes: a solução de referência foi escrita pelo Claude Code, e foram criadas ainda 23 versões adulteradas dela. De início, os testes não pegavam tudo: no primeiro passo, 3 de 6 versões adulteradas passavam, e a versão com /ready respondendo em 62 segundos em vez de 5 recebia nota máxima. Os testes foram complementados. O juiz foi comparado com um segundo juiz, o GPT-5.6-Sol: as notas coincidiram exatamente em 27 de 30 casos.

Quem se saiu bem e como

Os modelos: Qwen3.8–27B, Gemma 4 31B, Nemotron 3 Super (um modelo MoE com 120 bilhões de parâmetros, dos quais 12 bilhões ativos) e Devstral 2 (123 bilhões de parâmetros). Os harnesses: o opencode, de terminal, e o OpenHands, uma plataforma mais pesada, com detector de loops.

  • Gemma no opencode: 80% (variação de 76% a 96%). Cada execução leva 72 minutos e 145 mil tokens. Ela passa em 81% das verificações nas três execuções seguidas. No OpenHands, o mesmo modelo marcou 41%, e as faixas de resultados das execuções não se sobrepõem.
  • Qwen no opencode: 79% (de 78% a 96%). Com essa variação, o autor trata a diferença de um centésimo como empate. A melhor execução passou em todas as verificações de comportamento e tropeçou apenas no linter, chegando a 96%; com um hook de pre-commit que roda o linter automaticamente, uma execução chegou a 99%. Mas cada execução leva 227 minutos e 596 mil tokens: o triplo do tempo e quatro vezes mais tokens que a Gemma. O juiz deu ao Qwen 87%, contra 77% da Gemma, mas nos testes os dois pares empatam. No caso do Qwen, 69% das verificações são aprovadas nas três execuções.
  • Qwen no OpenHands: 59%; todos os quatro passos zerados foram por estouro do limite de tempo.
  • Os demais pares têm medianas de 41% a 55%, e não é possível ordená-los entre si. O Devstral no opencode gasta apenas 114–188 mil tokens por execução, mas nos passos 4–5 o serviço dele não funciona em nenhuma das três execuções.

Onde os agentes falharam

A verificação mais difícil: o banco para de responder, as conexões continuam abertas, e o /ready precisa devolver 503 em 10 segundos. Apenas 2 das 24 execuções passaram; dos 22 fracassos, 17 foram travamentos. Em 15 deles, o código é quase idêntico: um timer do asyncio em volta de uma conexão do pool.

Parece correto, mas a saída do bloco continua esperando a resposta do servidor. Só o Qwen no opencode não confiou nisso e testou com um PostgreSQL falso, que aceita a conexão e fica mudo (cerca de 130 turnos de 169), e depois migrou para asyncpg puro com terminate(). A outra execução aprovada criava um engine novo a cada requisição, violando a regra "um engine por processo", e o teste não detecta isso.

A Gemma no OpenHands corrompia arquivos: o comando cat com heredoc sem aspas (<<EOF) duplicou o texto em 17 de 24 chamadas, enquanto com aspas (<<'EOF') isso não ocorreu nenhuma vez em 9. O Qwen e o Nemotron, no mesmo harness, sempre escrevem com aspas: 0 falhas em 97. Foram corrompidos 5 arquivos em 2 de 3 execuções. O agente percebeu o problema, mas repetiu o mesmo comando 4 vezes, e o detector de loops encerrou a sessão. O autor não investigou por que o terminal se comporta assim: trata-se de uma correlação.

A regra do harness mostrou-se mais forte que a regra do projeto. A tarefa exigia encerrar o passo com um commit, mas, depois da compactação de um histórico longo, a exigência sobrou apenas no resumo, e o prompt de sistema do opencode manda não fazer commit sem pedido explícito. Em 13 passos assim, o agente nunca chamou git commit. Mover a regra para o AGENTS.md ajudou em apenas 1 caso de 6. E, em uma execução da Gemma, o próprio agente danificou o histórico do git, e o juiz ficou sem snapshots do código.

O que fazer na prática

  • Avalie o par "modelo + harness", e não só o modelo.
  • Delegue as regras obrigatórias a ferramentas (linter, hooks), e não ao texto do prompt.
  • Não aceite testes verdes como prova: verifique se eles detectam código sabidamente quebrado.
História

Perguntas frequentes sobre a notícia

O que foi testado e como?

A tarefa é uma só: escrever do zero um serviço em FastAPI com PostgreSQL e RabbitMQ. Ela foi dividida em cinco passos, como faria um tech lead: esqueleto, API, regras de domínio, banco de dados e worker da fila. Em cada passo, o agente trabalha em uma sessão nova e continua o próprio código do passo anterior, então os erros se acumulam: se o serviço estiver quebrado no segundo passo, o terceiro começa em cima do que está quebrado.

O que se sabe sobre Quem se saiu bem e como?

Os modelos: Qwen3.8–27B, Gemma 4 31B, Nemotron 3 Super (um modelo MoE com 120 bilhões de parâmetros, dos quais 12 bilhões ativos) e Devstral 2 (123 bilhões de parâmetros). Os harnesses: o opencode, de terminal, e o OpenHands, uma plataforma mais pesada, com detector de loops. Gemma no opencode: 80% (variação de 76% a 96%). Cada execução leva 72 minutos e 145 mil tokens. Ela passa em 81% das verificações nas três execuções seguidas.

Onde os agentes falharam?

A verificação mais difícil: o banco para de responder, as conexões continuam abertas, e o /ready precisa devolver 503 em 10 segundos. Apenas 2 das 24 execuções passaram; dos 22 fracassos, 17 foram travamentos. Em 15 deles, o código é quase idêntico: um timer do asyncio em volta de uma conexão do pool. Parece correto, mas a saída do bloco continua esperando a resposta do servidor.

ZK
Zhemal Khamidun — CPO da Alpina Digital, gerente de produto do AlpinaGPT. Cria produtos de IA desde 2019. O Hamidun News é um projeto pessoal que virou um agregador em produção com mais de 6.000 leitores.
✦ Unified AI Workspace · Nomad

Test Frontier LLMs & Autonomous Agents in One Workspace

Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.

Try Nomad AI →Launch Nomad Agent
O que você acha?
Carregando comentários…