Pular para o conteúdo
DOMINGO, NOVEMBRO 22, 2026NOTÍCIAS DE TECNOLOGIA INDEPENDENTES, ANÁLISES & GUIAS PRÁTICOS
SOBRE
ÚLTIMAS /

Como rodar o Inkling 2 Mini em um Mac com Ollama (32 GB)

LEIA O GUIA
AGENTES DE IAGM / 053

Como rodar o Inkling 2 Mini em um Mac com Ollama (32 GB)

Execute o Inkling 2 Mini com o Ollama em um Mac de 32 GB, passo a passo: instale, baixe o modelo de 20 GB, defina a janela de contexto e a memória e, em seguida, conecte um agente de codificação local.

Run Inkling 2 Mini with Ollama on a 32GB Mac: three Terminal commands, Ollama 0.40.17, a 16K–32K context and an optional 24 GiB GPU budget

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

Cinco passos para rodar o Inkling 2 Mini com Ollama em um Mac: instale o Ollama 0.40.17, baixe o modelo de 20 GB, execute-o, defina a janela de contexto e inicie um agente de codificação
O guia inteiro em uma imagem. Os passos 1 a 3 levam alguns minutos, mais o download; o passo 4 é onde um Mac de 32 GB exige cuidado.

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.

Qual Mac de 32 GB roda o Inkling 2 Mini melhor no Ollama: largura de banda de memória e leitura de prompts com economia de memória pelo chip Apple, do M1 Pro e M2 Max ao M4 e M5
A largura de banda define a velocidade de escrita; a leitura de prompt econômica em memória do Ollama, hoje presente só em alguns chips, define o tamanho de prompt que seu Mac consegue ler com segurança.

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

  1. Vá para ollama.com/download e baixe a versão para Mac, Ollama.dmg.
  2. Abra o arquivo e arraste Ollama para a pasta Aplicativos pasta.
  3. Abra o Ollama em Aplicativos. Na primeira vez que ele inicia, verifica se o seu ollama comando 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.
  4. 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-a5b e 26b-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 /bye ou 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-mini no 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.


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.

Memória do Inkling 2 Mini em um Mac de 32 GB: 18,8 GiB de pesos e picos medidos de 20,3 a 22,1 GiB contra o orçamento padrão de GPU de 21,3 GiB e um orçamento elevado de 24 GiB
Para onde vão 32 GiB. Os picos foram medidos com mlx-vlm em um M4 Pro de 48 GB usando os mesmos pesos originais que o Ollama distribui; os números do próprio Ollama vão diferir um pouco. Os orçamentos de GPU são os padrões do macOS e o limite elevado opcional.

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.

Esforço de raciocínio do Inkling 2 Mini no Ollama: os valores think none, minimal, low, medium, high e max mapeados para os números de esforço que o modelo recebe, com high como padrão
Sete nomes, seis níveis de esforço: 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 0 desativa; 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.

Ollama como backend local para agentes de codificação: Pi, OpenCode e Claude Code enviam suas solicitações de modelo ao Inkling 2 Mini em localhost:11434, no mesmo Mac
Como as peças se encaixam. Por padrão, o Ollama escuta apenas no seu próprio Mac e fala os formatos de API que os agentes já entendem.

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

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

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

Pi vs OpenCode vs Claude Code com o Inkling 2 Mini em um Mac de 32 GB: comando de configuração, instruções por solicitação, prompts de permissão e a melhor opção para cada um
Em um Mac de 32 GB, a troca é memória contra salvaguardas: o Pi envia menos, mas não pergunta nada; o Claude Code pergunta mais, mas envia mais.

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.

  1. Instale Node.js: baixe o instalador LTS em nodejs.org e execute-o. ollama launch pi precisa do npm do Node para instalar o Pi.
  2. 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:

  1. Git or a copy, always. Nunca solte um agente em arquivos que você não consegue restaurar.
  2. 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.
  3. Limite etapas e saída. Use a configuração do OpenCode steps; em um chat do Ollama, /set parameter num_predict 4096 limita uma única resposta.
  4. Verifique as afirmações dele. Execute os testes você mesmo antes de acreditar em "todos os testes passaram".
  5. 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.

Velocidade do Inkling 2 Mini no Mac com Ollama e MLX: tokens por segundo medidos em um M2 Max de 32 GB, um M4 Pro de 48 GB e um M5 Pro de 48 GB
Velocidades de escrita publicadas, identificadas por runtime. Apenas os dois resultados do Ollama 0.40.17 vêm da configuração que este guia usa.

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.

Solução de problemas do Inkling 2 Mini no Ollama: correções para o erro 412, travamentos por memória insuficiente, uma janela de contexto de 4K, uso intenso de swap e loops de agentes em um Mac de 32 GB
A maioria dos problemas em um Mac de 32 GB se resume a duas coisas: a configuração do contexto e a pressão de memória.

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 exemplo ollama 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

Posso rodar o Inkling 2 Mini em um Mac com 32 GB de memória?

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.

Qual versão do Ollama preciso para o Inkling 2 Mini?

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.

Qual é o tamanho do download do Inkling 2 Mini no Ollama?

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.

Por que o Ollama dá ao Inkling 2 Mini apenas um contexto de 4K no meu Mac?

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.

Qual comprimento de contexto devo usar para um agente de codificação com 32 GB?

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.

Devo aumentar o limite de memória da GPU com iogpu.wired_limit_mb?

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.

Como altero o esforço de raciocínio do Inkling 2 Mini no Ollama?

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.

Qual agente de codificação funciona melhor com o Inkling 2 Mini em um Mac de 32 GB?

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.

Por que o Ollama travou com "Memória insuficiente"?

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.

Quão rápido é o Inkling 2 Mini em um Mac de 32 GB?

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.

Posso rodar o Inkling 2 Mini com Ollama em um Mac de 16 GB ou 24 GB?

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.

O Inkling 2 Mini envia meu código ou prompts para algum lugar?

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.

Posso rodar o Inkling 2 Mini com Ollama no Windows ou Linux?

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.

Como removo o Inkling 2 Mini e libero o espaço?

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.

Adicione seu sinal.

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

pt_BRPortuguês do Brasil