Execute o Saluki 27B em menos de 8 GB

Ver no idioma original →

Autoria: Data Science in your pocket · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Run Qwen 3.8 27B in 8GBs Saluki 27B · Canal: Data Science in your pocket · 07:11 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Inferência e otimização de modelos, Modelos locais e open source

Resumo

O vídeo apresenta o Saluki 27B, um checkpoint quantizado de 2 bits baseado no Qwen 3.8-27B, compactado em um arquivo de 7,89 GB para rodar com llama.cpp padrão. Em alguns testes de tool calling, o modelo supera o Qwen original, embora a vantagem dependa do teste e possa refletir variações entre execuções. Ele mantém bom desempenho em tarefas de agentes e programação, mas fica atrás em matemática competitiva e pode apresentar falhas de formatação em chamadas paralelas. O vídeo também mostra como executá-lo e ressalta que o suporte a imagens exige um projetor de visão opcional.

Pontos-chave

• O Saluki 27B é um checkpoint quantizado de 2 bits baseado no Qwen 3.8-27B, distribuído como um arquivo GGUF de 7,89 GB.
• A quantização foi projetada para preservar o desempenho em tool calling, área em que muitas versões compactadas têm dificuldade.
• O modelo roda em llama.cpp padrão e pode caber em um laptop com GPU de 16 GB, sem runtime especial.
• No teste de 120 tarefas de tool calling, o Saluki obteve 88 acertos, contra 84 do Qwen original; a equipe alerta que a amostra é modesta.
• Em chamadas paralelas, o modelo teve mais dificuldade com o verificador estrito e cerca de um quinto das respostas precisou de um parser mais tolerante.
• Em 50 issues do SWE-bench Verified, o Saluki resolveu 30, enquanto o modelo completo resolveu 33.
• O desempenho em matemática competitiva é um ponto fraco: fica em torno de 82% a 85% do modelo completo.
• O modo de raciocínio fica ativado por padrão e pode gerar respostas longas; para tool calling direto, o vídeo recomenda desativá-lo e usar temperatura zero.
• A entrada de imagens requer um projetor de visão opcional, não incluído no arquivo principal.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do Saluki 27B	O vídeo introduz o modelo quantizado de 7,89 GB e destaca seu desempenho em tool calling.
01:40	Quantização e benchmarks de tool calling	O vídeo explica a estratégia de quantização e compara os resultados do Saluki com modelos maiores e outras versões compactadas.
03:14	Agentes, programação e limitações	São apresentados resultados em chamadas paralelas, SWE-bench Verified, navegação na web, seguimento de instruções e matemática.
04:54	Como executar o modelo	O vídeo apresenta as configurações de execução, o modo de raciocínio e a opção de adicionar entrada de imagens.
05:56	Limitações, disponibilidade e conclusão	O vídeo resume as limitações, informa onde obter o modelo e conclui que o Saluki é uma opção para agentes locais.

Citações

E se um modelo de 54 GB coubesse em menos de oito? — 00:00

A equipe reconhece uma ressalva justa: 120 tarefas é uma amostra modesta. — 02:40

A matemática competitiva é o ponto fraco mais claro. — 04:21

Compressão agressiva e confiabilidade para agentes não são incompatíveis. — 07:11

Conceitos e entidades

• Saluki 27B (modelo): Checkpoint quantizado de 2 bits baseado no Qwen 3.8-27B, apresentado como um modelo compacto voltado a agentes.
• Qwen3.8 27B (modelo): Modelo original usado como base para o Saluki 27B.
• Underdog (empresa): Equipe responsável por criar o Saluki 27B e apresentar seus resultados.
• llama.cpp (ferramenta): Runtime usado para executar o Saluki com suporte a arquivos GGUF.
• GGUF (conceito): Formato do arquivo quantizado do Saluki mencionado no vídeo.
• Berkeley function calling leaderboard (ferramenta): Referência de onde foram extraídas as tarefas de tool calling usadas no teste apresentado.
• SWE-bench Verified (benchmark): Benchmark citado para avaliar a resolução de issues reais do GitHub.
• Hugging Face (empresa): Plataforma onde o vídeo informa que o modelo está disponível.
• Conway Research (empresa): Organização sob cujo nome o Saluki é disponibilizado no Hugging Face, segundo o vídeo.

Tradução completa (pt-BR)

00:00 E se um modelo de 54 GB coubesse em menos de oito? Conheça o Saluki 27B, uma versão de 2 bits do Qwen 3.8-27B, criada por uma equipe chamada Underdog, que roda em um laptop de 16 GB com o llama.cpp padrão, sem software personalizado. E aqui vem a reviravolta: em tool calling, o que transforma um modelo de chat em um agent, esse modelo reduzido na verdade supera o original em tamanho integral. Vamos analisar como eles conseguiram isso, os benchmarks e as concessões honestas.

00:35 Saluki 27B 1.0 é um checkpoint quantizado do Qwen 3.8-27B, o modelo open source que, segundo relatos, supera o Claude Opus 4.6 Max no Artificial Analysis. A Underdog o comprimiu em um único arquivo GGUF de 7,89 GB, usando uma receita de matriz de importância baseada no lançamento de 2 bits do ISTA Desta’s labs. Ele usa a licença Apache 2.0. É um checkpoint de prévia; os detalhes completos do treinamento serão divulgados depois, e ele passou de 109 mil downloads

01:06 no primeiro mês. Por que isso é impressionante? Porque a quantização de 2 bits é o nível mais extremo. Reduza 27 bilhões de parâmetros a dois bits cada, e normalmente tudo desmorona; o primeiro sacrificado é o tool calling agentic. O modelo precisa escolher a função certa, preencher os argumentos corretamente e saber quando nenhuma ferramenta é adequada. A maioria das versões minúsculas ainda consegue conversar. Bem menos conseguem conduzir um agent com confiabilidade

01:40 do começo ao fim. A resposta da Underdog é uma quantização cuidadosa, uma receita mista IQ2 que aloca bits onde eles mais importam. O resultado mantém cerca de 96% da média do modelo completo em nove benchmarks, enquanto reduz o arquivo a aproximadamente um sétimo do tamanho. Esse tamanho é o ponto principal. Ele cabe inteiramente na GPU de um laptop de 16 GB, carrega no llama.cpp padrão

02:10 e não precisa de um runtime especial. Concorrentes como Me precisam do xLlama V3. O Saluki é apenas um GGUF padrão. O teste principal é o Underdog Bench: 120 tarefas de tool calling retiradas do Berkeley Function Calling Leaderboard, congeladas antes de qualquer modelo ser testado. Cada modelo foi executado em seu próprio runtime mais adequado. O Saluki passou em 88.

02:40 O Qwen 3.8-27B em tamanho integral, em 84. Outras versões de 2 bits ficam atrás: Me, com 85; STA, com 76; e Ternary Bonsai 2, com 70. A versão principal da própria Underdog lidera a tabela, com 91. Uma ressalva justa, feita pela própria equipe: 120 tarefas são uma amostra modesta, e parte da vantagem sobre o original se deve à variação entre execuções.

03:14 Chamadas paralelas de ferramentas, que acionam várias funções de uma só vez, são ainda mais difíceis. Em 100 tarefas paralelas com o verificador estrito oficial, o Saluki marca 42, contra 35 do modelo completo, que muitas vezes faz uma chamada e para. Com um parser mais permissivo, que corrige pequenos deslizes de formatação, o Saluki chega a 55. Essa fragilidade de formatação é real, porém. Cerca de um quinto das respostas com várias chamadas precisa do parser permissivo.

03:48 Mas benchmarks como esses são indicadores indiretos. O teste mais próximo do trabalho real de um agent: 50 issues genuínas do GitHub, do SWE-bench Verified. Explorar o código, encontrar o bug, corrigi-lo e passar nos testes do próprio projeto. O Saluki corrige 30, o modelo completo corrige 33, e o Saluki mantém 27 dessas 33 correções. Na navegação na web, clicando da página inicial até uma resposta em 150 perguntas, o Saluki responde a 60, ou 40%. Para um arquivo de 8 GB, isso representa a maior parte da capacidade agentic do

04:21 original. Em outros aspectos, o seguimento de instruções chega a ficar acima do número público do modelo completo: 93,5 na medida mais permissiva do IFEval. Em programação, alcança 78 no MBPP++. O ponto fraco honesto é a matemática de competição. No AIME, marca cerca de 80, aproximadamente 82% a 85% do modelo completo. A Underdog é transparente quanto ao posicionamento: foi feito para agents, não para olimpíadas de matemática

04:54 Rodá-lo exige um único comando: llama-server, o arquivo GGUF, a flag –jinja para o template de chat do Qwen 3.8 e flash attention com contexto de 32K. Você recebe uma API compatível com OpenAI na porta 8080, pronta para ser usada em frameworks de agent existentes. Configurações recomendadas: thinking ativado e temperature 0,6 para uso geral; para chamadas diretas e rápidas de ferramentas, desative o thinking

05:25 e defina temperature como zero. O modo thinking vem ativado por padrão e pode ser alternado a cada solicitação; o comportamento é igual ao do Qwen 3.8. Espere que ele raciocine longamente antes de responder. É daí que vem a qualidade. E, embora o arquivo principal seja apenas de texto, um projetor de visão opcional, de 629 a 928 megabytes, adiciona entrada de imagem pela mesma API de chat da OpenAI.

05:56 Texto e imagens quando você precisar. As limitações honestas, direto do cartão do modelo: ele mantém apenas 82% a 85% do desempenho em matemática de competição. Jogos de palavras no nível das letras — palíndromos, regras de vogais, ordenação alfabética — são o tipo de instrução de que ele menos gosta. Cerca de um quinto das respostas a chamadas paralelas tem pequenos deslizes de formatação. Com thinking ativado, ele pode ser prolixo. E lembre-se: visão é um complemento, não algo

06:30 integrado. Os créditos devidos: à equipe do Qwen pelo modelo-base, ao I stayed at S Lab pelo lançamento de 2 bits que serve de base, a Berkeley pelas tarefas de chamada de funções; todos usam Apache 2.0. Está no Hugging Face, sob Conway Research, com mais de 108 mil downloads no mês passado, e carrega em qualquer lugar onde o llama.cpp funciona: LM Studio, aplicativos no estilo do Ollama e seu próprio servidor. O Saluki também vem incluído no aplicativo da própria Underdog, junto com dezenas de outros modelos.

07:11 O veredito: o Saluki 27B prova que compressão extrema e confiabilidade agentic não são incompatíveis. 7,89 gigabytes, llama.cpp padrão e tool calling que supera por pouco o original de 54 gigabytes. É um checkpoint de prévia, então espere novas iterações, mas, se você está criando agents locais, este é o modelo para testar esta semana. Curta, inscreva-se e conte em que máquina você está rodando. Até a próxima.

Transcrição original

[00:00] What if a 54GB model fit in under eight? Meet Saluki 27B, a 2-bit build of Qwen 3.8-27B from a team called Underdog that runs on a 16 gig laptop with stock llama.cpp, no custom software. And here’s the twist, at tool calling, the thing that turns a chat model into an agent, this shrunken model actually beats the full-size original. Let’s break down how they pulled it off, the benchmarks, and the honest trade-offs.

[00:35] Saluki 27B 1.0 is a quantized checkpoint of Qwen 3.8-27B, the open-source model that reportedly outscores Claude Opus 4.6 Max on artificial analysis. Underdog compressed it into a single 7.89 GB GG UF file using an importance matrix recipe built on ISTA Desta’s labs 2-bit release. It’s Apache 2.0. It’s a preview checkpoint with full training details coming, and it passed 109,000 downloads

[01:06] in its first month. Why is that impressive? Because 2-bit quantization is the deep end. Crush 27 billion parameters down to two bits each and things usually fall apart, and agentic tool calling is the first casualty. The model has to pick the right function, fill in the arguments correctly, and know when no tool fits. Most tiny builds can still chat. Far fewer can reliably drive an agent

[01:40] loop. Underdog’s answer is careful quantization, an IQ2 mix recipe that spends bits where they matter most. The result keeps about 96% of the full model’s average across nine benchmarks while shrinking the file roughly seven times. That size is the whole point. It fits entirely on a 16 GB laptop GPU, loads in vanilla.llama.cpp,

[02:10] and needs no special runtime. Competitors like Me are require xlama V3. Saluki is just a standard GGUF. The headline test is underdog bench. 120 tool calling tasks pulled from the Berkeley function calling leaderboard frozen before any model was tested. Every model run in its own best runtime. Saluki passes 88.

[02:40] The full-size Qwen 3.8-27B 84. Other two-bit builds trail behind Me at 85, STA at 76, Ternary Bonsai 2 at 70. Underdog’s own main build tops the chart at 91. Fair caveat from the team itself. 120 tasks is a modest sample, and part of the lead over the original is run-to-run variation.

[03:14] Parallel tool calls firing several functions at once are even harder. On 100 parallel tasks with the official strict checker, Saluki scores 42 against the full models 35, which often makes one call and stops. With a forgiving parser that recovers small formatting slips, Saluki reaches 55. That formatting fragility is real, though. About a fifth of multi-call replies need the lenient parser.

[03:48] But, benchmarks like these are proxies. The closest thing to real agent work, 50 genuine GitHub issues from SWE-bench verified, explore the code, find the bug, fix it, pass the project’s own tests. Saluki fixes 30, the full model 33, and Saluki keeps 27 of those 33 fixes. In web browsing, clicking from a home page to an answer across 150 questions, Saluki answers 60 40%. For an 8 GB file, that’s most of the

[04:21] original’s agentic muscle. Elsewhere, instruction following actually edges above the full model’s public number 93.5 on I feebles loose measure. Coding on MBP++ lands at 78. The honest weak spot is competition math. Aim scores around 80, roughly 82 to 85% of the full model. Underdog is up front about the positioning built for agents, not math

[04:54] olympiads. Running it is one command, llama server, the GGUF file, ginger flag for the Qwen 3.8 chat template, flash attention on 32K context. You get an OpenAI compatible API on port 8080, drop-in for existing agent frameworks. Recommended settings, thinking on with temperature 0.6 for general use, for fast direct tool calls, disable thinking

[05:25] and set temperature to zero. Thinking mode is on by default and switchable per request, same behavior as Qwen 3.8. Expect it to reason at length before answering. That’s where the quality comes from. And while the main file is text only, an optional vision projector 629 to 928 megabytes adds image input through the same OpenAI chat API.

[05:56] Text plus pictures when you need them. The honest limitations, straight from the model card, it keeps only 82 to 85% of competition math. Letter level wordplay palindromes, vowel rules, alphabetical ordering is its least favored instruction type. About a fifth of parallel call replies have small formatting slips. With thinking on, it can be verbose. And remember, vision is an add-on, not

[06:30] built in. Credits where due, the Qwen team for the base model, I stayed at S Lab for the 2-bit release it builds on, Berkeley for the function calling tasks, all Apache 2.0. It’s on Hugging Face under Conway Research with over 108,000 downloads last month, and it loads anywhere llama.cpp runs, LM Studio, Ollama-style apps, your own server. Saluki also ships inside Underdog’s own app alongside dozens of other models.

[07:11] The verdict, Saluki 27B proves that brutal compression and agentic reliability aren’t mutually exclusive. 7.89 gigabytes, stock llama.cpp, tool calling that edges out the 54 gigabyte original. It’s a preview checkpoint, so expect iteration, but if you’re building local agents, this is the one to try this week. Like, subscribe, and tell me what you’re running it on. See you in the next one.