Imagina abrir o terminal, digitar um comando e ter um modelo de IA com 125 bilhões de parâmetros respondendo a 100 tokens por segundo. Na sua placa de vídeo de gamer. Sem cloud, sem API key, sem pagar centavos por token.

Parece mentira, mas o Strata acabou de provar que isso é possível. E a comunidade do Hacker News pirou.

O que é o Qwen 3.8 Flash Next (e por que 125B importa)

Antes de falar do Strata, precisa entender o modelo que ele roda. O Qwen 3.8 Flash Next é o mais recente da Alibaba Cloud, e não é um modelo qualquer: são 125 bilhões de parâmetros totais, com uma arquitetura Mixture-of-Experts (MoE) que ativa apenas 6 bilhões por token gerado.

Na prática, isso significa que o modelo é enorme em conhecimento, mas leve na execução. A cada token que ele gera, só 10 dos 24.576 especialistas internos são acionados. É como ter um escritório com 24 mil funcionários, mas cada pergunta só precisa de 10 para ser respondida.

Os benchmarks oficiais impressionam:

O contexto nativo é de 262.144 tokens, extensível até 1 milhão com compressão YaRN. Isso coloca o Qwen 3.8 Flash Next no mesmo campeonato que GPT-4 e Claude Sonnet, mas com uma diferença brutal: ele é open-weight e roda local.

Strata: o motor que fez o impossível

O Strata é um engine de inferência open source, escrito em C++, com licença MIT. O repositório no GitHub tem 16 dias de vida e já acumula quase 8 mil stars e 700 forks. E por uma razão simples: ele consegue rodar um modelo de 125 bilhões de parâmetros numa placa de vídeo com 12 GB de VRAM.

A mágica está na arquitetura de memória em camadas que o Strata implementa. Em vez de tentar enfiar o modelo inteiro na GPU (o que exigiria centenas de gigabytes de VRAM), ele distribui o trabalho por todo o hardware do seu PC:

• GPU (VRAM): Mantém os especialistas mais usados (“hot experts”) na memória da placa
• RAM do sistema: Todos os 24.576 especialistas ficam pinados na RAM
• CPU: Processa os cache misses quando um especialista não está na GPU
• SSD: Armazena uma tabela de embeddings n-gram de 28.8 GB acessada conforme necessário

Cada gigabyte extra de RAM comporta aproximadamente 700 especialistas a mais no cache. Então a diferença entre 32 GB e 64 GB de RAM é literalmente a diferença entre uma experiência sofrível e uma experiência que rivaliza com APIs na nuvem.

Benchmarks reais: quanto isso é rápido de verdade?

Eu sei que número de marketing é fácil de inflar, então vamos aos dados reais que a comunidade já verificou.

RTX 5070 (12 GB VRAM, sistema de referência)

A ingestão de prompt atinge 2.171 tokens por segundo em contexto de 32K. Ou seja, você cola um arquivo de código enorme e o modelo engole em segundos.

RTX 4070 (12 GB VRAM, teste independente)

Um teste independente mediu 53.2 tok/s em contexto de 60K tokens. Para comparar: o llama.cpp na mesma GPU e mesmo modelo ficou em 27.06 tok/s. O Strata foi quase o dobro.

RTX 3090 (24 GB VRAM)

Com mais VRAM, a coisa fica selvagem. Estimativas colocam o desempenho em curto contexto por volta de 140 tok/s. Na variante Coder, o benchmark registrou 99 tok/s em contexto de 198K tokens. Leu certo: 198 mil tokens de contexto rodando a quase 100 tokens por segundo numa placa que você compra na Kabum.

RTX 4090 (24 GB VRAM)

A queridinha dos gamers e devs de IA alcança mais de 100 tok/s facilmente, chegando a 140 tok/s em contextos curtos. É o sweet spot entre preço, disponibilidade e performance.

Como o Strata consegue essa velocidade

Três técnicas se complementam para atingir esses números absurdos.

1. Expert offloading inteligente

Diferente de um offloading bruto (que simplesmente joga camadas inteiras para a CPU), o Strata faz offloading por especialista. Como o modelo MoE ativa poucos especialistas por token, o engine aprende quais são os mais requisitados e os mantém na GPU. Os demais ficam na RAM, prontos para serem chamados quando necessário.

É uma estratégia que só funciona porque a arquitetura MoE é inerentemente esparsa. Num modelo denso como o Llama, cada token usa todos os parâmetros, então não existe “especialista quente” para priorizar.

2. Speculative decoding com multi-token prediction

O Strata usa uma cabeça de predição multi-token que rascunha 3 tokens de uma vez. A taxa de aceitação fica entre 2.4 e 3.2 tokens por passada, o que significa que a maioria dos rascunhos é aproveitada.

Pense assim: em vez de gerar um token, validar, gerar outro, validar… o modelo chuta três de uma vez e acerta quase todos. O resultado é uma aceleração de 1.6x a 1.8x comparada à geração sequencial.

Tem ainda o prompt lookup, que acelera edições de código repetitivas em 6% a 11%. Não parece muito, mas quando você está iterando sobre o mesmo arquivo dezenas de vezes, cada segundo importa.

3. Processamento em chunks de 2.048 tokens

Prompts longos são ingeridos em blocos de 2.048 tokens, atingindo throughput acima de 1.000 tok/s durante o prefill. Isso explica por que o modelo “engole” contextos enormes rapidamente, mas a geração token a token é naturalmente mais lenta (já que é sequencial por natureza).

Strata vs. llama.cpp: qual usar?

Essa é a pergunta que todo mundo está fazendo. O llama.cpp é o veterano da inferência local, estável, com suporte a milhares de modelos GGUF. O Strata é o novato agressivo. Aqui vai uma comparação honesta:

A recomendação prática: se você quer rodar especificamente o Qwen 3.8 Flash Next com máxima performance, Strata é imbatível. Se você precisa de flexibilidade para testar diferentes modelos, llama.cpp continua sendo o canivete suíço.

E nada impede usar os dois. O Strata expõe endpoints compatíveis com as APIs da OpenAI e Anthropic em localhost. Então você pode apontar suas ferramentas (como o Claude Code, Cursor, ou qualquer client OpenAI) para http://127.0.0.1:8080 e pronto.

Requisitos de hardware: o que você realmente precisa

Vamos ser diretos. O Strata tem requisitos mínimos e recomendados bem definidos:

A variante Coder do modelo cabe em 32 GB de RAM, com 256/512 especialistas em vez dos 24.576 originais. Ela retém 91.3% do score do modelo completo no SWE-bench Verified, uma troca aceitável se você tem pouca memória.

Evite a tentação de rodar o modelo quantizado UD-Q4_K_XL do Unsloth: precisa de 111 GB e rasteja a 7 a 8.5 tok/s lendo do SSD num PC com 64 GB. Não vale a pena.

Instalação em 5 minutos

O Strata automatiza a detecção de hardware e configuração. No Linux:

git clone https://github.com/Niko1221/Strata.git
cd Strata
./install.sh

No Windows, existe um instalador .exe que faz o mesmo processo. O script detecta sua GPU, quantidade de RAM e SSD disponíveis, e configura automaticamente o melhor perfil de quantização.

Depois de instalado, você inicia o servidor:

./strata serve --model qwen3.8-flash-next

E pode testar com curl:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-next",
    "messages": [{"role": "user", "content": "Explique MoE em 3 frases"}]
  }'

Para integrar com o Claude Code ou qualquer ferramenta que use a API da OpenAI:

export OPENAI_BASE_URL=http://127.0.0.1:8080/v1
export OPENAI_API_KEY=dummy

A questão da quantização: Q2 vs IQ3

A escolha de quantização é o maior trade-off que você vai enfrentar. Aqui vai a realidade:

Q2_0 (mais agressivo): Corta os pesos para 2 bits. Velocidade máxima (87+ tok/s na 5070), mas perde qualidade perceptível em raciocínio complexo. Ideal para chat casual, geração de código simples, brainstorming.

IQ3_S/IQ3_XXS (meio-termo): 3 bits com quantização inteligente. Mais lento (53 a 62 tok/s), mas perplexidade significativamente melhor. Ideal para coding assistants, análise de documentos, tarefas que exigem precisão.

O KV cache também tem variantes. O q4_0 adiciona 8% a 12% de custo em perplexidade, mas o k8v4 corta 23% do consumo de memória do KV. Na prática, num RTX 3090 rodando a variante Coder em 198K de contexto, a diferença é entre 99 tok/s e 85 tok/s. Vale o trade-off se você trabalha com contextos gigantes.

Custos: self-hosting vs. API

Vamos fazer as contas. O Qwen Cloud cobra US$ 0,16 por milhão de tokens de input e US$ 0,47 por milhão de tokens de output. Parece barato, mas se você processa 10 milhões de tokens por dia (o que qualquer pipeline de IA pesado faz facilmente), são US$ 6,30 por dia, ou US$ 189 por mês.

Uma RTX 4090 usada custa por volta de R$ 10 mil. Com 64 GB de RAM (mais R$ 1.500) e um SSD NVMe de 1 TB (R$ 500), o investimento total fica em torno de R$ 12 mil.

Com consumo elétrico de ~350W durante inferência, o custo mensal de energia fica em torno de R$ 80 (considerando tarifa residencial brasileira e uso de 8h/dia).

Em 2 meses de uso intensivo, o setup local já se pagou comparado com a API. E a partir daí, é só energia elétrica.

Claro, isso ignora o custo do seu tempo configurando, debugando e mantendo tudo. Se você precisa de 99.9% de uptime e zero manutenção, a API ainda faz sentido. Mas se você é dev e gosta de ter controle total do seu stack, o Strata é economicamente viável.

Limitações que ninguém te conta

Seria desonesto não falar dos problemas. O Strata tem 16 dias de vida e 232 issues abertas no GitHub. Algumas limitações reais:

Suporte a um modelo só. O Strata roda exclusivamente o Qwen 3.8 Flash Next. Se amanhã sair um modelo melhor da Meta ou da Google, você volta pro llama.cpp.

Licenciamento do modelo. O Qwen 3.8 Flash Next usa a Qwen Community License 1.0, não Apache 2.0. Uso comercial é permitido, mas se você pretende oferecer o modelo como API gerenciada ou assistente de IA como serviço, precisa de licença separada. Deployments com mais de 100 milhões de usuários mensais ou US$ 20M de receita mensal precisam exibir o nome do modelo.

Estabilidade. Com 16 dias e versão 0.1.38, bugs são esperados. O conselho da própria comunidade: “build from source, pin a commit, e não rode numa máquina que tenha algo que você não pode perder.”

8 GB de VRAM. Tecnicamente funciona, mas a experiência é sofrível. 12 GB é o mínimo real.

Por que isso importa (além do hype)

A corrida pela IA local não é apenas hobby de nerd. Existem razões práticas e estratégicas para rodar modelos na sua máquina:

Privacidade. Seu código, seus dados, suas conversas nunca saem do seu PC. Nenhuma empresa de IA está treinando em cima das suas perguntas.

Latência. Zero network round-trip. A resposta começa a aparecer instantaneamente.

Disponibilidade. Caiu a internet? O modelo continua rodando. A API da OpenAI deu 503? Você nem percebe.

Custo a longo prazo. Como mostrei nas contas acima, o break-even chega rápido para uso intensivo.

Experimentação. Você pode modificar parâmetros, testar quantizações, comparar outputs sem se preocupar com rate limits ou billing surpresa.

O Strata, mesmo com apenas 16 dias de vida, está mostrando que a era dos modelos gigantes exclusivos da nuvem está chegando ao fim. Quando um modelo de 125 bilhões de parâmetros roda a 100 tok/s numa placa de gamer, a conversa sobre “IA só na cloud” precisa ser revisitada.

A próxima versão (v0.1.39) já promete multi-GPU offload e handling de requisições paralelas. Se o ritmo de desenvolvimento continuar assim, em poucas semanas o Strata pode se tornar a referência para inferência local de modelos MoE.

Quer testar? O repositório é github.com/Niko1221/Strata. O setup leva 5 minutos, e o pior que pode acontecer é você nunca mais querer pagar por API.