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

Conteúdo da página

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.

Três camadas de memória para um MoE de 125B: GPU, RAM fixada e SSD

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.

  1. 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.

  2. 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.

  3. 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

  1. Amostragem (Sampling). Na 0.2.11 uma configuração de pacote sem bloco sampling segue 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.

  2. 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.

  1. 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 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 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 para tool_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.

  2. 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_recovery foram ativados. A mesma quantização através de llama serve teve 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.

  3. Chamadas de ferramenta deixadas dentro do bloco de raciocínio. A issue #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 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

  • 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.

Subscrever

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.