É sexta-feira à noite e você vai num comboio, portátil aberto, pronto para entregar ao Hermes aquela base de código que folheou durante o dia — só para descobrir que a sua quota de API se esgotou, enquanto a GPU discreta na mochila nunca fez mais do que jogar jogos. Ou está a rever um contrato que ainda não é público e não quer que um único carácter passe pelo servidor cloud de ninguém, nem em trânsito. Desde o início de setembro de 2026, o Hermes transformou “correr grandes modelos localmente” de um hobby trabalhoso num interruptor de um clique: descarrega e mantém por si o motor de inferência llama.cpp, escolhe a build certa de cada modelo para o seu hardware e gere a memória da GPU de ponta a ponta. Sem conta, sem API key — e, depois de um modelo ser descarregado, funciona totalmente offline.

Porque é que o DIY de modelos locais costumava ser um tormento

Se já tentou correr um modelo aberto na sua própria máquina, sabe o suplício. Primeiro instala um motor de inferência (llama.cpp, Ollama ou semelhante). Depois vai à caça de um ficheiro GGUF — o formato de empacotamento padrão da comunidade que enfia os pesos e a arquitetura de um modelo num único ficheiro. Mas isso é só o começo: downloads interrompidos que tem de refazer à mão; erros de falta de VRAM que o obrigam a descobrir que camadas despejar na RAM do sistema e em que ordem; uma janela de contexto que começa pequena demais; e escolhas de quantização (comprimir os pesos para menor precisão e poupar memória — Q4 ou Q8?) que parecem cara ou coroa.

Ferramentas como o Ollama resolveram parte disto. O Hermes vai mais longe e assume toda a cadeia — motor, downloads e colocação de memória — deixando-lhe apenas três cliques.

O fluxo em três passos no desktop

Numa build atual do Hermes Desktop, abra Definições → Fornecedores → Modelos locais. No macOS e no Windows, esta entrada agora é visível por defeito. Depois:

1. Clique em “Instalar o runtime”. O Hermes descarrega a build oficial do llama.cpp para o seu hardware (algumas centenas de MB), verifica-a e mantém-na atualizada nas releases futuras. O llama.cpp é o motor de código aberto que corre o modelo na sua GPU ou CPU.
2. Escolha um modelo do catálogo e clique em “Descarregar”.
3. Clique em “Utilizar”. Os novos chats passam a correr no modelo local.

O servidor arranca e para juntamente com o Hermes e sobrevive a reinícios do app. Voltar a um provider cloud é um clique no seletor de modelos.

O que está no catálogo — e se a sua GPU o aguenta

O catálogo selecionado tem atualmente quatro modelos, desde tamanhos de uso diário até à classe frontier:

Modelo	Perfil	Exigência de hardware
Qwen3.8 27B	Modelo agente polivalente; com capacidades de visão; contexto longo continua rápido	GPU com 16GB+ corre-o com alta qualidade
Qwen3.6 35B-A3B	Modelo maior de mixture-of-experts com previsão multi-token	GPU com 16GB+; mais margem é mais estável
Qwen3.8 Flash Next	Modelo de escala frontier	Precisa de uma GPU muito grande
DeepSeek V4 Flash	Modelo de classe frontier	Máquinas com 128GB+ de memória

Antes de descarregar seja o que for, cada linha é avaliada contra a sua máquina: encaixe de memória (verde = corre inteiramente na memória da GPU, âmbar = derrama para a RAM do sistema e corre mais devagar, vermelho = esta máquina não o consegue correr), janela de contexto e tamanho do download. O Hermes escolhe a build de mais alta qualidade que cabe inteiramente na sua GPU — e nunca oferece nada abaixo de quantização de 4 bits, porque abaixo disso a perda de qualidade é demasiado severa. Uma máquina que não aguenta a build de 4 bits simplesmente não consegue correr aquele modelo — e o Hermes diz-lho.

O catálogo é um ponto de partida selecionado, não uma fronteira. Encontrar mais modelos, na mesma página, pesquisa todo o Hugging Face, com uma verificação de encaixe por ficheiro dimensionada para a sua máquina antes de descarregar. Já tem um .gguf no disco? Adicionar ficheiro de modelo liga-o à sua biblioteca sem o copiar, utilizável de imediato.

Gestão de memória: o trabalho sujo, tratado

Os modelos locais vivem ou morrem pela colocação de memória, por isso o Hermes gere tudo de ponta a ponta e não expõe nenhuma alavanca:

• A janela de contexto começa com um tamanho que cabe inteiramente na sua GPU e cresce em direção ao máximo nativo do modelo à medida que a conversa precisa de mais espaço. Se vir “Janela de contexto expandida” no feed de estado durante sessões longas, é a janela a expandir-se — não um erro.
• Todos os modelos recomendados têm pelo menos uma janela de contexto de 64K. Quando um modelo é maior do que a memória da sua GPU, o Hermes coloca deliberadamente o excedente na RAM do sistema, na ordem que menos custa (primeiro os pesos de especialistas, nunca a cache de atenção) — trocando alguma velocidade para proteger a garantia de contexto.
• A compressão só entra em ação no tamanho máximo de janela do modelo. O crescimento vem sempre primeiro; o seu histórico nunca é resumido preventivamente.
• Modelos inativos são descarregados após 15 minutos para libertar memória da GPU, e recarregam automaticamente na mensagem seguinte.

Quer ver isto a acontecer? Clique com o botão direito na barra de estado e ative Recursos do sistema para ver a utilização da GPU, a memória da GPU e a RAM em tempo real. O medidor de contexto reflete sempre a janela com que o modelo está realmente a correr.

Privacidade e offline: depois de descarregado, nada sai da máquina

Este é o objetivo dos modelos locais, dito sem rodeios: sem conta, sem API key e sem acesso à rede depois de o modelo ser descarregado. Prompts, chamadas de ferramentas, código — tudo fica local. Para código ainda não divulgado, contratos ou dados médicos, isso não é “um pouco mais tranquilizador”, é uma categoria diferente: o pedido nunca sai do seu computador.

O Hermes também respeita setups que já correm inferência noutro lado:

• Se um llama-server já estiver a correr na sua máquina, o Hermes deteta-o e usa-o em vez de lançar o seu próprio.
• Para controlo manual total, aponte model.provider para qualquer servidor compatível com OpenAI.
• Em Ollama, MLX ou builds personalizadas, a documentação oficial tem guias dedicados de configuração do Ollama e de como correr no Mac.

Configuração: CLI e máquinas headless

A interface desktop escreve a configuração por si, mas as chaves estão abertas para uso via CLI e em máquinas headless. O runtime gerido é controlado pela secção local_runtime do config.yaml:

local_runtime:
  enabled: true     # true = iniciar o servidor gerido juntamente com o Hermes
  backend: auto     # auto | cuda | metal | vulkan | hip | cpu
                    # auto = CUDA em NVIDIA, Metal em macOS, Vulkan noutras GPUs, senão CPU

Os modelos e as builds do runtime vivem no diretório base do Hermes (models/ e runtimes/llamacpp/). Tornar um modelo local no seu modelo principal usa as definições padrão model.provider: llamacpp + model.default — com o mesmo formato de qualquer outro provider, selecionável interativamente com hermes model.

Requisitos e estado da release

• Windows e Linux: GPU NVIDIA (CUDA) ou CPU. macOS: Apple Silicon (Metal). As builds Vulkan servem GPUs AMD.
• Uma GPU com 8GB+ corre confortavelmente os modelos mais pequenos do catálogo; 16GB+ corre os modelos de 27–35B com alta qualidade.
• Os downloads são verificados byte a byte contra o catálogo; um download incompleto é apagado e reportado, nunca usado pela metade. (Os zips do motor de runtime são verificados por SHA-256.)

Uma ressalva honesta: esta capacidade chegou via PR #100667 (o próprio runtime gerido, mesclado a 1 de setembro) e PR #101823 (ponto de entrada ativo por defeito no macOS/Windows, mesclado a 3 de setembro). Atualmente vive no main upstream e ainda não foi incluída numa release — é mais recente que a v0.21.0. Para a experimentar hoje, atualize o Hermes para o main mais recente; no desktop, certifique-se de que a build inclui ambos os merges. Para contexto sobre para onde o produto agent está a caminhar, veja as nossas notas da release v0.21.0 Pantheon e o nosso guia para escolher modelos.

Resumo: de “será que corre?” a “um clique”

O verdadeiro avanço dos modelos locais não é um modelo ter ficado mais forte — é que a barreira desapareceu: o motor instala-se sozinho, a build escolhe-se sozinha, a memória gere-se sozinha e os modelos inativos descarregam-se sozinhos. O que costumava custar-lhe uma tarde de leitura de tutoriais agora são três cliques nas Definições. Da próxima vez que estiver num sítio sem ligação — ou a olhar para material que não quer entregar à cloud — lembre-se de que há um agente que viveu na sua máquina o tempo todo. Só precisava de alguém que o acordasse. Comece pelo guia de instalação e encontre depois a entrada de modelos locais no seletor de modelos (referência do comando hermes model).