Execute o Qwen3.8-Flash-Next localmente com o Strata: Guia Rápido de 64 GB
125B MoE em um único GPU de consumo — e onde a quantização de 3 bits falha
O Qwen3.8-Flash-Next (QFN) possui 125B de parâmetros totais, 6B ativos por token e uma janela de contexto nativa de 256K. Ele tem o modo de raciocínio (“thinking”) ativado por padrão e registra os melhores índices de referência (benchmarks) de codificação agêntica em sua categoria de modelos locais.
Este artigo descreve a execução de uma quantização de 3 bits do QFN em um desktop com 64 GB de RAM e uma RTX 5090, utilizando o Strata, e documenta por que quantizações abaixo de Q4 não produzem chamadas de ferramentas (tool calls) confiáveis para cargas de trabalho agênticas.

Os comandos de instalação, a quantidade de RAM que cada quantização fixa e as falhas nas chamadas de ferramentas em um desktop de 64 GB estão abaixo. As métricas de velocidade e falha misturam execuções nessa máquina — uma RTX 5090, 64 GB de RAM, Ubuntu 26.04 — com relatórios no rastreador do Strata e nas notas de versão 0.2.11.
Os comandos e os valores padrão do motor foram verificados em 06/11/2026 em relação ao Strata 0.2.11, quando o repositório exibia 40.836 estrelas e os pacotes do motor eram da versão 0.1.57. A posição deste runtime em relação ao Ollama, llama.cpp e vLLM é o papel do guia de hospedagem de LLM.
O que é o Strata
O motor neste tutorial rápido (quickstart) é o Niko1221/Strata, com licença MIT. Um projeto diferente, o artigo da OSDI 2026 sobre cache hierárquico de KV para o SGLang, usa o mesmo nome. O Strata é construído sobre o llama.cpp e o ggml, e o repositório inclui uma descrição em docs/paper/Strata-Paper.pdf. Ele executa o Qwen3.8-Flash-Next através de uma GPU de consumidor, RAM de sistema e um SSD. O mesmo motor também atende o Qwen3.6-35B e o DeepSeek V4.1-Flash.
O Qwen 3.8 Flash Next possui 24.576 especialistas roteados em 48 camadas; cada token ativa 10 especialistas (6B de parâmetros ativos no total). O Strata divide o modelo em três camadas de memória, em vez de exigir que ele caiba em uma única.
| Camada | Contém | Função |
|---|---|---|
| GPU (VRAM) | Atenção, misturadores DeltaNet, pesos residual-gateados, roteadores, especialistas compartilhados, cabeça de saída, a camada de rascunho MTP, o cache KV (a partir de 64K: a parte mais lida; o resto é transmitido a partir da RAM), além de um cache de especialistas | Tudo o que executa por token; o cache de especialistas preenche o que resta de VRAM com os especialistas mais usados e se adapta à conversa durante a execução |
| RAM | Todos os 24.576 especialistas, fixados (pinned) | A CPU calcula os especialistas que a GPU não possui, no local, ao mesmo tempo que a GPU trabalha nos que estão em cache (kernels AVX-512/AVX2, ggml para i-quants) |
| SSD | A tabela de incorporação (embedding) n-grama de 28,8 GB | Lê algumas linhas por token através do cache de páginas do sistema operacional |
O bloco de 51B de parâmetros n-grama serve como uma tabela de consulta de 20 milhões de entradas, indexada por bigramas e trigramas. Como isso é uma consulta e não uma multiplicação de matrizes, ela pode residir em um SSD com custo de execução mínimo.
A capacidade de VRAM determina o eixo de escalonamento. Cada gigabyte adicional de VRAM comporta aproximadamente 700 especialistas, e cada especialista em cache na GPU reduz o cálculo da CPU. Uma placa lenta com mais VRAM supera uma placa rápida com menos.
A capacidade de RAM é uma restrição rígida, pois todos os especialistas devem ser fixados para o cálculo simultâneo de CPU e GPU. O Strata não suporta mapeamento preguiçoso de memória (lazy memory mapping) para disco. O tamanho do download e o uso de RAM são quase idênticos para o QFN.
Como a velocidade de decodificação é construída
Três mecanismos fornecem a taxa de decodificação.
-
Previsão de múltiplos tokens. O checkpoint inclui uma camada MTP treinada para rascunhos de múltiplas etapas. O Strata faz rascunho de até 3 tokens e os verifica em uma única passagem por todas as 48 camadas — o ciclo de rascunho-verificação no guia de decodificação especulativa. O projeto mede a taxa média de aceitação em 2,4–3,2 tokens por passagem, e relata isso como velocidade de decodificação de 1,6–1,8× com a mesma saída.
-
Consulta de prompt. O servidor recupera até 5 tokens de rascunho de cópias anteriores do contexto quando o modelo o está repetindo, como em uma edição de código ou uma citação. O projeto relata que edições de código ficam 6–11% mais rápidas, e outros textos permanecem inalterados.
-
Prefill em blocos (chunked prefill). Os prompts chegam em blocos de até 8.192 tokens, e os especialistas da próxima camada são transferidos através do PCIe enquanto a atenção da camada atual executa. O projeto coloca a ingestão de documentos longos e base de código acima de 1.000 tokens/s, e uma solicitação de seguimento começa em segundos, porque o estado da conversa permanece residente.
O servidor inclui uma interface de chat local, como um aplicativo de desktop ou no terminal, além de pontos de extremidade (endpoints) compatíveis com OpenAI e Anthropic no localhost. O Claude Code, Codex CLI, OpenCode, Hermes Agent e OpenClaw se conectam através de strata connect. O hardware listado pelo projeto: NVIDIA RTX séries 20/30/40/50 (pacotes do motor CUDA 13 precisam do driver 580 ou mais novo), AMD Radeon no HIP, Intel Arc no Linux, Apple Silicon e AMD Strix Halo. A liberação 0.2.11 é o Strata-0.2.11-linux-x86_64.AppImage para o aplicativo de desktop; o caminho do terminal abaixo é o que este tutorial rápido percorre.
Benchmarks do QFN Contra Alternativas Locais
O card do modelo da Alibaba compara o Flash-Next com o Qwen3.8-27B, o DeepSeek-V4-Flash (o checkpoint 0731) e o Claude Opus 4.6 (Max).
| QFN | Qwen3.8-27B | DeepSeek-V4-Flash | Claude Opus 4.6 (Max) | |
|---|---|---|---|---|
| Parâmetros totais / ativos | 125B / 6B | 27B / 27B | 284B / 13B | – |
| Parâmetros de incorporação n-grama | 51B | – | – | – |
| DeepSWE 1.1 (codificação agêntica) | 58,7 | 42,2 | 54,4 | – |
| SWE-bench Pro | 62,5 | 61,7 | 56,0 | 53,4 |
| SWE-bench Multilingual | 81,0 | 73,8 | – | 77,5 |
| Toolathlon Verified (uso de ferramentas) | 73,5 | 67,1 | 70,3 | – |
| JobBench (escritório agêntico) | 55,7 | 33,4 | 41,3 | 36,6 |
| CoWorkBench | 73,9 | 70,7 | 45,1 | 68,2 |
| GPQA Diamond | 91,7 | 89,2 | 90,8 | 91,3 |
| LiveCodeBench v6 | 91,9 | 90,3 | 90,6 | 88,8 |
As linhas de codificação agêntica naquele card usaram temperatura 1.0, top_p 0.95 e uma janela de 256K. O DeepSWE relata o maior dos conjuntos de ferramentas (harnesses) do Claude Code e mini-SWE-agent, e o card diz que a pontuação mais alta do Flash-Next é no mini-SWE-agent. O SWE-bench Pro reexecutou as linhas de base em um conjunto de tarefas corrigido; a célula do Claude Opus 4.6 é a pontuação publicada pelo fabricante, e as outras células são do Claude Code.
Duas linhas no mesmo card vão na direção oposta. O NL2Repo-Bench é 48,1 para o Flash-Next e 54,2 para o DeepSeek-V4-Flash. O HLE, julgado pelo GPT-4o, é 35,9 contra o Claude Opus 4.6 (Max) em 40,0.
Para trabalho agêntico, os padrões do card são preserve_thinking ativado, para que o rastro de raciocínio permaneça entre as turnos, e reasoning_effort em xhigh. Os outros níveis são medium e low. A página da família Qwen 4 rastreia o que a Alibaba confirmou sobre esta linha, incluindo a Licença da Comunidade Qwen 1.0 nestes pesos. A tabela acima é a parte que pode ser medida hoje.
Builds e Tamanhos de Quantização
ISTA-DASLab GSQ-RCO
Os GGUFs ISTA-DASLab GSQ-RCO usam quantização não uniforme. O GSQ é quantização escalar de baixo bit por tensor, e o RCO atribui um tipo por tensor dentro de um orçamento de tamanho. O método gasta quase toda a compressão nos especialistas roteados, que são 95% dos pesos pesquisáveis. Cada build é de dois shards. O segundo é a tabela n-grama a cerca de 4,5 bits por peso, e pode ser mapeado do disco.
| Build | Bpw médio | Shard residente | Shard N-grama | Total | Notas |
|---|---|---|---|---|---|
| Q2_0 | 2.40 | 37,6 GB | 28,8 GB | 66,4 GB | Build de velocidade: evita formatos de tabela de consulta; 367 t/s de prompt, 93,8 t/s de decodificação, latência média de 6,7 s (vs 12,7 s para IQ2_XS em tamanho quase o mesmo) |
| IQ2_XS | 2.50 | 39,2 GB | 28,8 GB | 68,0 GB | O menor em qualidade igual |
| IQ3_XXS | 3.00 | 47,0 GB | 28,8 GB | 75,8 GB | A escolha para memória limitada; corresponde ao modelo base no AIME25, cede ~1,5 pontos no GPQA-Diamond |
| IQ3_S | 3.50 | 54,8 GB | 28,8 GB | 83,6 GB | Recomendação da ISTA: corresponde ou supera o modelo base em todas as tarefas no seu harness (GPQA-Diamond 92.93 vs 91.92) |
Aqueles números do GPQA são do harness da ISTA, não os 91,7 no card da Alibaba. Uma variante Coder mantém 256 dos 512 especialistas roteados por camada, em 58,4 GB e 1,89 bits efetivos por peso. Um projetor de visão BF16 de 0,91 GB é o acréscimo multimodal. A linha da ISTA para no IQ3_S; ela não tem um build Q4.
Pacotes Unsloth no Strata 0.2.11
Em 04/11/2026 a Unsloth reenviou seus GGUFs do Qwen3.8-Flash-Next como Dynamic v3.1. As notas de liberação 0.2.11 dizem que o Strata pode baixar, preparar e executar sete deles do aplicativo, de strata launch --family unsloth, ou de uma pasta que você já possui. Cada arquivo é verificado por tamanho e SHA-256 contra a revisão da Unsloth d9620119. O último arquivo de cada conjunto é a tabela por token de 28,8 GB. Conjuntos que compartilham uma tabela compartilham o arquivo: UD-IQ1_M com UD-IQ2_XS, e UD-IQ3_XXS com UD-IQ4_XS-v31.
| Nome no Strata | Download | Arquivos |
|---|---|---|
| UD-IQ1_M | 68,0 GB | 3 |
| UD-Q2_0 | 70,6 GB | 3 |
| UD-IQ2_XS | 75,8 GB | 3 |
| UD-Q2_K_XL | 79,6 GB | 4 |
| UD-IQ3_XXS | 83,6 GB | 4 |
| UD-Q3_K_XL | 89,5 GB | 4 |
| UD-IQ4_XS-v31 | 93,7 GB | 4 |
UD-IQ4_XS-v31 é um arquivo diferente do UD-IQ4_XS que o Strata já oferecia: outros tipos de tensor, quatro arquivos em vez de três. UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL e Q8_0 permanecem nos arquivos de 30/09/2026. O UD-Q4_K_XL de 04/11 é os mesmos pesos em uma divisão de quatro arquivos, e o Strata aceita essa divisão se você já a possui. O UD-IQ1_S não carrega — uma camada mistura dois formatos de especialista —, então o UD-IQ1_M é a escolha de 1 bit.
O UD-IQ4_XS-v31 usa o formato de especialista Q5_0 em 33 camadas. As mesmas notas dizem que a matemática Q5_0 do Strata fica a 1,2–1,3% do resultado exato, contra 2,6–3,0% para a fórmula do llama.cpp nesses tensors. Em um Mac, o aplicativo reescreve os especialistas em um arquivo de GPU antes da primeira inicialização, então o orçamento de disco é o download mais aquele arquivo mais alguns gigabytes (cerca de 115 GB para UD-IQ1_M).
Se a tabela de 28,8 GB permanecer mapeada, o resto do UD-IQ4_XS-v31 é cerca de 64,9 GB antes do cache KV, o que já ultrapassa uma máquina de 64 GB sob a regra de fixação do Strata. O resto do UD-IQ1_M é cerca de 39,2 GB. Aquele arquivo pode caber onde o IQ3_S não cabe, e é um pacote de 1 bit, mais distante do comportamento de chamada de ferramenta medido abaixo em 3 bits.
Tutorial Rápido: Instalação, Inicialização e Configuração da Primeira Execução
Um desktop Linux precisa de um cartão RTX série 20/30/40/50 ou outro GPU listado pelo projeto, RAM suficiente para o pacote escolhido mais folga para o cache KV, e espaço no SSD para o download. Os pacotes do motor CUDA 13 precisam do driver 580 ou mais novo.
Instalação via terminal:
curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
strata launch
strata launch pergunta pelo modelo, a quantização, o contexto, a pasta de armazenamento e as configurações de acesso, baixa o motor para o cartão, inicia o servidor e mostra um monitor com velocidade, memória e dados de requisição. O ponto de extremidade padrão é http://127.0.0.1:8080.
Para ver o que cabe antes de um download de 76 GB, ou para iniciar sem os prompts:
strata launch --family qwen --model q2_0 --plan # simulação (dry run): o que falta, o que cabe
strata launch --family qwen --model q2_0 --yes --no-tui # iniciar em segundo plano
strata launch --status
strata connect # imprime a configuração para Claude Code / OpenCode / Hermes / OpenClaw / ...
strata launch --stop
Aqueles flags --family qwen --model q2_0 são a simulação usada para o build ISTA Q2_0 no Ubuntu 26.04. Pacotes Unsloth usam --family unsloth e o nome da tabela acima. strata connect imprime um bloco de provedor por ferramenta. Ambos os formatos de API usam uma URL base compatível com OpenAI (http://127.0.0.1:8080/v1) e o nome do modelo que o launch imprime. Qualquer cliente que aceite um ponto de extremidade compatível com OpenAI personalizado, incluindo o Cursor, usa esse par.
Atualizar uma instalação existente
As notas de instalação dão três comandos para um Terminal que já está na máquina. strata update --check lê o feed de liberação assinado e relata o que mudaria. strata update baixa o motor para esta máquina e o componente Control, e altera apenas após um teste de inicialização. strata --version imprime a versão depois. O aplicativo, o Control e o motor têm números de versão separados, então os três podem diferir.
strata update --check
strata update
strata --version
Com um modelo carregado, strata update nomeia-o e pergunta antes de pará-lo. O novo motor baixa enquanto aquele modelo continua atendendo; após a alteração, o Strata pergunta se deve iniciar as mesmas configurações novamente. Uma atualização falha deixa o antigo motor em uso, e os arquivos do modelo e configurações salvas permanecem. strata components rollback retorna ao motor anterior.
Duas configurações para verificar na primeira execução
-
Amostragem (Sampling). Na 0.2.11 uma configuração de pacote sem bloco
samplingsegue o card do modelo. Requisições de raciocínio recebem temperatura 1.0, top_p 0.95 e top_k 20. Requisições sem raciocínio recebem 0.7, 0.8 e 20, com presence_penalty 1.5. A precedência é a requisição, então as configurações de Chat da interface Web, então o bloco de configuração, então o card. Temperatura 0 se aplica apenas quando a requisição ou o bloco a define, e aquelas execuções gulosas (greedy) são as que caíram em laços de repetição neste checkpoint. Se uma configuração de pacote antiga ainda contiver"sampling": {"temperature": 0}, substitua-a pelo preset de raciocínio do card. -
tool_call_recovery. A chave reside na configuração de execução do modelo (strata-*.json). Ela tem estado ativada por padrão desde a 0.2.8, e desativada na 0.2.7 e anteriores. As notas do motor do Strata, citando 1.462 turnos agênticos, relatam 98,3% das chamadas lidas conforme a intenção com o interruptor e 92,9% sem ele. Ele aceita quatro formas de uma chamada cujo nome estava na requisição: uma tag<parameter=NAME>, JSON dentro de<tool_call>, um bloco<function=NAME>sem a envoltória<tool_call>, e uma segunda chamada dentro de um único<tool_call>. Um nome não declarado ou JSON quebrado permanece texto. Na 0.2.7 e anteriores, defina"tool_call_recovery": true. Deixe o padrão da 0.2.11 ativado para trabalho agêntico.
Manter o servidor no localhost
O servidor se vincula ao localhost por padrão, e as configurações de acesso são parte de strata launch. Os pontos de extremidade expõem o modelo e a conversa naquela máquina, e não foram construídos para uma rede aberta. Quando outra máquina os precisa, coloque um proxy reverso autenticado à frente da porta.
ss -ltnp | grep :8080 # confirme que o listener é 127.0.0.1, não 0.0.0.0
curl -s http://127.0.0.1:8080/v1/models # o servidor responde no localhost
Cartões com 13 GB de VRAM ou menos
STRATA_ROUTE_PRIOR=1.5 diz ao roteador para preferir especialistas já no cartão. As notas do Strata para uma RTX 3060 12 GB executando IQ3_XXS relatam +15% na decodificação de história e +37% na decodificação de código contra o anterior desligado, e menos tarefas agênticas concluídas: 4,5 de 10 em média em 4 execuções, contra 5,6 em 7 execuções com o anterior desligado. A versão 0.2.7 ativou 1.5 por si só para cartões NVIDIA discretos de 13 GiB ou menos. A versão 0.2.8 desligou isso em 29/10/2026, após repetições e sessões agênticas longas mais fracas (issue #4402). Com a variável indefinida, a 0.2.11 roteia como a 0.2.6 fazia. O projeto aponta o anterior para chat e respostas curtas em um cartão de 12 GB, e para longe de execuções agênticas longas.
Banco de Teste: Um Desktop de 64 GB Executando um Agente
A caixa medida:
| Componente | Especificação |
|---|---|
| CPU | Intel Core Ultra 7 265 (20 núcleos, DDR5-6400 canal duplo ≈ 102 GB/s) |
| GPU | RTX 5090, 32 GB |
| RAM | 64 GB |
| SO | Ubuntu 26.04 |
| Também em execução | Host KVM para a VM Hermes, IDE Cursor, navegador |
Com ISTA IQ3_XXS o shard residente é 47 GB. Porque os especialistas são fixados, cerca de 9 GB permanece para tudo o resto. A VM Hermes — a pilha agêntica na configuração de produção do Hermes — mais o Cursor deixa cerca de 5 GB, o que não é cache de páginas ou cache KV suficiente para uma sessão agêntica longa.
O ISTA IQ3_S não cabe nesta máquina como um desktop diário. O shard residente de 54,8 GB mais a tabela n-grama mapeada de 28,8 GB usam os 64 GB. Com o Cursor em execução, 3 GB ficam livres, e a VM Hermes não tem para onde ir.
| Configuração | Residente | RAM Livre (só modelo) | RAM Livre (modelo + VM + Cursor) | Decodificação (medida) | Veredito Agêntico |
|---|---|---|---|---|---|
| IQ3_XXS (3.00 bpw) | 47 GB | ~9 GB | ~5 GB | – | Chamadas de ferramentas falham regularmente; não é um driver diário |
| IQ3_S (3.50 bpw) | 54,8 GB + 28,8 GB mmap | ~3 GB (só Cursor) | – | 100–130 tok/s | Sem folga alguma; não utilizável |
O IQ3_S decodificou a 100–130 tokens/s, a mesma classe de velocidade de um build de 27B no llama.cpp com MTP 3 na comparação MTP Qwen 3.6. O pacote que cabe no orçamento de RAM (IQ3_XXS) é aquele que erra o formato da chamada de ferramenta. O pacote recomendado pela ISTA (IQ3_S) não deixa espaço para o resto do desktop.
No IQ3_XXS o modelo emitiu argumentos de chamada de ferramenta malformados, inventou nomes de ferramentas que não estavam no esquema e reemitiu o mesmo comando três a cinco vezes após um bloco de raciocínio curto. O harness trata cada erro como uma nova tentativa, então a sessão preenche com o mesmo erro. Neste hardware o IQ3_XXS não é um modelo agêntico.
O que a Comunidade Relata
Relatos de velocidade para Qwen3.8-Flash-Next no Strata, de threads de issues e das notas 0.2.11:
| Configuração | Resultado |
|---|---|
| 2× RTX 4090 | 6.553 t/s de prompt, 271 t/s de decodificação em fluxo único |
| RTX 5080 + 4060 Ti, 32 GB RAM | Picos de decodificação acima de 200 tok/s |
| 12 GB VRAM + 32 GB RAM, especialistas descarregados para a CPU | ~65 tok/s; um comentário com contexto 199K com KV q8: 1.740 t/s de prompt, ~21,5 t/s de decodificação |
| RTX 5070 12 GB + 64 GB RAM, IQ3_S | 85–100 tok/s de decodificação |
| Pro 6000 + 2× 3090, 256 GB RAM, Unsloth 6-bit, contexto 160K | Decodificação 70–80 → 150 tok/s após mudar de llama-server para Strata |
| RTX 2060 notebook, 32 GB RAM + 6 GB VRAM | Q2_0 executando em algum nível |
| RTX 3060 12 GB, UD-IQ1_M, prompts curtos (notas 0.2.11) | 31–37 tok/s de decodificação, 18% dos especialistas no cartão |
Três modos de falha estão escritos para Qwen3.8-Flash-Next de baixo bit em cargas de trabalho agênticas.
-
Emissão de chamada de ferramenta corrompida que acompanha o tamanho do esquema. A issue #1431 relata que com 39 esquemas de função (cerca de 12K tokens) e um prompt de sistema de 6K, o IQ3_XXS no Strata 0.1.40 produziu um turno utilizável em cerca de 30–50% de 20+ reproduções controladas. O modelo ou emitiu uma forma de chamada de ferramenta que o analisador não podia mapear — o texto caiu em
contentcomfinish_reason: stop— ou fechou o bloco de raciocínio e emitiu fim de sequência sem chamada e sem resposta. Os mesmos pesos no llama.cpp analisaram chamadas de ferramenta em todas as 8+ execuções consecutivas. O llama.cpp restringe a emissão com uma gramática PEG e levanta o conteúdo corrompido de volta paratool_calls. Um wrapper que reparava o texto depois não impulsionou a taxa de turnos úteis acima daquela faixa de 30–50%, porque o reparo executa depois que os tokens já estão escolhidos. -
Erros de configuração e um caminho de especialista não determinístico. A issue #2685 relata uma RTX 5070, IQ3_S e 60 GB de RAM, com chamadas de ferramentas falhando através do Strata: argumentos malformados, ferramentas alucinadas e laços de repetição, inclusive depois que um bloco de amostragem e
tool_call_recoveryforam ativados. A mesma quantização através dellama serveteve sucesso em 5 de 5 execuções do mesmo harness. O relator descobriu que sementes idênticas divergiram no caminho de especialista MMQ durante o prefill, e que desativar aquele caminho tornou as execuções bit-idênticas. O Strata 0.1.44 embarrou correções de determinismo. Relatos posteriores ainda não mostram o Strata correspondendo ao llama.cpp na mesma quantização. -
Chamadas de ferramenta deixadas dentro do bloco de raciocínio. A issue #804 relata que uma chamada de ferramenta completa dentro de um bloco
thinknão fechado volta comoreasoning_content, comcontentvazio e semtool_calls, e o loop do agente para. Um usuário contou cerca de 1 em 100 respostas em aproximadamente 1.300 respostas reais de agente, usando o Hermes com IQ3_XXS, IQ2_XS e os builds Coder.
Por que Sub-Q4 Quebra Chamadas de Ferramenta Agênticas
Uma chamada de ferramenta tem que corresponder a um formato de fio (wire format). Em 3 bits este modelo de 125B erra aquele formato em alguns turnos, e os erros crescem com o contexto do esquema de ferramentas. Um esquema maior exige mais da memória de trabalho que formata a chamada, e o ruído de quantização recai sobre essa formatação. Turnos de chat o escondem. Turnos agênticos, que são majoritariamente chamadas de ferramentas, não.
A mesma compressão prejudica mais quando poucos parâmetros estão ativos. A comparação de LLM local para OpenCode mediu um 27B denso em IQ3_XXS com cerca de 5% de taxa de erro em uma tarefa agêntica estruturada. Checkpoints MoE de baixa atividade em larguras de bits similares falharam mais: o 35B-A3B teve 64,2% de erros em IQ3_S e 98,8% em IQ4_XS, e o 122B-A10B teve 80% de erros em IQ3_S e 90% em IQ3_XXS. O Qwen3.8-Flash-Next ativa 6B de parâmetros por token, então um pacote de 3 bits se comporta como um modelo pequeno em uma quantização pesada. Aqueles runs do OpenCode mostram IQ3 e IQ4 errando a tarefa estruturada para o 35B-A3B e o 122B-A10B; eles não incluem uma execução Q5 do Flash-Next. O UD-IQ4_XS-v31 do Strata tem estado baixável desde a 0.2.11, não tem comparação de tarefa agêntica nas fontes verificadas aqui, e não cabe na caixa de 64 GB.
Os mesmos pesos GSQ-RCO falham quando carregados no llama.cpp e no Ollama. O llama.cpp ainda restringe a emissão com uma gramática e pode levantar um trecho corrompido de volta para tool_calls, então o cliente vê uma chamada em vez de uma string quebrada. O modo JSON do Strata, nas notas do motor, é prompt de esquema mais uma verificação após a geração, não decodificação restrita por gramática: um objeto ruim retorna HTTP 502 com structured_output_failed. tool_call_recovery e as liberações posteriores reparam as quatro formas listadas acima. Elas não mudam a distribuição da qual o modelo amostra, que é por que o wrapper da issue #1431 não pôde subir além da taxa de emissão.
O Strata gasta RAM para manter a CPU e a GPU em passo. Em 64 GB, o maior pacote ISTA que ainda deixa espaço para um desktop e uma VM agêntica é o IQ3_XXS, e aquele pacote está abaixo do limiar de emissão medido aqui. O IQ3_S já decodifica na mesma faixa de um modelo de 27B com MTP 3, então o limite naquele pacote é RAM. Uma execução do llama.cpp com um mapeamento preguiçoso comprometeria menos RAM e abriria mão da taxa de decodificação que torna o Strata o mais rápido dos dois neste modelo.
Veredito
O Qwen 2.8 Flash Next supera o Qwen3.8-27B em benchmarks agênticos: DeepSWE 58,7 vs 42,2, JobBench 55,7 vs 33,4 e Toolathlon 73,5 vs 67,1. Trabalho multietapas é visivelmente mais competente. O cálculo por token é mais próximo de um modelo pequeno do que de um modelo de 125B.
Quantizações abaixo de Q4 não fornecem emissão de chamada de ferramenta confiável para trabalho agêntico, falhando em taxas que produzem laços de repetição em ambos, Strata e llama.cpp. O desempenho Q4 ainda não está provado através de comparação controlada em benchmarks agênticos. Quantizações de classe Q5 são o piso demonstrado para trabalho agêntico confiável; o Unsloth UD-Q5_K_XL existe, mas carece de benchmarks publicados. A mesma regra de saída estruturada sub-Q4 se aplica ao fazer uma lista preliminar de builds Qwen abliterated em Como Escolher um LLM Sem Censura.
Um Mac Studio com M5 Max e 128 GB de memória unificada pode segurar o build MLX de 105 GB ou um pacote Q4 com folga suficiente para a pilha agêntica. A arquitetura QFN foi projetada para este modelo de descarregamento (offloading).
Eu continuarei usando no meu setup atual um modelo 27B NVFP4 — 17 GB na RTX 5090 — com MTP 3. Ele está alcançando 100+ tokens/s com chamadas de ferramentas confiáveis e sem competição de RAM. Eu retornarei ao QFN quando uma quantização de classe Q4 for benchmarkada em tarefas agênticas, quando a recuperação de emissão do Strata amadurecer, ou quando o hardware for atualizado.
Referências
- Niko1221/Strata — o motor de inferência neste artigo. O artigo da OSDI 2026 sobre KV hierárquico para SGLang é um projeto diferente com o mesmo nome.
- Notas de liberação do Strata 0.2.11 — pacotes Unsloth Dynamic v3.1, matemática Q5_0 e as velocidades de prompt curto citadas acima.
- Notas do motor (
docs/DETAILS.md) — precedência de amostragem,tool_call_recoverye as medições do roteador-prioritário. - Notas de instalação, Atualizando —
strata update --check,strata updateestrata --version. - Qwen/Qwen3.8-Flash-Next — arquitetura, presets de amostragem e a tabela de benchmark.
- ISTA-DASLab Qwen3.8-Flash-Next GSQ-RCO GGUFs — os builds Q2 e IQ3 no banco de teste.
- Issue #1431, issue #2685, issue #804 e issue #4402 — os relatórios de falha nas seções de comunidade e cartões pequenos.
Links Úteis
- Escolhendo o Melhor LLM para Ollama em uma GPU com 16 GB de VRAM — alternativas de modelo denso quando o cartão é o limite.
- [Cheatsheet do Ollama](https://www.glukhov.org/pt/llm-hosting/ollama/ollama-cheatsheet/ “Cheatsheet do CLI Ollama: serve, run, ps e gerenciamento de modelos.”}) — o outro servidor local para o qual os mesmos GGUFs podem ser importados.