A Alibaba acabou de soltar uma bomba no mundo da IA open source — e dessa vez, os números não mentem.

O Qwen3.6-35B-A3B é um modelo com 35 bilhões de parâmetros totais, mas que ativa apenas 3 bilhões durante a inferência. E mesmo assim, está destruindo modelos densos que são 10 vezes maiores em tarefas de código e raciocínio. Não é exagero: no SWE-bench Verified, ele marca 73.4 pontos contra 52.0 do Gemma4-31B do Google, um modelo que precisa de todos os seus 31 bilhões de parâmetros o tempo todo.

Eu acompanho a corrida dos modelos open source há anos, e posso dizer: esse é o momento em que a eficiência deixou de ser uma promessa e virou realidade — algo que já vimos com modelos de 1-bit rodando em 1GB de RAM.

O que é Mixture of Experts (e por que isso importa agora)

Antes de entrar nos benchmarks, vale entender o mecanismo que faz o Qwen3.6 funcionar tão bem com tão pouco.

Mixture of Experts (MoE) é uma arquitetura onde o modelo tem centenas de “especialistas” — sub-redes dentro da rede principal — mas só ativa uma fração deles para cada token processado. É como ter uma equipe de 256 engenheiros, mas só chamar 9 para resolver cada problema específico.

No caso do Qwen3.6-35B-A3B:

A sacada aqui é que cada token de entrada passa por um roteador que decide quais 8 especialistas (mais 1 compartilhado) são os mais relevantes para aquele contexto. Os outros 247 especialistas ficam dormindo, economizando memória e computação.

Na prática? Você roda um modelo com a inteligência de 35B, mas com o custo computacional de 3B. Isso muda completamente a equação de custo para quem quer rodar IA localmente ou em produção.

Gated Delta Networks: a arquitetura híbrida que ninguém esperava

O Qwen3.6 não é um transformer convencional. Ele usa uma arquitetura chamada Gated Delta Networks, que mistura atenção linear com atenção completa em um padrão alternado.

A estrutura de cada bloco de 4 camadas segue essa fórmula:

3 × (Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE)

Traduzindo: para cada 4 camadas, 3 usam atenção linear (mais rápida e mais eficiente em memória) e apenas 1 usa atenção completa (mais expressiva, mas mais cara). São 10 repetições desse bloco, totalizando as 40 camadas.

Por que isso é inteligente? Atenção linear escala de forma sub-quadrática com o tamanho do contexto, enquanto a atenção completa escala quadraticamente. Ao usar atenção completa apenas em 25% das camadas, o modelo mantém a capacidade de capturar dependências de longo alcance sem o custo proibitivo de fazê-lo em todas as camadas.

Na camada de Gated DeltaNet, temos:

• 32 cabeças de atenção linear para valores (V)
• 16 cabeças para queries e keys (QK)
• Dimensão de cada cabeça: 128

Na camada de Gated Attention (a cada 4):

• 16 cabeças de query (Q)
• 2 cabeças de key-value (KV) — o famoso Grouped Query Attention
• Dimensão de cada cabeça: 256
• Rotary Position Embedding com dimensão 64

Essa combinação é o que permite ao modelo processar contextos de 262K tokens nativamente — e até 1 milhão com scaling via YaRN — sem explodir a conta de VRAM.

Os benchmarks que importam (com números reais)

Chega de teoria. O bicho pega quando olhamos os benchmarks, especialmente em tarefas de coding agent — que é onde o Qwen3.6 realmente brilha.

Coding Agent

No SWE-bench Verified — que testa a capacidade de resolver issues reais de repositórios open source — o Qwen3.6 tem uma vantagem de 21.4 pontos sobre o Gemma4-31B. Isso não é marginal. É demolição.

O Terminal-Bench 2.0, que avalia tarefas de terminal em cenários agênticos (o modelo precisa navegar, executar comandos, debugar), mostra a mesma história: 51.5 contra 42.9.

Raciocínio e Matemática

Um score de 92.7 no AIME 2026 — uma competição de matemática de nível olímpico — com apenas 3B de parâmetros ativos é absurdo. Para colocar em perspectiva: modelos densos que precisam de 70B+ parâmetros lutam para atingir esses números.

Visão e Multimodalidade

O Qwen3.6 não é apenas texto. Ele processa imagens e vídeos nativamente:

O RefCOCO, que mede inteligência espacial, marca 92.0 — superando o Claude Sonnet 4.5 da Anthropic. Um modelo open source de 3B ativos batendo um dos melhores modelos proprietários em compreensão visual. Deixa isso assentar.

Como rodar o Qwen3.6 localmente

Aqui é onde a coisa fica realmente interessante para quem quer sair da dependência de APIs pagas.

Opção 1: vLLM (recomendado para produção)

# Instalação
pip install vllm>=0.19.0

# Servir o modelo
vllm serve Qwen/Qwen3.6-35B-A3B \
  --port 8000 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --reasoning-parser qwen3

Com tensor parallelism em 8 GPUs, você consegue rodar o modelo com contexto completo de 262K tokens. Mas como ele ativa apenas 3B, a latência é surpreendentemente baixa.

Opção 2: SGLang (melhor throughput)

python -m sglang.launch_server \
  --model-path Qwen/Qwen3.6-35B-A3B \
  --port 8000 \
  --tp-size 8 \
  --mem-fraction-static 0.8 \
  --context-length 262144 \
  --reasoning-parser qwen3

O SGLang tem uma vantagem interessante: suporte nativo a Multi-Token Prediction, que acelera a geração usando decoding especulativo:

python -m sglang.launch_server \
  --model-path Qwen/Qwen3.6-35B-A3B \
  --port 8000 \
  --tp-size 8 \
  --speculative-algo NEXTN \
  --speculative-num-steps 3 \
  --speculative-eagle-topk 1 \
  --speculative-num-draft-tokens 4

Opção 3: GGUF para hardware mais modesto

Para quem não tem 8 GPUs, a Unsloth já disponibilizou versões GGUF quantizadas no Hugging Face. Com quantização Q4_K_M, o modelo cabe em hardware bem mais acessível — embora com alguma perda de qualidade.

# Via Ollama (quando disponível)
ollama run qwen3.6-35b-a3b

# Via llama.cpp
./llama-server -m qwen3.6-35b-a3b-q4_k_m.gguf \
  --ctx-size 8192 \
  --n-gpu-layers 40

Usando como API compatível com OpenAI

Uma vez rodando localmente, a integração é trivial:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="Qwen/Qwen3.6-35B-A3B",
    messages=[
        {"role": "user", "content": "Refatore essa função para usar async/await"}
    ],
    max_tokens=81920,
    temperature=0.6,  # recomendado para coding
    top_p=0.95,
    extra_body={"top_k": 20}
)

Agentes de código: onde o Qwen3.6 muda o jogo

A real é que benchmarks sintéticos contam só metade da história. O que torna o Qwen3.6 especial é seu desempenho como coding agent — um modelo que não só gera código, mas navega repositórios, lê arquivos, executa testes e resolve problemas de forma autônoma.

O modelo já vem com suporte nativo a tool calling:

# vLLM com tool calling habilitado
vllm serve Qwen/Qwen3.6-35B-A3B \
  --port 8000 \
  --tensor-parallel-size 8 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder

E se integra nativamente com o framework Qwen-Agent, incluindo suporte a MCP (Model Context Protocol):

from qwen_agent.agents import Assistant

tools = [
    {'mcpServers': {
        "filesystem": {
            "command": "npx",
            "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/repo"]
        }
    }}
]

bot = Assistant(
    llm={'model': 'Qwen3.6-35B-A3B', 'model_server': 'http://localhost:8000/v1'},
    function_list=tools
)

Com MCP, o modelo pode navegar o filesystem, executar comandos, ler documentação — tudo de forma autônoma. É exatamente o tipo de integração que frameworks como Claude Code e Cursor usam internamente, mas agora disponível para qualquer um com hardware suficiente.

Modo Thinking: raciocínio estendido

O Qwen3.6 suporta um “modo de pensamento” onde ele raciocina internamente antes de responder — similar ao que o Claude faz com seus thinking blocks. Você pode ativar ou desativar:

# Com thinking (padrão para tarefas complexas)
response = client.chat.completions.create(
    model="Qwen/Qwen3.6-35B-A3B",
    messages=messages,
    max_tokens=81920,
    temperature=1.0,
    extra_body={
        "top_k": 20,
        "chat_template_kwargs": {"enable_thinking": True}
    }
)

# Sem thinking (respostas mais rápidas)
response = client.chat.completions.create(
    model="Qwen/Qwen3.6-35B-A3B",
    messages=messages,
    max_tokens=32768,
    temperature=0.7,
    extra_body={
        "top_k": 20,
        "chat_template_kwargs": {"enable_thinking": False}
    }
)

Contexto de 1 milhão de tokens (e como ativar)

O contexto nativo de 262K tokens já é generoso, mas o Qwen3.6 vai além. Com YaRN scaling, você estende para mais de 1 milhão de tokens:

VLLM_ALLOW_LONG_MAX_MODEL_LEN=1 vllm serve Qwen/Qwen3.6-35B-A3B \
  --hf-overrides '{"text_config": {"rope_parameters": {
    "rope_type": "yarn",
    "rope_theta": 10000000,
    "factor": 4.0,
    "original_max_position_embeddings": 262144
  }}}' \
  --max-model-len 1010000

1 milhão de tokens equivale a aproximadamente 750.000 palavras — ou cerca de 10 livros técnicos completos. Com 3B de parâmetros ativos. Isso é território que, até pouco tempo atrás, era exclusivo de modelos proprietários como o Gemini.

O elefante na sala: custo vs. performance

Vamos fazer uma conta rápida. Se você usa a API do Claude Sonnet para tarefas de coding agent, está pagando por milhões de tokens de entrada e saída. Com o Qwen3.6 rodando localmente:

• Custo de inferência: zero (além da eletricidade e hardware)
• Latência: controlável, sem depender de terceiros
• Privacidade: seus dados nunca saem do seu servidor
• Disponibilidade: sem rate limits, sem downtime de API

O trade-off? Você precisa de hardware. Para rodar o modelo completo em FP16, são necessárias múltiplas GPUs. Mas com quantização GGUF (Q4), o modelo cabe em configurações muito mais modestas — e a versão quantizada ainda mantém a maior parte da qualidade, especialmente para tarefas de código.

Para empresas que processam grandes volumes de código — code review automatizado, geração de testes, migração de bases legadas — a economia pode ser brutal. Estamos falando de modelos que custavam centenas de milhares de dólares por mês em APIs e agora podem rodar em um cluster de GPUs com custo fixo.

Qwen3.6 vs. o predecessor: o salto geracional

O Qwen3.5-35B-A3B, lançado há poucos meses, já era impressionante. Mas o 3.6 mostra que o time da Alibaba/Qwen está iterando rápido:

• Frontend workflows melhorados significativamente
• Raciocínio a nível de repositório mais fluente e preciso
• Suporte multimodal (imagem e vídeo) nativo
• Multi-Token Prediction para inferência mais rápida
• Melhorias em todas as métricas de coding agent

Não é um bump incremental de versão. É um salto qualitativo que coloca o modelo em outro patamar.

Licença Apache 2.0: a cereja do bolo

Tudo isso sob licença Apache 2.0. Sem restrições comerciais, sem cláusulas de uso aceitável que mudam de um dia para o outro, sem medo de que a Alibaba resolva fechar o código amanhã — como a Meta fez com o Llama. Você pode pegar o modelo, fine-tunar para o seu caso de uso, empacotar em um produto comercial e vender.

Compare com o cenário proprietário: o Claude, o GPT e o Gemini são caixas pretas que podem mudar preços, termos de serviço ou performance a qualquer momento. O Qwen3.6 está no Hugging Face, nos pesos, pronto para ser auditado, modificado e rodado em qualquer infraestrutura.

O que isso significa para o ecossistema de IA

A mensagem do Qwen3.6 é clara: modelos menores e mais eficientes não são mais compromissos — são vantagens competitivas. A era de “quanto maior melhor” está dando espaço para “quanto mais esperto, melhor”. E quando um modelo de 3B ativos empata ou supera modelos de 30B+ em tarefas práticas, a pergunta muda de “qual modelo tem mais parâmetros?” para “qual modelo resolve meu problema de forma mais eficiente?”

Esse é um shift que beneficia todo mundo: pesquisadores com orçamento limitado, startups que não podem pagar $100K/mês em APIs, e empresas que precisam de IA on-premise por questões de compliance.

Quem deveria prestar atenção

Se você se encaixa em alguma dessas categorias, o Qwen3.6 merece sua atenção imediata:

• Startups de developer tools que querem coding AI sem depender de APIs externas
• Empresas com dados sensíveis que não podem enviar código para servidores terceiros
• Pesquisadores que precisam de um modelo state-of-the-art para fine-tuning
• DevOps/SRE que querem automação inteligente de infraestrutura
• Hobbyistas que querem a melhor IA open source rodando no próprio hardware

O Qwen3.6-35B-A3B está disponível agora no Hugging Face, com versões GGUF quantizadas pela Unsloth e suporte nos principais frameworks de inferência. A corrida pela IA open source eficiente acaba de ganhar um novo líder — e dessa vez, ele cabe no seu bolso.

Fonte de inspiração: Qwen3.6-35B-A3B: Agentic coding power, now open to all — Qwen Team