A Thinking Machines Lab lançou o Inkling 2 Mini em 20 de novembro com uma promessa incomum para um modelo aberto tão capaz: ele roda em um laptop. A empresa oferece suporte a ele em qualquer Mac com 32 GB de memória ou mais, por meio do Ollama. Seus pesquisadores até o rodaram offline em um MacBook Pro durante um voo, onde ele construiu um simulador de voo jogável. Este guia mostra, passo a passo, como rodar o Inkling 2 Mini com Ollama em um Mac de 32 GB. Começa com uma instalação limpa e termina com um agente de codificação local funcionando.
A versão curta são três comandos. A versão longa é o motivo de este guia existir. Em um Mac de 32 GB, o modelo ocupa cerca de 20 GB. Por padrão, o macOS também mantém aproximadamente um terço da sua memória longe do processador gráfico. O Ollama responde dando ao modelo um contexto de 4.000 tokens: bom para um chat, pequeno demais para um agente de codificação. E na maioria dos Macs de 32 GB, prompts muito longos ainda podem ficar sem memória hoje. Nada disso é motivo para pular. É motivo para configurar direito.
Você não precisa saber programar. Vai copiar alguns comandos no Terminal, o aplicativo de linha de comando do Mac (pressione Cmd-Espaço, digite Terminal e pressione Return). Cada um é explicado. O suporte do Ollama ao Inkling 2 Mini tem poucos dias e evolui rápido, então cada fato abaixo foi verificado em 21 de novembro de 2026.
Divulgação de independência e de afiliados: Nenhuma empresa mencionada aqui patrocinou, revisou ou aprovou este guia. Ele contém um link de afiliado, ao GLM Coding Plan do Z.ai’s (na Parte 10). Assinar por meio dele garante 10% de desconto e pode me render uma comissão sem custo extra para você.
TL;DR — A versão em 60 segundos
- Você precisa: um Mac Apple silicon com 32 GB de memória ou mais, macOS 14 ou posterior, cerca de 25 GB de espaço livre em disco e Ollama 0.40.17 ou mais recente.
- Três comandos:
ollama --version(0.40.17 ou superior),ollama pull inkling-2-mini(um download de 20,2 GB),ollama run inkling-2-mini. - O detalhe dos 32 GB: os pesos ocupam 18.8 GiB, e por padrão o macOS deixa a GPU usar apenas cerca de 21.3 GiB. Então o Ollama define um contexto de 4K, pequeno demais para agentes.
- As configurações que importam: defina o contexto como 16K–32K nas Configurações do Ollama para agentes. Opcionalmente, aumente o limite de GPU para 24 GiB com
sudo sysctl iogpu.wired_limit_mb=24576(ele é redefinido ao reiniciar). Mantenha o esforço de raciocínio em high para programação, low para perguntas rápidas. Feche primeiro os aplicativos que consomem muita memória. - Seu chip importa hoje: O Ollama 0.40.17 só ativa a leitura de prompt com economia de memória para o M2 Pro, M2 Ultra, M3 Ultra, M4 Pro e M5 Pro, Max e Ultra. No único teste publicado com 32 GB, um M2 Max travou com "Insufficient Memory" depois de cerca de 12.000 tokens.
- Agentes: O Pi é o mais indicado para 32 GB, porque suas instruções e ferramentas somam menos de 1.000 tokens (
ollama launch pi --model inkling-2-mini). Ele executa comandos sem perguntar, então mantenha-o em uma pasta descartável. O OpenCode abre com cerca de 6.900 tokens e passa a perguntar antes de agir depois de uma mudança na configuração. O Claude Code pergunta por padrão, mas sua primeira solicitação mediu cerca de 32.800 tokens: melhor a partir de 48 GB. - Velocidade: sobre 24 tokens por segundo em um M2 Max de 32 GB, e cerca de 32 em um M4 Pro de 48 GB.
- Segurança: A Thinking Machines avisa que o modelo pode entrar em loop, excluir ou sobrescrever arquivos sem perguntar, e relatar seus resultados de forma incorreta. Trabalhe no Git ou em uma cópia, mantenha os avisos de permissão ativados e limite os passos do agente.
Visão geral
| Modelo | Inkling 2 Mini da Thinking Machines Lab, lançado em 20 de novembro de 2026, licença Apache 2.0 |
| Tamanho | 26,4B de parâmetros, 3,4B ativos por token; 5,4B de ativações de pesos contando suas camadas em loop |
| Tag do Ollama | inkling-2-mini (também 26b-a5b e 26b-a5b-nvfp4: o mesmo pacote de 20 GB) |
| Download | 20.188.097.271 bytes (20,2 GB, ou 18,8 GiB) |
| Tempo necessário | Cerca de meia hora, mais 3 a 60 minutos para o download |
| Versão do Ollama | 0.40.17 ou mais recente; somente Apple silicon nessa versão |
| Motor | O runner MLX do Ollama, construído sobre o framework de aprendizado de máquina da Apple |
| Sabe fazer | Entrada de texto e imagem, chamadas de ferramentas, pensamento |
| Contexto | Até 1M de tokens no modelo; padrão do Ollama na maioria dos Macs de 32 GB: 4K |
| Mínimo suportado | Mac com Apple silicon e 32 GB (Thinking Machines e Ollama) |
| macOS | 14 Sonoma ou mais recente (requisito do Ollama) |
| Esforço de raciocínio | none, minimal, low, médio, high (padrão), xhigh, max |
| Agentes em um comando | Pi, OpenCode, Claude Code, Hermes Agent e OpenClaw, via ollama launch |
| Velocidade medida | M2 Max 32 GB: cerca de 24 tok/s; M4 Pro 48 GB: cerca de 32 tok/s escrevendo, 279 tok/s lendo |
Measured speeds are third-party results.
Índice
- Parte 1 — Antes de começar: seu Mac está pronto?
- Parte 2 — Passo 1: instalar ou atualizar o Ollama
- Parte 3 — Passo 2: baixar o Inkling 2 Mini
- Parte 4 — Passo 3: executar o Inkling 2 Mini no Ollama pela primeira vez
- Parte 5 — Passo 4: configurações recomendadas para um Mac de 32 GB
- Parte 6 — A realidade dos 32 GB: seu chip importa
- Parte 7 — Passo 5: usar o Inkling 2 Mini como backend local para um agente de codificação
- Parte 8 — Quão rápido é o Inkling 2 Mini em um Mac de 32 GB?
- Parte 9 — Solução de problemas do Inkling 2 Mini no Ollama
- Parte 10 — Quando 32 GB não bastam
- Perguntas frequentes
- A conclusão

Parte 1 — Antes de começar: seu Mac está pronto?
Quatro coisas decidem se você consegue executar o Inkling 2 Mini com o Ollama: seu chip, sua memória, sua versão do macOS e seu espaço livre em disco. As três primeiras estão em uma só tela: abra o menu Apple e escolha Sobre Este Mac. Para o espaço em disco, abra Ajustes do Sistema → Geral → Armazenamento.
| Requisito | Mínimo | Por que |
|---|---|---|
| Chip | Apple silicon (qualquer chip da série M) | O Ollama 0.40.17 executa o Inkling 2 Mini somente em Apple silicon. Em Macs Intel, o Ollama só consegue usar o processador, não a GPU |
| Memória | 32 GB | o mínimo suportado pelo Thinking Machines e pelo Ollama; só o modelo ocupa cerca de 20 GB |
| macOS | 14 Sonoma ou posterior | requisito do próprio Ollama |
| Espaço livre em disco | Cerca de 25 GB | 20,2 GB para o modelo, mais espaço para o macOS respirar |
| Ollama | 0.40.17 ou mais recente | A primeira versão que conhece o modelo (Parte 2) |
E os Macs de 16 GB e 24 GB? Não com o pacote do Ollama, que é um único arquivo de 20 GB sem versão menor. Cópias comprimidas existem: a Unsloth publica arquivos de 2 e 3 bits, de cerca de 9 a 14 GB, que rodam com a compilação própria dela do llama.cpp. É uma rota diferente e mais técnica, que eu cobri em Inkling 2 Mini vs Qwen3.8-27B, junto com o que você abre mão em qualidade.
Qual Mac de 32 GB você tem?
Seu chip importa por dois motivos. O primeiro é a velocidade. Um modelo como esse escreve cada palavra lendo seus pesos ativos da memória. Então a velocidade de escrita depende muito disto largura de banda de memória: quão rápido o chip consegue ler a memória. O M1 Max e o M2 Max têm o dobro da largura de banda do M1 Pro e do M2 Pro, e cerca de três vezes a do M4 e M5 básicos.
O segundo motivo é novo e específico do Ollama 0.40.17 (a Parte 6 explica). O Ollama tem uma maneira econômica em memória de ler prompts longos para este modelo, mas ela só está ativada em alguns chips. Entre os Macs que vêm com exatamente 32 GB, só o M2 Pro tem isso hoje.
| Chip | Vem com 32 GB? | Largura de banda de memória | Leitura de prompts econômica em memória no Ollama 0.40.17 |
|---|---|---|---|
| M1 Pro | Sim | 204,8 GB/s | Não |
| M1 Max | Sim | 409,6 GB/s | Não |
| M2 Pro | Sim | 204,8 GB/s | Sim |
| M2 Max | Sim | 409,6 GB/s | Não |
| M4 | Sim | 120 GB/s | Não |
| M5 | Sim | 153,6 GB/s | Não |
| M3 Pro, M3 Max, M4 Max | versões de 36 GB | 153,6 / 307,2 / 409,6 GB/s | Não |
| M5 Max | versão de 36 GB | 460,8 GB/s | Sim |
Largura de banda e opções de memória segundo as especificações da Apple, conforme reunidas pela Wikipedia. O suporte à leitura de prompt vem do código-fonte do Ollama 0.40.17, que o habilita para o M2 Pro, o M2 Ultra, o M3 Ultra, o M4 Pro e o M5 Pro, Max e Ultra. O M4 Pro e o M5 Pro não são vendidos com 32 GB.
Máquinas com 36 GB têm cerca de 4 GB a mais de espaço do que tudo neste guia pressupõe, então os mesmos passos funcionam com uma folga um pouco maior.

Parte 2 — Passo 1: instalar ou atualizar o Ollama
O Ollama é um aplicativo gratuito que baixa modelos abertos e os executa no seu próprio Mac. Ele também roda um pequeno servidor em segundo plano, que é com quem os agentes de codificação conversam depois.
Se você ainda não tem o Ollama
- Vá para ollama.com/download e baixe a versão para Mac,
Ollama.dmg. - Abra o arquivo e arraste Ollama para a pasta Aplicativos pasta.
- Abra o Ollama em Aplicativos. Na primeira vez que ele inicia, verifica se o seu
ollamacomando está disponível no Terminal. Se não estiver, ele pede permissão para adicioná-lo a/usr/local/bin. Diga sim e digite a senha do seu Mac se for pedido. Um pequeno ícone de lhama aparece na barra de menus enquanto o Ollama está em execução. - Abra o Terminal e digite:
ollama --version
Você quer 0.40.17 ou superior.
Se você já tem o Ollama
Executar ollama --version. Se for mais antigo que 0.40.17, atualize:
- O aplicativo: O Ollama baixa atualizações sozinho. Clique no ícone de lhama na barra de menus e escolha Reiniciar para atualizar se a opção aparecer. Se não aparecer, baixe o Ollama de novo em ollama.com/download e substitua o aplicativo. Os modelos baixados continuam onde estão.
- Homebrew: execute
brew upgrade ollama. O pacote Ollama do Homebrew já estava na 0.40.17 em 21 de novembro.
Verificação de versão, 21 de novembro de 2026: O Ollama anunciou o suporte ao Inkling 2 Mini em 0.40.17 em 20 de novembro, como pré-lançamento. A versão final 0.40.17 foi marcada no GitHub em menos de um dia, e o Homebrew já a distribui. Se a página de download ainda entrega a 0.40.16, obtenha a 0.40.17 ou mais nova na página de releases do GitHub. Um Ollama mais antigo recusa o download com
pull model manifest: 412: The model you are attempting to pull requires a newer version of Ollama.
Duas configurações que vale a pena conferir (opcional)
Abra as configurações do Ollama Configurações a partir do ícone da lhama ou da janela do app.
- Nuvem. Esta chave ativa os modelos na nuvem e a busca na web do Ollama. O Inkling 2 Mini roda inteiramente no seu Mac de qualquer forma; o próprio FAQ do Ollama diz que, quando você roda localmente, ele não vê seus prompts nem seus dados. Desative Nuvem se quiser ter certeza de que nada pode cair para um modelo na nuvem. Note, porém, que as ferramentas de busca na web de alguns agentes usam a nuvem do Ollama.
- Localização do modelo. Se o seu disco interno estiver com pouco espaço, aponte isto para um SSD externo antes de antes de você baixar 20 GB.
Parte 3 — Passo 2: baixar o Inkling 2 Mini
Um comando:
ollama pull inkling-2-mini
O download tem 20.188.097.271 bytes, um pouco mais de 20 GB. Veja abaixo quanto tempo isso leva em velocidade máxima; downloads reais costumam ser mais lentos:
| Sua conexão | Tempo de download |
|---|---|
| 50 Mbit/s | cerca de 54 minutos |
| 100 Mbit/s | cerca de 27 minutos |
| 250 Mbit/s | cerca de 11 minutos |
| 500 Mbit/s | cerca de 5½ minutos |
| 1 Gbit/s | cerca de 3 minutos |
Se o download parar, rode o mesmo comando de novo e ele continua de onde parou.
Algumas coisas que vale a pena saber sobre o que você acabou de baixar:
- Só existe uma versão. As três tags na página de biblioteca do Ollama,
latest,26b-a5be26b-a5b-nvfp4, são o mesmo pacote de 20 GB. Não há uma versão menor do Ollama para escolher. - É o original, não uma cópia comprimida. A Thinking Machines treinou a maior parte dos pesos do modelo em um formato de 4 bits chamado NVFP4, e suas últimas quatro camadas em um formato de 8 bits, MXFP8. Ele é distribuído assim. O pacote do Ollama contém esses pesos, então nada se perdeu em uma conversão.
- Ele enxerga. O pacote lida com imagens e também com texto, e ele pode chamar ferramentas, que é o que permite que agentes de codificação o usem.
Confira se ele chegou:
ollama ls
Você deve ver inkling-2-mini:latest com um tamanho de 20 GB.
Parte 4 — Passo 3: executar o Inkling 2 Mini no Ollama pela primeira vez
Inicie um chat no Terminal:
ollama run inkling-2-mini --verbose
A primeira inicialização leva um pouco de tempo, porque o Ollama carrega 20 GB do seu disco na memória. Depois você vê um >>> prompt. Tente algo como:
Explique em três frases o que é um transformer com loop.
Inkling 2 Mini pensa antes de responder, então você verá o raciocínio dele aparecer primeiro, seguido pela resposta. Se preferir não ver ele pensando, inicie com --hidethinking em vez disso.
Leia os números
Como você adicionou --verbose, o Ollama imprime estatísticas depois de cada resposta. Duas linhas importam:
| Line | O que significa |
|---|---|
| taxa de avaliação do prompt | Com que velocidade o modelo ler lê a sua mensagem, em tokens por segundo |
| eval rate | Com que velocidade ele escreveu a resposta, em tokens por segundo. Um token equivale a mais ou menos três quartos de uma palavra em inglês |
Para referência, o único teste do Ollama publicado em um Mac de 32 GB, um M2 Max, mediu cerca de 24 tokens por segundo. A Parte 8 traz as outras medições.
Algumas coisas que você pode fazer em seguida
- Saia do chat: type
/byeou pressione Ctrl-D. O modelo fica na memória por cinco minutos, caso você volte. - Libere a memória agora:
ollama stop inkling-2-mini. - Pergunte sobre uma imagem: digite sua pergunta e arraste um arquivo de imagem do Finder para a janela do Terminal, que cola o caminho completo. Pressione Return.
- Use o aplicativo em vez disso: abra o aplicativo Ollama, selecione
inkling-2-minino menu de modelos e converse por lá. Você também pode soltar imagens na janela.
Verifique se o Inkling 2 Mini está rodando corretamente
Com o modelo carregado, abra uma segunda janela do Terminal e execute:
ollama ps
| Coluna | O que você quer ver |
|---|---|
| NAME | inkling-2-mini:latest |
| SIZE | Quanta memória o modelo ocupa |
| PROCESSOR | 100% GPU. Em Apple silicon, isso significa que ele está rodando no processador gráfico em memória unificada |
| CONTEXTO | Quantos tokens de conversa ele consegue manter. Na maioria dos Macs de 32 GB, isso mostra 4096 até você alterar na Parte 5 |
| RUNNER | mlx, o mecanismo do Ollama para Apple silicon |
| ATÉ | Quando o Ollama vai descarregá-lo se você não o usar |
Você também pode perguntar ao Ollama o que ele detectou ao iniciar:
grep "vram-based default context" ~/.ollama/logs/server.log | tail -1
Em um Mac de 32 GB, você deve ver um total_vram de cerca de 21 GiB e default_num_ctx=4096. Essa única linha explica a maior parte da Parte 5.
Parte 5 — Passo 4: configurações recomendadas para um Mac de 32 GB
Conversar funciona sem nenhuma alteração. Agentes de codificação e documentos longos não, por causa de como um Mac de 32 GB divide a memória. Todos os números de memória nesta parte estão em GiB, os gigabytes binários que o macOS e o Ollama informam; um Mac de "32 GB" tem 32 GiB.
Aqui está o orçamento. Os pesos do Inkling 2 Mini ocupam 18.8 GiB. Em um Mac de 32 GB, o macOS deixa o processador gráfico usar cerca de dois terços da memória, cerca de 21,3 GiB, a menos que você altere. A VisualInference mediu esses mesmos pesos originais em outro app MLX, o mlx-vlm, em um M4 Pro de 48 GB. A memória chegou ao pico de 20,3 GiB com um prompt curto, 21,4 GiB com 4.000 tokens e 22,1 GiB com 16.000 tokens. Em outras palavras, quando o prompt fica longo, só o modelo chega ao limite do orçamento padrão da GPU. E isso antes de o macOS e seus outros apps ficarem com a parte deles.

Quatro configurações fazem a diferença.
Configuração 1: comprimento de contexto (a que mais importa)
O comprimento de contexto é quanto texto o modelo consegue manter de uma vez. Isso inclui suas mensagens e as respostas dele e, no caso de um agente, o prompt de sistema, as definições de ferramentas e cada arquivo que ele leu. Pequeno demais, e um agente perde as instruções silenciosamente e começa a cometer erros estranhos. Grande demais, e você reserva memória que nunca vai usar.
O Ollama escolhe um padrão a partir da memória de GPU que detecta:
| Memória de GPU que o Ollama detecta | Contexto padrão |
|---|---|
| Menos de 23 GiB (a maioria dos Macs de 32 GB: cerca de 21,3 GiB) | 4K tokens |
| 23 a 47 GiB | 32K tokens |
| 47 GiB ou mais | 256K de tokens |
A documentação do Ollama define as faixas como menos de 24, 24–48 e 48 GiB ou mais. O código na 0.40.17 usa 23 e 47 GiB, para acomodar pequenas diferenças no que cada Mac informa.
Quanto uma janela de contexto maior custa à Inkling 2 Mini em memória, calculado a partir da configuração dela:
| Contexto | Memória extra para o contexto |
|---|---|
| 4K | 0.28 GiB |
| 8K | 0.41 GiB |
| 16K | 0.66 GiB |
| 32K | 1.16 GiB |
| 64K | 2.16 GiB |
| 128K | 4.16 GiB |
A Inkling 2 Mini precisa de menos memória por token de contexto do que a maioria dos modelos do seu tamanho. Apenas quatro das suas 24 camadas revisitam toda a conversa. A memória de trabalho usada durante a leitura de um prompt entra por cima; os picos medidos acima já a incluem.
O que definir
| O que você está fazendo | Contexto | Por que |
|---|---|---|
| Conversas e perguntas curtas | 4K–8K (o padrão serve) | É o que usa menos memória |
| Colar documentos longos ou arquivos de código | 16K | Cerca de 12.000 palavras de inglês |
| Agente Pi | 16K (8K em chips sem a leitura de prompt que economiza memória da Parte 6) | As instruções do próprio Pi são minúsculas (Parte 7) |
| OpenCode | 32K, num M2 Pro | O máximo que você consegue dar com conforto em 32 GB. O Ollama recomenda 64K ou mais para agentes, algo que este Mac não tem como bancar de verdade ao lado de um modelo de 20 GB. Em outros chips, leia a Parte 6 primeiro |
| Claude Code | 64K ou mais, segundo o Ollama | Não é realista em 32 GB; veja a Parte 7 |
Como definir
O jeito mais fácil de mudar o tamanho da janela de contexto do Ollama é pelo aplicativo: abra Configurações → Tamanho do contexto e mova o controle deslizante, que tem paradas em 4k, 8k, 16k, 32k, 64k, 128k e 256k. O Ollama reinicia o servidor para aplicar, e a configuração sobrevive a uma reinicialização do seu Mac.
Há outras três formas, úteis mais adiante:
# Apenas para uma sessão de chat, dentro de `ollama run`:
/set parameter num_ctx 16384
# Para o aplicativo Ollama, até você reiniciar o Mac (então feche e reabra o Ollama):
launchctl setenv OLLAMA_CONTEXT_LENGTH 32768
Se você já moveu o controle deslizante do aplicativo, o controle deslizante vence o launchctl ajuste.
Ou faça uma cópia do modelo com o próprio contexto embutido, o que é útil quando você quer 8K para chat mas 32K para um agente. Cole isto no Terminal; ele cria um pequeno arquivo de texto chamado Modelfile e depois o novo modelo:
cat > Modelfile <<'EOF'
FROM inkling-2-mini
PARAMETER num_ctx 32768
EOF
ollama create inkling-2-mini-32k -f Modelfile
A cópia não baixa nem duplica os 20 GB de pesos. Você então usa inkling-2-mini-32k onde você usaria inkling-2-mini. Qualquer que seja o método que você escolher, confirme na CONTEXTO coluna de ollama ps.
Configuração 2: Dê mais espaço à GPU (opcional)
O macOS limita quanta memória a GPU pode reservar para si, e o Ollama trata esse limite como a sua "VRAM". Em um Mac de 32 GB, são cerca de 21,3 GiB. Três coisas decorrem disso. O Ollama define o contexto padrão a partir dele (Configuração 1). O motor MLX do Ollama mantém o modelo carregado residente na memória até esse limite. Se o modelo for maior, ele registra um aviso de que o desempenho pode ser degradado. E quando uma única etapa de trabalho precisa de mais memória de GPU do que está disponível, o macOS a interrompe. Esse é o Insufficient Memory — o travamento da Parte 6. A documentação da Apple diz que isso significa que a GPU não tinha memória suficiente para executar um buffer de comandos.
Você pode aumentar o limite até a próxima reinicialização; a documentação do MLX, da Apple, traz o comando exatamente para isso. Verifique primeiro o valor atual; 0 significa o padrão do macOS:
sysctl iogpu.wired_limit_mb
Aumente para 24 GiB, o que deixa 8 GiB para o macOS e seus aplicativos:
sudo sysctl iogpu.wired_limit_mb=24576
Depois, encerre o Ollama pela barra de menus e abra de novo, porque o Ollama só lê o limite quando inicia. Execute o grep comando da Parte 4 novamente e total_vram ele agora deve indicar cerca de 24 GiB.
Quatro coisas para saber
- Ele também muda seu contexto padrão. Com 24 GiB detectados, o padrão do Ollama salta de 4K para 32K (a tabela acima), então talvez você nem precise da Configuração 1.
- Ele dá mais espaço à GPU, não mais memória. Ele desloca a fronteira entre a GPU e o macOS; não acrescenta memória. Se seus outros aplicativos ficarem sem, o macOS usa swap em vez disso.
- Ele volta ao padrão quando você reinicia o Mac. Isso é uma rede de segurança, não um bug. Para desfazer antes:
sudo sysctl iogpu.wired_limit_mb=0. - Não é uma configuração oficial do macOS. É muito usado para IA local, mas se o seu Mac fizer muito swap, travar ou reiniciar sem aviso durante uma sessão, volte para 0. Não passe muito de 24 GiB em um Mac de 32 GB.
Configuração 3: Esforço de raciocínio
O Inkling 2 Mini decide o quanto pensar com base em uma configuração de esforço de raciocínio . O padrão do Ollama é high. Veja como o Ollama 0.40.17 traduz os nomes no valor que o modelo realmente recebe:
| Configuração do Ollama | Esforço que o modelo recebe | Bom para |
|---|---|---|
none ou false |
0 (raciocínio oculto) | Consultas simples |
minimal |
0.1 | Fatos rápidos |
low |
0.2 | Respostas curtas, resumos, reescrita |
médio |
0.7 | Perguntas do dia a dia |
high ou true (default) |
0.9 | Programação e trabalho com agentes |
xhigh ou max |
0.99 | Problemas difíceis, quando você pode esperar |
Do renderizador do Inkling 2 Mini no Ollama 0.40.17. A Thinking Machines observa que nem o mínimo desliga o raciocínio por completo.

xhigh e max envie o mesmo valor. O padrão, high, é a configuração certa para programação.Para configurar para um chat:
ollama run inkling-2-mini --think=low
Dentro de um chat, /set nothink reduz ao nível mais baixo e oculta o raciocínio, e /set think reativa. Na API do Ollama, os mesmos nomes vão no campo think correspondente.
Minha recomendação: deixe em high para programação e agentes, onde o raciocínio se paga. Use low ou médio para perguntas rápidas, para você não ficar esperando um raciocínio longo por uma resposta de uma linha.
Configuração 4: mantenha-o carregado e descarregue quando terminar
O Ollama descarrega um modelo após cinco minutos sem uso, e carregar 20 GB de novo leva tempo. Numa sessão de agente com pausas, isso incomoda. Para mantê-lo carregado por 30 minutos após cada uso:
launchctl setenv OLLAMA_KEEP_ALIVE 30m
Depois, encerre e reabra o Ollama. Para um único chat, ollama run inkling-2-mini --keepalive 30m faz o mesmo. O outro lado: quando terminar, devolva a memória com ollama stop inkling-2-mini.
Mais dois ajustes, para os curiosos
- O modelo de rascunho integrado. A Thinking Machines entrega o Inkling 2 Mini com uma pequena rede auxiliar, a DSpark, que adivinha algumas palavras à frente. O modelo principal então as confere de uma vez. O Ollama dá suporte a isso e ativa o rascunho por padrão em qualquer modelo que inclua um gerador de rascunho. Em testes públicos de MLX fora do Ollama, a DSpark elevou a velocidade de escrita do Inkling de 43,6 para 70,9 tokens por segundo num M5 Max. Num M4 Pro, ela cortou a velocidade de 31,1 para 18,7. Então teste no seu Mac: num chat,
/set parameter draft_num_predict 0desativa; compare o desempenho eval rate com e sem. - Requisições paralelas. Desde a 0.40.17, o Ollama no Apple silicon consegue responder a várias requisições de uma vez, e cada uma precisa da sua própria memória de contexto. O Ollama escolhe um padrão cauteloso com base na sua memória livre. Se um agente que roda auxiliares em paralelo ainda empurrar seu Mac para o swap, limite a um com
launchctl setenv OLLAMA_NUM_PARALLEL 1. Depois, encerre e reabra o Ollama.
Configurações que não ajudam aqui
Guias para outros modelos costumam sugerir OLLAMA_KV_CACHE_TYPE=q8_0 para cortar pela metade a memória que um contexto usa, junto com o flash attention. No Ollama 0.40.17, essas configurações pertencem à sua llama.cpp engine; o Inkling 2 Mini roda na MLX engine, e nada no código dessa engine as lê. O mesmo vale para configurações de camadas de GPU, como num_gpu. E deixe temperature sozinho: o pacote do Ollama usa o padrão 1.0 da Thinking Machines, que também é o que a Unsloth recomenda.
Antes de uma sessão longa: libere memória
Abrir Monitor de Atividade (em Aplicativos → Utilitários) e clique na Memória aba. Na parte inferior, você vê os gráficos de Pressão de Memória e Swap Usado. Verde é bom, amarelo significa que o macOS está comprimindo a memória e vermelho significa que ele está usando swap no seu disco, o que deixa tudo lento. Antes de uma sessão de agente, feche os grandes consumidores: navegadores com muitas abas, Docker Desktop, simuladores de iPhone, editores de vídeo e de foto. Em um notebook, conecte o carregador para execuções longas.
Parte 6 — A realidade dos 32 GB: seu chip importa
Esta parte importa se o seu Mac tem um chip diferente do M2 Pro (ou de um M5 Max de 36 GB), o que vale para a maioria dos Macs de 32 GB. É também a parte que as notas de lançamento do Ollama não mencionam.
O que acontece quando o Inkling 2 Mini lê um prompt longo
Antes de escrever qualquer coisa, o modelo lê o seu prompt inteiro. O motor MLX do Ollama faz isso 2.048 tokens por vez. Para cada bloco, o Inkling 2 Mini calcula como cada novo token se relaciona com todos os tokens anteriores, usando uma medida aprendida de distância entre eles. Essa etapa precisa de uma tabela temporária que cresce com tudo o que o modelo já leu na conversa.
O Ollama 0.40.17 inclui uma maneira de economizar memória para fazer isso, que trata o prompt em blocos pequenos para a tabela nunca ficar grande. O código-fonte dele ativa isso apenas para estes chips: M2 Pro, M2 Ultra, M3 Ultra, M4 Pro e os M5 Pro, Max e Ultra. Todos os outros chips usam um método geral cujo uso de memória cresce com o prompt. Isso inclui os M1 Pro e Max, o M2 Max, o M4 básico e o M5 básico.
Como isso se saiu em um M2 Max de 32 GB
O único teste publicado do Ollama 0.40.17 em um Mac de 32 GB vem dos desenvolvedores do Genex. Eles testaram o Inkling 2 Mini em um M2 Max com 32 GB:
- O download funcionou, e uma requisição curta de chamada de ferramenta retornou uma resposta correta a cerca de 24 tokens por segundo.
- Uma requisição de 18.003 tokens travou depois de 12.288 tokens com o erro
mlx: [METAL] Command buffer execution failed: Insufficient Memory. Definir o contexto como 32.768 e o tamanho do lote como 512 não ajudou. - O prompt real deles, de 15.089 tokens, travou da mesma forma.
- Um ciclo de uso do computador guiado por capturas de tela reais funcionou.
Eles concluíram que o modelo cabe em um Mac de 32 GB para prompts curtos, mas não para os prompts longos do aplicativo deles. Por isso mudaram o aplicativo para recomendar o Inkling 2 Mini só a partir de 48 GB.
O que fazer a respeito
| Seu chip | O que esperar hoje | O que fazer |
|---|---|---|
| M2 Pro (32 GB) ou M5 Max (36 GB) | Prompts longos usam memória limitada | Agentes com contexto de 16K–32K, com o limite da GPU aumentado (Parte 5) |
| M1 Pro, M1 Max, M2 Max, M4, M5 (32 GB) | Uma sessão que passa muito de cerca de 10.000 tokens corre o risco de travar com "Insufficient Memory" | Use para conversas e documentos mais curtos; para agentes, use o Pi com contexto de 8K e inicie uma nova sessão para cada tarefa; aumente o limite da GPU; atualize o Ollama sempre que sair uma versão nova |
| M3 Pro, M3 Max, M4 Max (36 GB) | Mesmo fallback, com cerca de 4 GB a mais de espaço | Como acima, com um pouco mais de folga |
Duas coisas para manter em perspectiva. Primeiro, este é um limite de software, não um de hardware. O código de economia de memória existe; ele só ainda não está ativado para todos os chips, e a Ollama lança novas versões quase toda semana. Confira as notas de lançamento quando atualizar. Segundo, o que conta é quanto texto o modelo precisa processar em uma sessão, não o número no controle de contexto. Cada novo trecho é comparado com tudo que veio antes, então uma conversa longa pesa tanto quanto um prompt longo, e agentes de codificação constroem conversas longas rapidamente. Um contexto pequeno mantém as sessões curtas; começar sessões novas as mantém ainda mais curtas.
Parte 7 — Passo 5: usar o Inkling 2 Mini como backend local para um agente de codificação
Um agente de codificação é um programa que dá ferramentas a um modelo, como ler arquivos, editá-los e executar comandos. Ele permite que o modelo resolva uma tarefa passo a passo. Normalmente o modelo fica em um data center. Aqui, o Inkling 2 Mini no seu Mac se torna o backend local: o agente envia suas solicitações ao Ollama em vez disso.

Como funciona
Quando o Ollama está em execução, ele escuta em http://localhost:11434, um endereço que só programas no seu Mac conseguem acessar. Ele fala os formatos de API que os agentes já conhecem: um compatível com OpenAI um em http://localhost:11434/v1, um compatível com Anthropic um para o Claude Code, e o próprio. O agente envia seu prompt e as definições de ferramentas, e o Inkling 2 Mini decide qual ferramenta chamar. O agente executa essa ferramenta no seu Mac e devolve o resultado. O ciclo se repete até a tarefa terminar.
Você não precisa configurar nada disso à mão. O ollama launch comando instala os agentes compatíveis se eles não estiverem presentes, aponta-os para o Ollama e os inicia.
Antes de iniciar qualquer agente
- Defina o contexto primeiro (Parte 5). Isso importa mais do que parece: quando você inicia o OpenCode por meio de
ollama launch, o Ollama lê o contexto com que o modelo realmente foi carregado e informa esse número ao OpenCode. Se o Ollama ainda estiver em 4K, o OpenCode acredita. - Trabalhe em uma pasta de teste no Git, para que você possa ver e desfazer cada alteração:
mkdir -p ~/Projects/inkling-test
cd ~/Projects/inkling-test
git init
Na primeira vez que você usa git, o macOS pode oferecer instalar as ferramentas de linha de comando de desenvolvedor da Apple. Aceite; leva alguns minutos.
- Feche os aplicativos que consomem muita memória (Parte 5).
Qual agente você deve usar com 32 GB?
| Pi | OpenCode | Claude Code | |
|---|---|---|---|
| Configuração com um comando | ollama launch pi --model inkling-2-mini |
ollama launch opencode --model inkling-2-mini |
ollama launch claude --model inkling-2-mini |
| Você instala primeiro | Node.js | Nada; o Ollama oferece instalar | Nada; o Ollama oferece instalar |
| Instruções e ferramentas enviadas antes da sua primeira palavra | Menos de 1.000 tokens | Cerca de 6.900 tokens | Cerca de 32.800 tokens |
| Pergunta antes de executar comandos | Não, por design | Não por padrão; uma mudança de configuração o ativa | Sim, para a maioria das ações |
| Contexto a definir com 32 GB | 16K (8K em chips sem a leitura de prompt que economiza memória) | 32K em um M2 Pro | O Ollama recomenda 64K ou mais |
| Melhor em | Qualquer Mac de 32 GB, em uma pasta descartável | M2 Pro com 32 GB, ou 48 GB ou mais | 48 GB ou mais |
O número do Pi vem do próprio autor. Os números do OpenCode e do Claude Code vêm da medição da Systima, de julho de 2026, da primeira requisição de cada agente. A Systima usou um projeto vazio, sem servidores MCP, com OpenCode 1.17 e Claude Code 2.1 rodando um modelo Claude. Os dois agentes foram atualizados desde então, então leia os números como ordens de magnitude. O conselho geral do Ollama para agentes é um contexto de pelo menos 64K.

Opção A: Pi, o mais leve
O Pi é um agente de codificação deliberadamente minimalista, com quatro ferramentas: read, write, edit e bash. Seu autor diz que o prompt de sistema e as definições de ferramentas somam, juntos, menos de 1.000 tokens. Isso o torna o mais adequado para um Mac de 32 GB, e é o agente que o Ollama sugeriu no anúncio do próprio Inkling 2 Mini.
- Instale Node.js: baixe o instalador LTS em nodejs.org e execute-o.
ollama launch piprecisa donpmdo Node para instalar o Pi. - Vá até sua pasta de teste e execute:
cd ~/Projects/inkling-test
ollama launch pi --model inkling-2-mini
O Ollama instala o Pi, configura-o para usar seu modelo local e abre uma sessão.
⚠️ O Pi não pergunta nada. Seu autor o descreve como rodando em "modo YOLO total": nenhuma solicitação de permissão para operações de arquivo ou comandos, e acesso irrestrito aos seus arquivos. A Thinking Machines também avisa que o Inkling 2 Mini pode excluir ou sobrescrever arquivos sem confirmação. Juntos, isso significa: execute o Pi apenas em uma pasta descartável, nunca na sua pasta pessoal ou em um projeto sem backup. O autor sugere executá-lo dentro de um contêiner se você quiser um limite de verdade; meu guia de contêiner da Apple mostra como configurar um no Mac.
Mais um detalhe: quando o Pi é iniciado pelo Ollama, sua ferramenta de busca na web usa a busca na web na nuvem do Ollama. Isso exige uma conta Ollama e a configuração Cloud ativada. Todo o resto fica no seu Mac.
Opção B: OpenCode, o meio-termo refinado
O OpenCode é um agente de codificação de código aberto popular, com interface de terminal em tela cheia, snapshots por etapa e um sistema de permissões que você pode restringir.
cd ~/Projects/inkling-test
ollama launch opencode --model inkling-2-mini
Se o OpenCode não estiver instalado, o Ollama pergunta se deve instalá-lo; diga sim. O Ollama então repassa ao OpenCode as configurações para esta sessão, sem sobrescrever as suas ~/.config/opencode/opencode.json. Ele dimensiona os limites do OpenCode conforme o contexto com que o modelo foi carregado e reserva um quarto disso, até 8K tokens, para a resposta. Desde a versão 0.40.17, ele também repassa as opções de raciocínio do Inkling 2 Mini.
A solicitação inicial do OpenCode’s é moderada, cerca de 6.900 tokens na medição da Systima em julho. Mas cada arquivo que ele lê e cada saída de comando que recebe de volta se somam à conversa. Em um Mac de 32 GB sem a leitura de prompt econômica em memória da Parte 6, esse é o número a observar. Não é preciso ler muitos arquivos para passar dos 12.000 tokens em que o M2 Max travou.
O OpenCode v2 também encontra os modelos do Ollama sozinho ao iniciar, então você pode simplesmente executar opencode e escolher o modelo com /models. Iniciar pelo Ollama ainda é o melhor caminho em 32 GB, porque informa ao OpenCode o contexto que você realmente tem.
Faça-o perguntar antes e limite seus passos
De fábrica, o OpenCode v2 deixa o modelo executar comandos de shell e editar arquivos sem perguntar; suas regras padrão só perguntam antes de ler .env arquivos. Com um modelo cujo fabricante alerta sobre ações destrutivas, mude isso. A Thinking Machines também recomenda limitar os turnos do agente, porque o modelo às vezes fica preso em longos loops de raciocínio, especialmente durante a depuração, e a opção steps do OpenCode faz isso. Coloque as duas em ~/.config/opencode/opencode.json (crie o arquivo se ele não existir):
{
"$schema": "https://opencode.ai/config.json",
"permissions": [
{ "action": "shell", "resource": "*", "effect": "ask" },
{ "action": "edit", "resource": "*", "effect": "ask" }
],
"agents": {
"build": { "steps": 40 }
}
}
O permissions fazem o OpenCode perguntar antes de cada comando de shell e de cada edição. O build agente é o padrão do OpenCode; no último passo permitido, o OpenCode remove as ferramentas e pede ao modelo que faça um resumo. Verifique se funcionou pedindo ao OpenCode para criar um arquivo: agora ele deve perguntar antes. Se não perguntar, a documentação de permissões do OpenCode explica como os agentes podem adicionar regras próprias. Para tudo o mais sobre o OpenCode, de planos a servidores MCP, veja meu guia do OpenCode.
Opção C: Claude Code, o mais pesado
O Claude Code funciona com o Ollama por meio da API compatível com a Anthropic do Ollama, então suas solicitações vão para o seu Mac em vez dos servidores da Anthropic. Por padrão, ele pede permissão antes da maioria das ações, o que o torna o mais cauteloso dos três.
cd ~/Projects/inkling-test
ollama launch claude --model inkling-2-mini
O Ollama se oferece para instalar o Claude Code se ele estiver faltando. Se você preferir iniciá-lo depois por conta própria, estas são as configurações ollama launch que ele cuida:
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model inkling-2-mini
O Ollama 0.40.17 também permite que o Claude Code carregue ferramentas MCP apenas quando forem necessárias, em vez de todas de uma vez, o que mantém os prompts mais curtos. Mas ele não mexe nas ferramentas integradas do Claude Code, e são elas que o tornam pesado. Na medição da Systima em julho, sem nenhum servidor MCP, a primeiríssima solicitação do Claude Code foi de cerca de 32.800 tokens, em sua maioria definições de ferramentas. Isso é mais do que um contexto de 32K comporta, e bem além dos 12.000 tokens em que o M2 Max travou. O Ollama recomenda um contexto de 64K ou mais para ele. Em um Mac de 32 GB, experimente se estiver curioso; conte com isso a partir de 48 GB.
Outros agentes e aplicativos
A página de biblioteca do Ollama lista inicializações com um comando para mais dois agentes, e o mesmo padrão funciona para o Codex:
ollama launch hermes --model inkling-2-mini # Hermes Agent
ollama launch openclaw --model inkling-2-mini # OpenClaw
ollama launch codex --model inkling-2-mini # OpenAI's Codex CLI
Qualquer outra ferramenta que fale a API da OpenAI também pode usar o Inkling 2 Mini. Passe a ela a URL base http://localhost:11434/v1, o nome do modelo inkling-2-mini e qualquer texto como chave de API. O Ollama não verifica a chave, mas muitas ferramentas recusam uma chave vazia.
Sua primeira tarefa de agente
Comece com algo pequeno e visível, na sua pasta de teste:
Crie uma página web de lista de tarefas em um único arquivo chamada index.html que salve as tarefas
no navegador. Mantenha simples e explique como abri-la quando terminar.
Observe o que ele faz: quais arquivos lê, o que escreve, quais comandos executa. Quando terminar, abra a página com open index.html, e confira a mudança com o Git:
git status # which files changed or appeared
git diff # what changed in files Git already knew about
Se você não gostar do resultado, apague a pasta e comece de novo. É exatamente para isso que serve uma pasta de teste.
Cinco regras para rodar um agente local com segurança
O cartão de modelo da Thinking Machines é incomumente franco sobre os modos de falha do Inkling 2 Mini. Ele pode ficar preso em longos loops de raciocínio. Pode apagar ou sobrescrever arquivos sem confirmação, e pode não relatar com precisão o resultado do seu trabalho. Também é mais propenso que modelos maiores a afirmar fatos errados com confiança. Nada disso é incomum para um modelo desse tamanho. Só significa uma coisa:
- Git or a copy, always. Nunca solte um agente em arquivos que você não consegue restaurar.
- Ative os avisos de permissão onde o agente os tem (o OpenCode precisa da mudança de configuração acima), e leia o que você aprova.
- Limite etapas e saída. Use a configuração do OpenCode
steps; em um chat do Ollama,/set parameter num_predict 4096limita uma única resposta. - Verifique as afirmações dele. Execute os testes você mesmo antes de acreditar em "todos os testes passaram".
- Nunca aponte um agente para a sua pasta pessoal. E para o Pi, use uma pasta descartável ou um contêiner.
Se você quiser ir além, o meu guia de skills de agentes e servidores MCP cobre como limitar o que as ferramentas de um agente podem alcançar. Todos os harnesses de codificação com IA comparados examina os próprios agentes em profundidade.
Parte 8 — Quão rápido é o Inkling 2 Mini em um Mac de 32 GB?
A velocidade tem duas partes: com que rapidez o modelo lê seu prompt e com que rapidez ele escreve sua resposta. Aqui estão as medições relevantes publicadas até 21 de novembro, com o runtime usado em cada uma:
| Mac | Runtime | Velocidade de escrita | Velocidade de leitura | Notas |
|---|---|---|---|---|
| M2 Max, 32 GB | Ollama 0.40.17 | Cerca de 24 tok/s | Não publicado | Requisição curta com chamada de ferramenta |
| M4 Pro, 48 GB | Ollama 0.40.17 | Cerca de 32 tok/s | 279 tok/s | Um prompt de 12.000 tokens, contexto de 64K; 65 segundos no total |
| M4 Pro, 48 GB | mlx-vlm, mesmos pesos originais | 25,9 tok/s | Não publicado | VisualInference |
| M5 Pro, 48 GB | MLX-VLM, compilação 4/8 bits da comunidade | Cerca de 27 tok/s | Cerca de 123–144 tok/s em prompts muito curtos | ModelFit; prompts muito curtos são lidos devagar, então isto não é comparável com os 279 acima |
Third-party measurements, collected on 21 November 2026. No published Ollama runs yet for the M1 Pro, M1 Max, M2 Pro, base M4 or base M5.

O que esses números significam na prática
- Para chat, cerca de 24 tokens por segundo é mais rápido do que você lê. Uma resposta de 300 palavras depois de mil tokens de raciocínio, cerca de 1.400 tokens no total, leva mais ou menos um minuto nessa velocidade. Reduza o esforço de raciocínio para perguntas rápidas e ela fica bem mais curta.
- Para agentes, a velocidade de leitura importa tanto quanto a de escrita, porque um agente envia um prompt longo a cada turno. No M4 Pro de 48 GB, um prompt de 12.000 tokens levou cerca de 43 segundos para ser lido. O Ollama reutiliza o cache do início compartilhado de uma conversa entre os turnos, então os turnos seguintes em grande parte só leem o conteúdo novo.
- Para comparar, nesse mesmo M4 Pro, o Qwen3.8-27B levou 122 segundos na tarefa de 12.000 tokens que o Inkling 2 Mini concluiu em 65. O Qwen leu a 107 e escreveu a 27 tokens por segundo. Minha comparação dos dois modelos entra no porquê e no único porém: o Inkling 2 Mini tende a escrever mais tokens por tarefa.
O que esperar em outros Macs de 32 GB
Ninguém publicou números do Ollama para os M4 e M5 básicos ainda. A largura de banda de memória deles é de 120 e 153,6 GB/s, contra 409,6 GB/s do M2 Max, que alcançou cerca de 24 tokens por segundo. Espere que sejam bem mais lentos. Quanto mais lentos é difícil dizer de antemão, porque, no software atual, o Inkling 2 Mini não acelera na proporção da largura de banda. Se você tem um, rode o --verbose teste da Parte 4 e você vai saber em um minuto.
Parte 9 — Solução de problemas do Inkling 2 Mini no Ollama
Encontre seu sintoma abaixo. Se ele não estiver listado, o log do Ollama geralmente diz o que deu errado; a última seção desta parte mostra como lê-lo.

Se o Inkling 2 Mini não baixar ou não iniciar
| Sintoma | Causa provável | Solução |
|---|---|---|
ollama pull inkling-2-mini falha com 412 e "requires a newer version" |
Ollama anterior à 0.40.17 | Atualize (Parte 2) e faça o pull de novo |
ollama: command not found |
O link da linha de comando não foi criado | Abra o aplicativo Ollama e aceite a oferta de instalar o comando, ou reinstale o aplicativo |
PROCESSOR em ollama ps não diz 100% GPU |
Há algo errado na configuração da GPU | Feche e reabra o Ollama; verifique se você está em Apple silicon e macOS 14 ou posterior |
| Você está no Windows ou no Linux | O Ollama 0.40.17 só oferece suporte ao Inkling 2 Mini em Apple silicon; os modelos exclusivos de Mac do Ollama se recusaram a baixar em outros sistemas com 412: this model requires macOS |
Espere uma versão posterior, ou use llama.cpp ou vLLM |
Se o Inkling 2 Mini travar, esquecer ou deixar seu Mac lento
| Sintoma | Causa provável | Solução |
|---|---|---|
O modelo para no meio da resposta, com Insufficient Memory ou Command buffer execution failed no log |
O prompt era longo demais para a memória do seu chip hoje (Parte 6), ou outros aplicativos ficaram com a memória | Feche aplicativos, encurte o prompt ou os documentos que você cola, use o Pi em vez de um agente mais pesado, aumente o limite da GPU (Parte 5) e atualize o Ollama |
| O agente esquece instruções, as chamadas de ferramenta falham, as edições param no meio | O contexto é pequeno demais: provavelmente o padrão de 4K | Defina 16K–32K (Parte 5) e confira a coluna CONTEXT em ollama ps. Depois, reinicie o agente |
| Seu Mac fica lentíssimo, as ventoinhas disparam, o swap cresce | Pressão de memória | Verifique o Monitor de Atividade; feche aplicativos; reduza o contexto; ollama stop qualquer outro modelo carregado |
| A primeira resposta depois de uma pausa é lenta | O Ollama descarregou o modelo após cinco minutos de inatividade | Defina OLLAMA_KEEP_ALIVE (Parte 5) |
Se um agente de codificação se comportar mal
| Sintoma | Causa provável | Solução |
|---|---|---|
| O modelo pensa por uma eternidade ou se repete | Loops longos de raciocínio, sobre os quais a Thinking Machines alerta | Dê tarefas menores, limite as etapas e os tokens de saída, use esforço menor para perguntas simples |
| O agente diz que o modelo não existe | Um erro de digitação no nome do modelo | Use exatamente inkling-2-mini; ollama ls lista o que você tem |
| A busca na web do Pi não funciona | Ele usa a busca na web na nuvem do Ollama | Entre no Ollama e ative o Cloud, ou trabalhe sem busca na web |
| O OpenCode edita arquivos sem perguntar | O OpenCode v2 permite edições e comandos de shell por padrão | Adicione as permissions regras da Parte 7 |
Verifique o log do Ollama
Os logs do Ollama ficam em ~/.ollama/logs/server.log. Para ver as últimas linhas depois que algo der errado:
tail -n 40 ~/.ollama/logs/server.log
Parte 10 — Quando 32 GB não bastam
Você vai saber que atingiu o teto quando prompts longos travarem, quando os agentes ficarem compactando a conversa sem parar, ou quando seu Mac usar swap toda vez que o modelo for carregado. As três primeiras opções não custam nada; as três últimas custam dinheiro, privacidade ou os dois.
No Mac que você tem
- Fique com ele e use-o para o que couber. Chat, documentos curtos, perguntas sobre imagens e o Pi em tarefas pequenas funcionam bem em qualquer Mac de 32 GB. Fique de olho nas notas de versão do Ollama: se a leitura de prompts com economia de memória da Parte 6 chegar a mais chips, o cenário muda da noite para o dia.
- Um arquivo menor em outro runtime. A versão 4-bit da Unsloth tem 17,6 GB, cerca de 2,6 GB menor que o pacote do Ollama, e roda com a compilação própria da Unsloth do llama.cpp. É mais técnico, e o suporte no primeiro dia foi mais acidentado; meu artigo de comparação cobre isso.
- Um modelo local diferente. O Qwen3.8-27B pontua igual ao Inkling 2 Mini no índice da Artificial Analysis, roda em qualquer lugar e é melhor em perguntas de conhecimento, mas é mais lento no mesmo Mac. Mesmo artigo.
Além do seu Mac
- Mais memória. A partir de 48 GB, o Inkling 2 Mini roda agentes com folga, e a partir de 64 GB você pode mantê-lo carregado junto com outro modelo. Se você está decidindo o que comprar, meus guias sobre se vale a pena um MacBook para LLMs locais e o MacBook Pro M5 Pro com 64 GB analisam os trade-offs.
- O irmão maior, na nuvem. O Inkling 2 Small, modelo de 594 bilhões de parâmetros da Thinking Machines, está na nuvem do Ollama como
inkling-2-small:cloud. Funciona com os mesmos comandos de inicialização, por exemploollama launch opencode --model inkling-2-small:cloud. Precisa de uma conta Ollama, e seus prompts então saem do seu Mac. - Um plano de codificação para os 10% mais difíceis. Muitas pessoas rodam um modelo local para trabalho privado e do dia a dia e direcionam o planejamento e a depuração mais difíceis para um grande modelo na nuvem. Uma opção acessível é o GLM Coding Plan da Z.ai’, que funciona no OpenCode, no Claude Code e em outros agentes. Você pode ganhar 10% de desconto no GLM Coding Plan pelo meu link de afiliado. (Link de afiliado — veja a divulgação no topo.)
Perguntas frequentes
Sim. A Thinking Machines e a Ollama suportam o Inkling 2 Mini em Macs com Apple silicon e 32 GB ou mais, através do Ollama 0.40.17 ou mais recente. O modelo ocupa cerca de 20 GB, então chat e documentos curtos funcionam bem. Prompts longos são o limite. Na maioria dos chips de 32 GB, o Ollama 0.40.17 ainda não usa a leitura de prompt com economia de memória. Um teste em um M2 Max travou depois de cerca de 12.000 tokens.
Ollama 0.40.17 ou mais recente. A Ollama anunciou o suporte ao Inkling 2 Mini na 0.40.17 em 20 de novembro de 2026 como pré-lançamento, e a versão final da 0.40.17 saiu em menos de um dia. Verifique com ollama --version. Versões mais antigas recusam o download com um erro 412. Na 0.40.17, o Inkling 2 Mini só é compatível com Apple silicon.
20.188.097.271 bytes, cerca de 20,2 GB ou 18,8 GiB. As três tags, latest, 26b-a5b e 26b-a5b-nvfp4, são o mesmo pacote: os pesos NVFP4 e MXFP8 originais da Thinking Machines’, com suporte a imagens. Não existe uma versão menor no Ollama. A 100 Mbit/s, o download leva cerca de 27 minutos.
O Ollama define seu contexto padrão a partir da memória de GPU que detecta: 4K abaixo de cerca de 23 GiB, 32K até cerca de 47 GiB e 256K acima disso. Em um Mac, esse valor é o orçamento de GPU que o macOS permite, que em um Mac de 32 GB é cerca de 21,3 GiB, então você fica com 4K. Altere isso com o controle Context length nas Configurações do Ollama, ou aumentando o orçamento de GPU para 24 GiB.
16K para o Pi, e 32K para o OpenCode em um M2 Pro, que é o máximo que um Mac de 32 GB consegue dar com conforto ao lado de um modelo de 20 GB. Em chips sem a leitura de prompt com economia de memória do Ollama, use 8K e sessões curtas. O Ollama recomenda 64K ou mais para agentes de codificação, o que funciona a partir de 48 GB. Defina isso antes de iniciar o agente, porque ollama launch opencode repassa o contexto carregado ao OpenCode.
Em um Mac de 32 GB, ajuda. Executar sudo sysctl iogpu.wired_limit_mb=24576 aumenta o orçamento de GPU de cerca de 21,3 GiB para 24 GiB e deixa 8 GiB para o macOS. O Ollama então assume um contexto de 32K por padrão. Saia e reabra o Ollama depois. A configuração volta ao padrão quando você reinicia o Mac; sudo sysctl iogpu.wired_limit_mb=0 restaura o padrão mais cedo. Não é uma configuração oficial do macOS, então desfaça se o seu Mac usar muita swap ou ficar instável.
Use o --think flag: ollama run inkling-2-mini --think=low. O Ollama aceita none, minimal, low, médio, high (o padrão), xhigh e max, que ele envia ao modelo como valores de esforço de 0 a 0,99. Dentro de um chat, /set nothink define o nível mais baixo e oculta o raciocínio. Nem o mínimo desliga o raciocínio por completo.
o Pi, porque o prompt de sistema e as ferramentas dele somam menos de 1.000 tokens, o que mantém os prompts curtos: ollama launch pi --model inkling-2-mini. Mas o Pi executa comandos sem perguntar, então use-o apenas em uma pasta descartável. O OpenCode abre com cerca de 6.900 tokens e funciona com um contexto de 32K, melhor em um M2 Pro. Ele pergunta antes de agir depois que você adiciona duas regras de permissão à configuração dele. O Claude Code pergunta por padrão, mas a primeira requisição dele mediu cerca de 32.800 tokens, mais do que um contexto de 32K comporta, então é melhor a partir de 48 GB.
Muito provavelmente, o prompt ou a conversa era longo demais para a memória de GPU do seu Mac. O Ollama 0.40.17 lê prompts longos com um método de economia de memória apenas nos M2 Pro, M2 Ultra, M3 Ultra, M4 Pro e M5 Pro, Max e Ultra. Em outros chips, o uso de memória cresce com tudo o que o modelo leu, e um M2 Max de 32 GB travou depois de 12.288 tokens. Feche outros aplicativos, mantenha as sessões curtas, use o Pi, aumente o orçamento de GPU e mantenha o Ollama atualizado.
No único teste publicado do Ollama em um Mac de 32 GB, um M2 Max, uma solicitação curta rodou a cerca de 24 tokens por segundo. Em um M4 Pro de 48 GB com Ollama 0.40.17, ele escreveu a cerca de 32 tokens por segundo e leu um prompt de 12.000 tokens a 279 tokens por segundo. Macs M4 e M5 básicos têm muito menos largura de banda de memória e devem ser mais lentos; nenhuma execução foi publicada ainda.
Não com o pacote do Ollama, que é uma única versão de 20 GB, e a Thinking Machines indica 32 GB como mínimo. A Unsloth publica arquivos de 2 e 3 bits de cerca de 9 a 14 GB que rodam com a compilação própria dela do llama.cpp em Macs menores. Eles custam um pouco de qualidade e exigem mais configuração.
Não quando ele roda localmente. O Ollama executa o modelo no seu Mac, e o FAQ dele diz que não vê seus prompts nem seus dados quando você roda localmente. Agentes de codificação iniciados com ollama launch conversam com o Ollama em localhost:11434, na sua própria máquina. Modelos na nuvem e a busca na web são diferentes: eles enviam dados para os servidores da Ollama, e você pode desativá-los com a configuração Cloud. Os agentes são programas separados, com ferramentas de rede próprias, como o web fetch do OpenCode, então confira as configurações deles se precisar trabalhar totalmente offline.
Não no Ollama 0.40.17, cujas notas de versão dizem que o Inkling 2 Mini só é compatível com Apple silicon nessa versão. Em hardware NVIDIA, a Thinking Machines oferece suporte a vLLM e SGLang, e a compilação do llama.cpp da Unsloth roda os arquivos GGUF dele. Uma versão posterior do Ollama pode adicionar outras plataformas.
Executar ollama rm inkling-2-mini. Remova quaisquer cópias que você criou com ollama create, como inkling-2-mini-32k, do mesmo jeito: os 20 GB de pesos são liberados assim que nenhum modelo os usa. Para remover o próprio Ollama, encerre-o, apague-o da pasta Applications e exclua a .ollama pasta na sua pasta de usuário; a documentação do Ollama para macOS lista todos os arquivos.
A conclusão
O Inkling 2 Mini é um modelo aberto capaz que o fabricante suporta em um Mac de 32 GB, e o Ollama torna o básico realmente fácil: instalar, baixar, rodar. Para chat, documentos e perguntas sobre imagens, um Mac de 32 GB é tudo o que você precisa.
É com agentes que os 32 GB ficam apertados, por dois motivos. O Ollama inicia a maioria dos Macs de 32 GB com uma janela de contexto de 4K, o que silenciosamente quebra os agentes até você mudar isso. E na maioria dos chips de 32 GB, prompts longos ainda podem ficar sem memória, porque a leitura de prompts com economia de memória do Ollama’s cobre apenas alguns chips. Então defina o contexto, aumente o orçamento da GPU e feche o navegador. Comece com o Pi em uma pasta descartável e atualize o Ollama com frequência.
Se você tem um M2 Pro, está na melhor posição que um Mac de 32 GB permite hoje. Se você tem 48 GB ou mais, a maioria das ressalvas aqui desaparece. E seja qual for o seu Mac, ollama run inkling-2-mini --verbose diz mais sobre a sua própria máquina em cinco minutos do que qualquer tabela deste guia.
Rodando o Inkling 2 Mini em um Mac de 32 GB? Compartilhe seu chip, versão do Ollama, configuração de contexto e --verbose números nos comentários, especialmente de um M1, M4 ou M5. Vou adicionar os resultados mais úteis à Parte 8, com os devidos créditos. Correções também são bem-vindas: com um suporte tão novo, alguns detalhes de hoje vão mudar rápido.
Divulgação: Este guia contém um link de afiliado, para o GLM Coding Plan do Z.ai’s (na Parte 10). Assinar por meio dele garante 10% de desconto e pode me render uma comissão sem custo extra para você. Nenhum outro produto ou empresa neste guia é patrocinado, e nenhum deles o revisou antes da publicação.
Fatos verificados: 21 de novembro de 2026.



