Execute o Qwen3.8-Flash-Next Localmente com o Strata: Guia Rápido de 64 GB

O Qwen3.8-Flash-Next (QFN) possui 125 bilhões de parâmetros totais, 6 bilhões 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 maiores índices em benchmarks de codificação agêntica entre modelos locais da mesma categoria.

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 usando o Strata, e documenta por que quantizações abaixo do Q4 não produzem chamadas de ferramentas confiáveis para cargas de trabalho agênticas.

Os comandos de instalação, a RAM que cada quantização fixa e as falhas de chamadas de ferramentas em um desktop de 64 GB estão abaixo. As figuras de velocidade e falha misturam execuções naquela máquina — uma RTX 5090, 64 GB de RAM, Ubuntu 26.04 — com relatos no rastreador do Strata e nas notas da versão 0.2.11.

Os comandos e padrões do motor foram verificados em 06/11/2026 contra o Strata 0.2.11, quando o repositório exibia 40.836 estrelas e os pacotes do motor eram 0.1.57. Onde este runtime se posiciona em relação ao Ollama, llama.cpp e vLLM é assunto do guia de hospedagem de LLMs.

O que é o Strata

O motor deste guia rápido é o Niko1221/Strata, com licença MIT. Um projeto diferente, o paper do 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 atravessando uma GPU de consumidor, a RAM do sistema e um SSD. O mesmo motor também serve 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 (6 bilhões de parâmetros ativos no total). O Strata divide o modelo em três camadas de memória em vez de exigir que caiba em uma só.

O bloco de parâmetros n-gram de 51 bilhões atua como uma tabela de pesquisa (lookup) com 20 milhões de entradas indexada por bigramas e trigramas. Como se trata de uma pesquisa e não de uma multiplicação de matrizes, ele pode residir em um SSD com custo mínimo em tempo de execução.

A capacidade de VRAM determina o eixo de escala. Cada gigabyte adicional de VRAM segura aproximadamente 700 especialistas, e cada especialista em cache na GPU reduz o cálculo da CPU. Uma placa mais lenta com mais VRAM supera uma placa mais rápida com menos.

A capacidade de RAM é uma restrição rígida porque 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 o 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.

1. Previsão multi-token. O checkpoint inclui uma camada MTP treinada para rascunhos multietapa. O Strata rascunha 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 aceitação média em 2,4–3,2 tokens por passagem, e relata isso como 1,6–1,8× de velocidade de decodificação com a mesma saída.

2. Pesquisa de prompt. O servidor busca 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 edições de código 6–11% mais rápidas, e outro texto inalterado.

3. Prefill em blocos (chunked). Os prompts chegam em blocos de até 8.192 tokens, e os especialistas da próxima camada se movem pelo PCIe enquanto a atenção da camada atual roda. O projeto coloca a ingestão de documentos longos e base de código acima de 1.000 tokens/s, e um acompanhamento começa em segundos porque o estado da conversa permanece residente.

O servidor vem com uma interface de chat local, como um aplicativo de desktop ou no terminal, além de 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. Hardware listado pelo projeto: NVIDIA RTX 20/30/40/50 series (os pacotes do motor CUDA 13 precisam do driver 580 ou mais novo), AMD Radeon em HIP, Intel Arc em Linux, Apple Silicon e AMD Strix Halo. A versão 0.2.11 é o Strata-0.2.11-linux-x86_64.AppImage para o aplicativo de desktop; o caminho do terminal abaixo é aquele que este guia rápido percorre.

Benchmarks do QFN Contra Alternativas Locais

O cartão do modelo da Alibaba compara o Flash-Next com o Qwen3.8-27B, DeepSeek-V4-Flash (o checkpoint 0731) e Claude Opus 4.6 (Max).

As linhas de codificação agêntica naquele cartão usaram temperatura 1,0, top_p 0,95 e uma janela de 256K. O DeepSWE relata o maior dos arnês (harnesses) Claude Code e mini-SWE-agent, e o cartão 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 fornecedor, e as outras células são do Claude Code.

Duas linhas no mesmo cartão vão no sentido contrário. 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 40,0 do Claude Opus 4.6 (Max).

Para trabalho de agentes, os padrões do cartão 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.

Compilações de Quantização e Tamanhos

ISTA-DASLab GSQ-RCO

Os GGUFs do 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 compilação é dois shards. O segundo é a tabela n-gram a cerca de 4,5 bits por peso, e pode ser mapeado do disco.

Essas figuras do GPQA são do arnês da ISTA, não o 91,7 do cartão da Alibaba. Uma variante Coder mantém 256 dos 512 especialistas roteados por camada, a 58,4 GB e 1,89 bits efetivos por peso. Um projetor de visão BF16 de 0,91 GB é o adicional multimodal. A linha da ISTA para no IQ3_S; ela não tem compilação 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 da 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.

O 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. O 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 especialistas — 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 tensores. Num Mac, o aplicativo reescreve os especialistas em um arquivo de GPU antes do primeiro início, então o orçamento de disco é o download mais esse arquivo mais alguns gigabytes (cerca de 115 GB para o UD-IQ1_M).

Se a tabela de 28,8 GB permanece mapeada, o resto do UD-IQ4_XS-v31 é cerca de 64,9 GB antes do cache KV, o que já passa de 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. Esse arquivo pode caber onde o IQ3_S não, e é um pacote de 1 bit, mais distante do comportamento de chamadas de ferramentas medido abaixo a 3 bits.

Guia Rápido: Instalação, Lançamento e Configuração da Primeira Execução

Um desktop Linux precisa de uma placa RTX 20/30/40/50 series ou outra GPU que o projeto liste, RAM suficiente para o pacote escolhido mais folga para o cache KV, e espaço em SSD para o download. Os pacotes do motor CUDA 13 precisam do driver 580 ou mais novo.

Instalação pelo 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 a placa, inicia o servidor e mostra um monitor com velocidade, memória e dados de requisição. O endpoint 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      # execução de teste (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

Essas bandeiras --family qwen --model q2_0 são a execução de teste usada para a compilação Q2_0 da ISTA no Ubuntu 26.04. Os 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 lançamento imprime. Qualquer cliente que aceita um endpoint personalizado compatível com OpenAI, incluindo o Cursor, usa esse par.

Dois ajustes para verificar na primeira execução

1. Amostragem (Sampling). Na 0.2.11, uma configuração de pacote sem bloco sampling segue o cartão do modelo. Requisições de raciocínio recebem temperatura 1,0, top_p 0,95 e top_k 20. Requisições não-raciocínio recebem 0,7, 0,8 e 20, com presence_penalty 1,5. A precedência é a requisição, depois as configurações de Chat da interface web, depois o bloco de configuração, depois o cartão. Temperatura 0 se aplica apenas quando a requisição ou o bloco a define, e essas execuções gananciosas são as que caíram em laços de repetição neste checkpoint. Se uma configuração de pacote mais antiga ainda contém "sampling": {"temperature": 0}, substitua-o pelo preset de raciocínio do cartão.

2. tool_call_recovery. A chave fica na configuração de execução do modelo (strata-*.json). Ela está 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 de agente, relatam 98,3% das chamadas lidas como intentado com a chave ativada e 92,9% sem. Ela aceita quatro formatos de uma chamada cujo nome estava na requisição: uma etiqueta <parameter=NAME>, JSON dentro de <tool_call>, um bloco <function=NAME> sem envoltório <tool_call>, e uma segunda chamada dentro de um único <tool_call>. Um nome não declarado ou JSON quebrado permanece como texto. Na 0.2.7 e anteriores, defina "tool_call_recovery": true. Deixe o padrão da 0.2.11 ativado para trabalho de agentes.

Mantenha o servidor no localhost

O servidor se vincula ao localhost por padrão, e as configurações de acesso são parte do strata launch. Os endpoints 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

Placas com 13 GB de VRAM ou menos

STRATA_ROUTE_PRIOR=1.5 diz ao roteador para preferir especialistas já na placa. As notas do Strata para uma RTX 3060 12 GB executando IQ3_XXS relatam +15% em decodificação de história e +37% em decodificação de código contra a prioridade desligada, e menos tarefas de agente passadas: 4,5 de 10 em média em 4 execuções, contra 5,6 em 7 execuções com a prioridade desligada. A versão 0.2.7 ativou 1,5 por conta própria para placas NVIDIA discretas de 13 GiB ou menos. A versão 0.2.8 desativou isso em 29/10/2026, após repetições e sessões longas de agente mais fracas (problema #4402). Com a variável não definida, a 0.2.11 roteia como a 0.2.6 fazia. O projeto aponta a prioridade para chat e respostas curtas numa placa de 12 GB, e longe de execuções longas de agente.

Banco de Testes: Um Desktop de 64 GB Executando um Agente

A caixa medida:

Com o ISTA IQ3_XXS, o shard residente é 47 GB. Como os especialistas são fixados, cerca de 9 GB restam para tudo o mais. A VM Hermes — a pilha de agente na configuração de produção do Hermes — mais o Cursor deixa cerca de 5 GB, o que não é suficiente cache de página ou cache KV para uma sessão longa de agente.

O ISTA IQ3_S não cabe nesta máquina como desktop diário. O shard residente de 54,8 GB mais a tabela n-gram mapeada de 28,8 GB usam os 64 GB. Com o Cursor rodando, 3 GB ficam livres, e a VM Hermes não tem para onde ir.

O IQ3_S decodificou a 100–130 tokens/s, a mesma classe de velocidade que uma compilação de 27B no llama.cpp com MTP 3 na comparação MTP do Qwen 3.6. O pacote que cabe no orçamento de RAM (IQ3_XXS) é aquele que erra o formato de chamada de ferramenta. O pacote que a ISTA recomenda (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 ferramenta 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 arnês trata cada erro como uma nova tentativa, então a sessão enche com o mesmo erro. Neste hardware, o IQ3_XXS não é um modelo de agente.

O que a Comunidade Relata

Relatos de velocidade para o Qwen3.8-Flash-Next no Strata, de threads de problemas e das notas da 0.2.11:

Três modos de falha estão escritos para Qwen3.8-Flash-Next de baixo bit em cargas de trabalho de agentes.

1. Emissão de chamadas de ferramenta corrompida que acompanha o tamanho do esquema. O Problema #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 ou mais reproduções controladas. O modelo ou emitiu um formato de chamada de ferramenta que o parser não podia mapear — o texto caiu em content com finish_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 parsearam chamadas de ferramenta em todas as 8 ou mais execuções consecutivas. O llama.cpp restringe a emissão com uma gramática PEG e eleva conteúdo corrompido de volta para tool_calls. Um wrapper que reparou o texto posteriormente não empurrou a taxa de turnos úteis acima daquela faixa de 30–50%, porque o reparo roda após os tokens já estarem escolhidos.

2. Erros de configuração e um caminho de especialista não determinístico. O Problema #2685 relata uma RTX 5070, IQ3_S e 60 GB de RAM, com chamadas de ferramenta falhando através do Strata: argumentos malformados, ferramentas alucinadas e laços de repetição, incluindo após um bloco de amostragem e tool_call_recovery serem ativados. A mesma quantização através de llama serve teve sucesso em 5 de 5 execuções do mesmo arnês. O reportador 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 embarcou correções de determinismo. Relatos posteriores ainda não mostram o Strata igualando o llama.cpp na mesma quantização.

3. Chamadas de ferramenta deixadas dentro do bloco de raciocínio. O Problema #804 relata que uma chamada de ferramenta completa dentro de um bloco think não fechado volta como reasoning_content, com content vazio e sem tool_calls, e o laço de agente para. Um usuário contou cerca de 1 em 100 respostas em cerca de 1.300 respostas reais de agente, usando Hermes com IQ3_XXS, IQ2_XS e as compilações 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). A 3 bits, este modelo de 125B erra esse 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 da quantização cai naquele formatamento. Turnos de chat o escondem. Turnos de agente, que são majoritariamente chamadas de ferramenta, não.

A mesma compressão machuca mais quando poucos parâmetros estão ativos. A comparação de LLMs locais para OpenCode mediu um denso de 27B a IQ3_XXS com cerca de 5% de taxa de erro numa tarefa estruturada de agente. Checkpoints MoE de baixa ativação em larguras de bit similares falharam mais: o 35B-A3B teve 64,2% de erros no IQ3_S e 98,8% no IQ4_XS, e o 122B-A10B teve 80% de erros no IQ3_S e 90% no 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 numa quantização pesada. Essas execuções OpenCode mostram IQ3 e IQ4 errando a tarefa estruturada para o 35B-A3B e o 122B-A10B; elas 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 de agente nas fontes verificadas aqui, e não cabe na caixa de 64 GB.

Os mesmos pesos GSQ-RCO falham quando são carregados no llama.cpp e no Ollama. O llama.cpp ainda restringe a emissão com uma gramática e pode elevar 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 restringida por gramática: um objeto ruim retorna HTTP 502 com structured_output_failed. O tool_call_recovery e as liberações posteriores reparam os quatro formatos listados acima. Eles não mudam a distribuição de que o modelo amostra, o que é o motivo pelo qual o wrapper do problema #1431 não poderia subir acima da taxa de emissão.

O Strata gasta RAM para manter a CPU e a GPU em compasso. Em 64 GB, o pacote maior da ISTA que ainda deixa espaço para um desktop e uma VM de agente é o IQ3_XXS, e aquele pacote está abaixo do limiar de emissão medido aqui. O IQ3_S já decodifica na mesma faixa que um modelo de 27B com MTP 3, então o limite naquele pacote é RAM. Uma execução llama.cpp com um mapa preguiçoso comprometceria 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 multietapa é notavelmente mais competente. O cálculo por token está mais perto de um modelo pequeno do que de um modelo de 125B.

Quantizações abaixo do Q4 não fornecem emissão confiável de chamadas de ferramenta para trabalho agêntico, falhando em taxas que produzem laços de repetição tanto no Strata quanto no llama.cpp. O desempenho Q4 ainda não foi provado através de comparação controlada em benchmarks de agente. Quants 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.

Um Mac Studio com M5 Max e 128 GB de memória unificada pode segurar a compilação MLX de 105 GB ou um pacote Q4 com folga suficiente para a pilha de agente. A arquitetura QFN foi desenhada para este modelo de descarregamento (offloading).

Eu continuarei usando no meu setup atual um modelo NVFP4 27B — 17 GB na RTX 5090 — com MTP 3, está alcançando 100+ tokens/s com chamadas de ferramenta confiáveis e sem competição de RAM. Eu retornarei ao QFN quando uma quantização de classe Q4 for benchmarkada em tarefas de agente, 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 paper do OSDI 2026 de 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_recovery e as medições de prioridade de rota.
• Qwen/Qwen3.8-Flash-Next — arquitetura, presets de amostragem e a tabela de benchmarks.
• ISTA-DASLab Qwen3.8-Flash-Next GSQ-RCO GGUFs — as compilações Q2 e IQ3 no banco de testes.
• Problema #1431, problema #2685, problema #804 e problema #4402 — os relatos de falha nas seções de comunidade e placa pequena.

Links Úteis

• Escolhendo o Melhor LLM para Ollama em uma GPU com 16 GB de VRAM — alternativas de modelo denso quando a placa é o limite.
• Folha de dicas do Ollama — o outro servidor local para o qual os mesmos GGUFs podem ser importados.