Key Takeaways
- O Qwen 3.6 27B lidera: 92,1% HumanEval, 77,2% SWE-bench, 84,3% MBPP — os melhores valores nos três benchmarks localmente.
- O DeepSeek Coder é o vencedor em custo de nuvem: US$ 0,14/1M tokens, 0,5 pp atrás do Qwen no HumanEval. Use-o para código público não sensível em escala.
- O Mistral Devstral se destaca em tarefas agênticas: melhor em uso de ferramentas de várias etapas e refatoração multiarquivo do que suas pontuações brutas sugerem.
- Latência: o Qwen 3.6 27B em Q4_K_M roda a 35 tokens/seg em uma RTX 4090. O Devstral em 14 GB a 40 tokens/seg. A latência da API do DeepSeek Coder depende da rede (~50–200 ms até o primeiro token).
- Estratégia de despacho: tarefas de código sensíveis/GDPR → Qwen 3.6 local, tarefas não sensíveis de alto volume → API do DeepSeek Coder, refatoração agêntica → Devstral local.
Por que os modelos locais de código alcançaram os da nuvem
Durante os três primeiros anos da era dos LLMs, os modelos em nuvem superavam os locais em todos os benchmarks de código por 10–20 pontos percentuais. Essa diferença foi fechada em 2025–2026, quando os modelos de pesos abertos escalaram para a faixa de 27–72B parâmetros com treinamento específico em código sobre grandes corpora.
O Qwen 3.6 27B, lançado em abril de 2026, atinge 77,2% no SWE-bench — um benchmark que testa se os modelos conseguem resolver issues reais do GitHub em bases de código open source. Essa pontuação se compara diretamente ao Claude Sonnet 4.6 (~72%) e ao GPT-5.5 (~73%), ambos significativamente maiores e disponíveis apenas na nuvem. A chave arquitetural é que o pré-treinamento focado em código filtrado (a Alibaba publicou 3T de tokens de código para o Qwen 3) compensa a diferença no número de parâmetros.
Três fatores impulsionaram a convergência: (1) dados de treinamento de código de alta qualidade em escala, (2) RLHF ajustado em tarefas reais de engenharia de software em vez de seguimento genérico de instruções, e (3) quantização GGUF aprimorada que preserva melhor a capacidade de codificação em precisão Q4 do que os métodos anteriores.
O Qwen 3.6 27B atinge 77,2% no SWE-bench localmente — igualando ou superando o Claude Sonnet 4.6 e o GPT-5.5 na resolução real de issues do GitHub.
O SWE-bench testa se uma IA consegue realmente corrigir bugs em bases de código open source reais como Django, Flask e NumPy. Uma pontuação de 77,2% significa que o modelo resolveu 77 de 100 issues reais do GitHub sem ajuda humana.
Tabela de benchmarks
Todas as pontuações são números publicados em maio de 2026 em páginas oficiais dos modelos ou em leaderboards abertos. O HumanEval usa a métrica pass@1. O SWE-bench usa a taxa de aprovação de testes verificados. O MBPP usa pass@1 no conjunto de testes completo do MBPP.
| Benchmark | Qwen 3.6 27B | DeepSeek Coder | Mistral Devstral 24B | Codestral 22B |
|---|---|---|---|---|
| HumanEval (Python, pass@1) | 92.1% | 91.6% | 90.1% | 88.9% |
| SWE-bench (issues do GitHub) | 77.2% | ~75% | ~73% | N/A |
| MBPP (problemas Python) | 84.3% | 82.7% | 81.4% | 79.2% |
| Multilíngue (Java, Go, Rust) | 88.4% | 87.1% | 84.6% | 83.1% |
📌Note: As pontuações de SWE-bench para o DeepSeek Coder e o Mistral Devstral são estimadas a partir dos dados de leaderboard disponíveis. As pontuações de SWE-bench do Qwen 3.6 27B e do Codestral são de publicações oficiais.
💡Tip: A linha de modelos da DeepSeek evolui com frequência. Verifique o nome do modelo atual e o preço em platform.deepseek.com antes da implantação. Os números refletem dados publicamente disponíveis em maio de 2026.
Matemática de custo por token
A economia dos LLMs de código depende do volume de uso, da sensibilidade das tarefas e do overhead de infraestrutura. A seguir estão projeções de custo em diferentes volumes diários de tokens para um desenvolvedor individual. Observação: o modelo de custo é ancorado em USD porque a API do DeepSeek Coder é cobrada em dólar; os custos de eletricidade são apresentados para referência (no Brasil, ~R$ 0,80/kWh, variando por distribuidora e bandeira tarifária).
A 5M tokens/dia (sessão intensa de codificação: autocomplete, geração de testes, revisão de código), a API em nuvem do DeepSeek Coder custa aproximadamente US$ 0,70/dia às taxas habituais. Em um ano de trabalho (250 dias), isso dá ~US$ 175/ano por desenvolvedor para tarefas não sensíveis. Uma RTX 4090 (US$ 1.500–2.000; ~R$ 11.000–13.000 no varejo brasileiro) rodando o Qwen 3.6 27B local atinge o ponto de equilíbrio em alguns anos — mas o equilíbrio muda drasticamente para equipes e código sensível ao GDPR.
Para uma equipe de 10 gerando 50M tokens/dia: a API em nuvem custa ~US$ 7/dia (~US$ 1.750/ano). Um sistema RTX 4090 para 2 desenvolvedores (US$ 3.000 no total; ~R$ 20.000 no Brasil) atinge o equilíbrio em menos de 2 anos, com conformidade total ao GDPR e custo zero por token a partir de então.
# Calculadora de custos: matemática por token para LLMs de código
# Premissas: razão entrada + saída 1:2, taxa combinada efetiva
# Modelo ancorado em USD (API DeepSeek cobrada em dólar)
# DeepSeek Coder (nuvem)
input_rate = 0.14 # US$/1M tokens (aproximado)
output_rate = 0.28 # US$/1M tokens (aproximado para deepseek-chat)
blended = (input_rate + 2 * output_rate) / 3 # ~US$0.23/1M combinado
daily_tokens = 5_000_000 # 5M tokens/dia por desenvolvedor
daily_cost = (daily_tokens / 1_000_000) * blended # US$1.15/dia
annual_cost = daily_cost * 250 # US$287/ano por desenvolvedor
# Qwen 3.6 27B local (RTX 4090)
hardware_cost = 1800 # US$ (GPU RTX 4090; ~R$ 11.000-13.000 no varejo brasileiro)
# Eletricidade no Brasil: ~R$ 0,80/kWh (350W -> ~R$ 2.450/ano em uso continuo)
annual_local = 0 # custo por token zero apos o hardware (eletricidade a parte)
# Equilibrio vs DeepSeek a 5M tokens/dia: hardware_cost / annual_cost ~ poucos anos para 1 devA realidade da latência
A latência importa para a codificação interativa: o autocomplete fica inutilizável acima de 500 ms, a revisão de código é aceitável até 3 s, as tarefas em lote são insensíveis à latência. Os números a seguir são estimativas de benchmarks da comunidade e testes internos, não medições oficiais dos fabricantes.
| Modelo | Primeiro token (ms) | Sustentado (tok/seg) | Codificação interativa? |
|---|---|---|---|
| Qwen 3.6 27B Q4_K_M (RTX 4090) | 80–120 | ~35 | ✅ Sim |
| Qwen 3.6 27B Q4_K_M (Apple M4 Max 48 GB) | 50–80 | ~42 | ✅ Sim |
| Mistral Devstral 24B Q4_K_M (RTX 4090) | 60–100 | ~40 | ✅ Sim |
| DeepSeek Coder (API, latência UE) | 150–400 | 80–120 | ⚠️ Marginal |
| Qwen 3.6 27B Q8_0 (dual RTX 3090) | 100–150 | ~25 | ✅ Sim (com compromisso de qualidade) |
Os números de latência são estimativas de benchmarks da comunidade e testes, não medições oficiais dos fabricantes. A latência da API da DeepSeek a partir da UE (Frankfurt) até os servidores da DeepSeek varia conforme a carga; 400 ms até o primeiro token é comum em horários de pico. Para fluxos de autocomplete, a inferência local é sistematicamente mais rápida.
⚠️Warning: O num_ctx padrão do Ollama (2048) aumenta a vazão aparente (menos tokens a processar), mas trunca o contexto. Defina num_ctx 32768 para medições precisas de latência de codificação.
Requisitos de hardware
- Qwen 3.6 27B Q4_K_M: 16 GB de VRAM — RTX 4080 (16 GB), RTX 3090 (24 GB), RTX 4090 (24 GB), Apple M3/M4/M5 Max 48 GB
- Mistral Devstral Small 24B Q4_K_M: 14 GB de VRAM — RTX 4070 Ti Super (16 GB), RTX 3090 (24 GB), Apple M3/M4/M5 Pro 36 GB
- Codestral 22B Q4_K_M: 13 GB de VRAM — RTX 4070 Ti (12 GB marginal, 16 GB recomendado)
- Rodar dois modelos simultaneamente: uma RTX 4090 de 24 GB pode hospedar Qwen 3.6 27B Q4_K_M + Devstral 24B Q4_K_M em uma configuração dual-GPU de 48 GB. O Apple M5 Max (128 GB de memória unificada, 460–614 GB/s de largura de banda) roda confortavelmente os dois modelos ao mesmo tempo via MLX.
- Recomendação Apple Silicon: o M5 Pro (64 GB de memória unificada) roda o Qwen 3.6 27B a ~48 tokens/seg via MLX. O M5 Max (128 GB) atinge ~55 tokens/seg para o Qwen e consegue rodar Qwen + Devstral ao mesmo tempo — a opção mais silenciosa e eficiente em energia. O M4 Pro com 48 GB também é adequado a 42 tokens/seg.
# Configuração do Ollama para Qwen 3.6 27B com num_ctx e camadas de GPU
cat > Modelfile-qwen3-coder <<'EOF'
FROM qwen3-coder:27b
PARAMETER num_ctx 32768
PARAMETER num_gpu 1
PARAMETER num_thread 8
PARAMETER temperature 0.2
SYSTEM "You are an expert software engineer. Respond with clean, well-structured code."
EOF
ollama create qwen3-coder-local -f Modelfile-qwen3-coder
ollama run qwen3-coder-localEstratégia de despacho multimodelo
Nenhum modelo de código vence em todas as tarefas. O Qwen 3.6 27B lidera em precisão de benchmarks. O Devstral lidera em tarefas agênticas multiarquivo. O DeepSeek Coder é o mais barato em escala para código não sensível. Uma camada de despacho que roteia as tarefas por tipo captura os benefícios dos três.
Uma matriz de despacho sugerida para uma equipe de desenvolvimento:
| Tipo de tarefa | Modelo recomendado | Por quê |
|---|---|---|
| Código privado/GDPR (dados de clientes) | Qwen 3.6 27B (local) | Conformidade com GDPR por design |
| Autocomplete (interativo) | Devstral 24B (local) | Saída sustentada mais rápida, 40 tok/seg |
| Revisão de código (não sensível) | DeepSeek Coder (API) | US$ 0,14/1M, boa qualidade, alta vazão |
| Refatoração complexa (multiarquivo) | Qwen 3.6 27B (local) + consenso PromptQuorum | Melhor SWE-bench, seguro para GDPR |
| Geração de testes em lote | DeepSeek Coder (API) | Otimizado em custo para volume não sensível |
Integração com o PromptQuorum
O PromptQuorum roteia as tarefas de código entre o Qwen local, o Devstral local e APIs em nuvem conforme regras de classificação que você define. Isso elimina a troca manual de modelos e implementa automaticamente a matriz de despacho acima.
O PromptQuorum roteia as tarefas de código para o Qwen 3.6 local em código sensível ao GDPR e para o DeepSeek Coder na geração em volume não sensível.
# Configuração de roteamento do PromptQuorum para cargas de trabalho de código
# Defina nas configurações do PromptQuorum ou no arquivo .env
# Modelos locais (via Ollama)
LOCAL_OLLAMA_URL=http://localhost:11434/v1
LOCAL_CODING_MODEL=qwen3-coder-local # Qwen 3.6 27B com num_ctx 32768
LOCAL_AUTOCOMPLETE_MODEL=devstral # Mistral Devstral 24B
# Fallback em nuvem
DEEPSEEK_API_KEY=sua_chave_aqui
DEEPSEEK_MODEL=deepseek-chat
# Regras de roteamento (despacho PromptQuorum)
# route: task_contains("private") OR task_contains("customer") -> qwen3-coder-local (local)
# route: task_type == "autocomplete" -> devstral (local)
# route: token_count > 50000 -> deepseek-chat (nuvem, apenas nao sensivel)
# default -> qwen3-coder-local (local)Perguntas frequentes
O Qwen 3.6 27B é melhor que o DeepSeek Coder para codificação local?
Para implantação local: o Qwen 3.6 27B atinge 77,2% no SWE-bench (verificado) e roda inteiramente local em 16 GB de VRAM, tornando-o conforme ao GDPR para equipes da UE. O DeepSeek Coder é uma API em nuvem que custa ~US$ 0,14/1M tokens de entrada — a melhor opção para geração de código público não sensível em alto volume, quando não há hardware local disponível. A escolha certa depende da sensibilidade dos seus dados e do orçamento, não de um único vencedor.
O que é o Mistral Devstral e por que ele é mencionado aqui?
O Mistral Devstral Small 24B é um modelo orientado a código da Mistral AI, lançado em maio de 2026, projetado especificamente para tarefas de codificação agêntica — refatoração multiarquivo, uso de ferramentas e geração iterativa de código. Atinge 90,1% no HumanEval e roda em 14 GB de VRAM. É especialmente forte em tarefas que exigem várias operações de código sequenciais, em que seu treinamento agêntico lhe dá vantagem sobre as pontuações brutas do Qwen 3.6 27B.
Posso rodar o Qwen 3.6 27B e o Devstral 24B simultaneamente?
Em uma única RTX 4090 (24 GB de VRAM), não — o Qwen 3.6 27B Q4_K_M usa ~15,8 GB e o Devstral 24B Q4_K_M usa ~14,2 GB, somando ~30 GB. Você precisaria de uma configuração dual-GPU (duas RTX 3090 ou duas RTX 4090) ou de Apple Silicon com 96+ GB de memória unificada. A solução prática é usar um modelo por vez e alternar via Ollama, o que leva ~5 segundos em uma RTX 4090.
É seguro usar o DeepSeek Coder para código de empresa da UE?
O DeepSeek Coder processa dados nos servidores da DeepSeek AI, uma empresa constituída na China. A Comissão Europeia não emitiu uma decisão de adequação para a China. Usar o DeepSeek Coder com dados pessoais da UE ou código-fonte proprietário que contenha informações pessoais exige análise jurídica de conformidade com o Artigo 44 do GDPR. Para código proprietário sem dados pessoais, consulte sua equipe jurídica. Para tratamento de dados pessoais, o Qwen 3.6 27B local é a alternativa em conformidade.
O que é o SWE-bench e por que focar nele?
O SWE-bench (benchmark de Engenharia de Software) testa se um LLM consegue resolver issues reais do GitHub em bases de código open source como Django, Flask e NumPy. Mede a capacidade prática de engenharia de software em vez da codificação a nível de função isolada. O Qwen 3.6 27B atinge 77,2% no SWE-bench Verified, a métrica de codificação real mais confiável disponível atualmente.