Rodando modelos de IA gigantes em um PC comum: Colibri, Strata, AirLLM e FreeToken comparados

Agora é possível rodar um modelo com centenas de bilhões de parâmetros em um PC de mesa. Se vale a pena depende de uma pergunta: quais partes do modelo precisam se mover entre o seu SSD, a sua RAM e a sua placa de vídeo, e com que frequência. Quatro engines de código aberto respondem a isso de formas diferentes, e a resposta decide se você recebe uma resposta em segundos ou uma palavra a cada quarto de minuto.

Por que isso funciona

A maioria dos grandes modelos abertos hoje é mixture-of-experts (MoE). Cada um é uma multidão de pequenas redes especialistas, e para cada palavra só algumas delas trabalham. Um modelo de 744 bilhões de parâmetros pode usar alguns por cento dos seus pesos por token. Se você conseguir manter os especialistas mais ocupados perto do processador e buscar o resto quando necessário, não precisa de memória digna de um data center.

Pense na memória da placa de vídeo como a sua mesa, na RAM como a estante atrás de você e no SSD como a biblioteca no fim do corredor. Cada especialista que não está na mesa quando é necessário custa uma ida até lá, e as engines abaixo são estratégias diferentes para fazer menos idas, e mais curtas.

Colibri: qualquer modelo, se você puder esperar

Colibri (4,2) é uma engine em C puro que trata o disco como parte da memória. Ela mantém os pesos mais usados na RAM e faz streaming dos outros especialistas a partir de um drive NVMe. Isso faz modelos enormes iniciarem em máquinas modestas, a um preço que o README declara abertamente: o GLM-5.2, um modelo de 744B, decodifica a 0,05 a 0,1 token por segundo a frio no notebook de 25 GB onde o projeto começou, mais ou menos uma palavra a cada 10 a 20 segundos. Em um Ryzen AI Max+ 395 com 128 GB, chega a 1,83. É nos modelos MoE menores que ela fica agradável: o Qwen3.6-35B-A3B roda a 6,0 tokens por segundo na CPU e 30,0 com CUDA.

O porém: "a frio" significa que nada está em cache ainda, e as primeiras execuções em um modelo grande são lentas a ponto de parecerem quebradas. Modelos grandes também significam downloads de centenas de gigabytes. O Colibri faz o parsing de arquivos de modelo muito grandes em C e publicou oito alertas de segurança em agosto, então use arquivos de modelo só de fontes em que você confia.

Strata: uma família de modelos, rápida em um PC gamer

Strata (4,0) faz o oposto: em vez de rodar tudo devagar, roda o Qwen3.8-Flash-Next e o DeepSeek V4.1-Flash rápido. Ela fixa os especialistas mais usados na GPU, calcula o resto na CPU a partir da RAM em vez de transportá-los, mantém uma grande tabela de consulta no SSD e usa decodificação especulativa, em que um pequeno modelo auxiliar rascunha palavras e o modelo principal as confere. As próprias medições do projeto em uma RTX 5070 com 12 GB e um Ryzen 5 7600 mostram 93 tokens por segundo com contexto de 4K usando o pacote Q2_0 e 53 com o IQ3_S, de maior qualidade, e relatos da comunidade em placas AMD ficam na mesma faixa.

O porém: esses pacotes precisam de 37,6 a 54,8 GB de RAM e VRAM somadas, então 64 GB de RAM é o mínimo realista. As velocidades com contexto de 4K também favorecem a imagem em relação a sessões longas de programação, e o projeto é em grande parte trabalho de um único desenvolvedor, com versões novas a cada poucos dias.

AirLLM: menos memória de GPU, mais paciência

AirLLM mantém só uma camada do modelo na GPU de cada vez, carregando cada uma do disco quando é necessária. É assim que o README pode listar um modelo de 70B em uma placa de 4 GB e o Llama 3.1 405B em 8 GB, e a linha v3 adiciona streaming por especialista para o Kimi K3, que segundo o projeto rodou em 3,72 GB de VRAM. É uma biblioteca Python, então um primeiro experimento são algumas linhas com AutoModel.

O porém: o destaque é um número de memória, não de velocidade. O AirLLM primeiro divide o checkpoint em arquivos por camada, o que o README chama de "very disk-consuming" (cerca de 360 GB para o Qwen3.8-Flash-Next), e aponta o carregamento do disco como o principal gargalo. Ele não publica números de tokens por segundo. A compressão opcional de 4 ou 8 bits o deixa até três vezes mais rápido.

FreeToken: feito para agentes que voltam para mais

FreeToken, de uma equipe de pesquisa universitária (artigo), mantém todos os pesos na RAM e transforma a memória livre da GPU em um único cache compartilhado de especialistas usados recentemente. Quando falta um especialista, ele decide caso a caso se é mais rápido copiá-lo pelo PCIe ou calculá-lo na CPU, com base na largura de banda que mede. Ele também pode mudar como a memória da GPU é dividida entre o cache de especialistas e a memória da conversa sem reiniciar.

O seu recurso diferencial é para agentes de programação. Um agente edita argumentos de ferramentas e injeta a saída de comandos no meio da conversa, o que normalmente obriga uma engine a recalcular o prompt inteiro. O FreeToken salva o estado interno do modelo em limites lógicos de tarefa e o reutiliza, então o décimo turno de uma sessão não deveria custar tanto quanto o primeiro. O passo a passo da Better Stack cobre a instalação e as velocidades em comparação com o Ollama. É Apache-2.0, suporta placas NVIDIA RTX 30, 40 e 50 no Windows e no Linux e funciona com Claude Code, Codex e OpenCode por meio de APIs compatíveis com a OpenAI e a Anthropic.

O porém: só NVIDIA por enquanto; o suporte a AMD existe apenas em um fork da comunidade. A página do projeto não publica números de benchmark próprios, e com 281 issues abertas ele está mudando rápido.

Qual testar primeiro

Escolha o modelo antes da engine. Um runtime rápido não salva um modelo que falha na sua tarefa ou que tem uma licença que você não pode usar.

Para um assistente rápido e responsivo em um PC gamer com 64 GB de RAM, a Strata é o caminho mais curto, desde que o Qwen3.8-Flash-Next ou o DeepSeek V4.1-Flash seja o modelo que você quer. Para sessões longas de agentes em uma placa NVIDIA, o FreeToken foi desenhado exatamente para essa carga; cronometre uma tarefa inteira, não uma resposta. Para testar um modelo grande demais para a sua máquina, o Colibri vai rodá-lo, devagar, e diz com honestidade quão devagar. Para um experimento em Python em uma GPU pequena em que esperar não é problema, o AirLLM é o mais simples de programar.

Se nenhum deles agradar, o llama.cpp e o Ollama continuam sendo a escolha confiável para modelos que cabem na sua memória.

Nossa opinião: a engine certa é aquela cujas idas à biblioteca combinam com a sua paciência. Meça o segundo e o décimo turno de uma sessão real, não a primeira resposta a "hello".