Ir al contenido
DOMINGO, NOVIEMBRE 22, 2026NOTICIAS TECNOLÓGICAS INDEPENDIENTES, Reseñas y guías prácticas
ACERCA DE
ÚLTIMAS NOTICIAS /

Cómo ejecutar Inkling 2 Mini con Ollama en Mac (32 GB)

LEE LA GUÍA
Agentes de IAGM / 053

Cómo ejecutar Inkling 2 Mini con Ollama en Mac (32 GB)

Ejecuta Inkling 2 Mini con Ollama en un Mac de 32 GB, paso a paso: instala, obtén el modelo de 20 GB, ajusta el contexto y la memoria y, por último, conecta un agente de programación 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

Thinking Machines Lab publicó Inkling 2 Mini el 20 de noviembre con una promesa poco habitual para un modelo abierto tan capaz: funciona en un portátil. La empresa le da soporte en cualquier Mac con 32 GB de memoria o más, a través de Ollama. Sus investigadores incluso lo ejecutaron sin conexión en un MacBook Pro durante un vuelo, donde creó un simulador de vuelo jugable. Esta guía te muestra, paso a paso, cómo ejecutar Inkling 2 Mini con Ollama en un Mac de 32 GB. Empieza con una instalación desde cero y termina con un agente de programación local en funcionamiento.

La versión corta son tres comandos. La versión larga es la razón de que exista esta guía. En un Mac de 32 GB el modelo ocupa unos 20 GB. De forma predeterminada, macOS también mantiene aproximadamente un tercio de tu memoria lejos del procesador gráfico. Ollama responde dando al modelo un contexto de 4.000 tokens: bien para un chat, demasiado pequeño para un agente de programación. Y en la mayoría de los Mac de 32 GB, los prompts muy largos todavía pueden quedarse sin memoria hoy. Nada de eso es motivo para saltárselo. Es motivo para configurarlo bien.

No necesitas saber programar. Copiarás unos cuantos comandos en Terminal, la aplicación de línea de comandos del Mac (pulsa Cmd-Space, escribe Terminal y pulsa Return). Cada uno está explicado. El soporte de Ollama para Inkling 2 Mini tiene unos días y avanza rápido, así que todos los datos de abajo se comprobaron el 21 de noviembre de 2026.

Declaración de independencia y de afiliación: Ninguna empresa mencionada aquí patrocinó, revisó ni aprobó esta guía. Contiene un enlace de afiliado, al GLM Coding Plan de Z.ai (en la parte 10). Si te suscribes a través de él, obtienes un 10 % de descuento y puede que yo gane una comisión sin coste adicional para ti.


TL;DR — La versión de 60 segundos

  • Necesitas: un Mac con Apple silicon de 32 GB de memoria o más, macOS 14 o posterior, unos 25 GB de espacio libre en disco y Ollama 0.40.17 o posterior.
  • Tres comandos: ollama --version (0.40.17 o superior), ollama pull inkling-2-mini (una descarga de 20,2 GB), ollama run inkling-2-mini.
  • El problema con los 32 GB: los pesos ocupan 18,8 GiB, y de forma predeterminada macOS deja que la GPU use solo unos 21,3 GiB. Así que Ollama establece un contexto de 4K, demasiado pequeño para agentes.
  • Los ajustes que importan: ajusta el contexto a 16K–32K en los Ajustes de Ollama para agentes. Opcionalmente, sube el presupuesto de GPU a 24 GiB con sudo sysctl iogpu.wired_limit_mb=24576 (se restablece al reiniciar). Mantén el esfuerzo de razonamiento en alto para programar, bajo para preguntas rápidas. Cierra primero las apps que consumen mucha memoria.
  • Tu chip importa hoy: Ollama 0.40.17 activa su lectura de prompts con ahorro de memoria solo para el M2 Pro, M2 Ultra, M3 Ultra, M4 Pro y M5 Pro, Max y Ultra. En la única prueba publicada con 32 GB, un M2 Max se cayó con "Insufficient Memory" tras unos 12.000 tokens.
  • Agentes: Pi es el que mejor encaja con 32 GB, porque sus instrucciones y herramientas no llegan a 1.000 tokens (ollama launch pi --model inkling-2-mini). Ejecuta comandos sin preguntar, así que mantenlo en una carpeta desechable. OpenCode arranca con unos 6.900 tokens y pregunta primero tras un cambio de configuración. Claude Code pregunta por defecto, pero su primera petición midió unos 32.800 tokens: mejor a partir de 48 GB.
  • Velocidad: Acerca de 24 tokens por segundo en un M2 Max de 32 GB, y unos 32 en un M4 Pro de 48 GB.
  • Seguridad: Thinking Machines advierte de que el modelo puede entrar en bucle, borrar o sobrescribir archivos sin preguntar y reportar mal sus resultados. Trabaja en Git o en una copia, mantén activados los avisos de permisos y limita los pasos del agente.

De un vistazo

Modelo Inkling 2 Mini de Thinking Machines Lab, publicado el 20 de noviembre de 2026, licencia Apache 2.0
Tamaño 26,4B parámetros, 3,4B activos por token; 5,4B de activaciones de pesos contando sus capas en bucle
Etiqueta de Ollama inkling-2-mini (también 26b-a5b y 26b-a5b-nvfp4: el mismo paquete de 20 GB)
Descargar 20.188.097.271 bytes (20,2 GB, o 18,8 GiB)
Tiempo necesario Unos treinta minutos, más de 3 a 60 minutos para la descarga
Versión de Ollama 0.40.17 o posterior; solo Apple silicon en esa versión
Motor El runner MLX de Ollama, construido sobre el framework de aprendizaje automático de Apple
Puede hacer Entrada de texto e imágenes, llamadas a herramientas, razonamiento
Contexto Hasta 1M de tokens en el modelo; el valor por defecto de Ollama en la mayoría de Macs de 32 GB: 4K
Mínimo compatible Mac con Apple silicon y 32 GB (Thinking Machines y Ollama)
macOS 14 Sonoma o posterior (requisito de Ollama)
Esfuerzo de razonamiento ninguno, minimal, bajo, medio, alto (por defecto), xalto, max
Agentes con un solo comando Pi, OpenCode, Claude Code, Hermes Agent y OpenClaw, mediante ollama launch
Velocidad medida M2 Max 32 GB: unos 24 tok/s; M4 Pro 48 GB: unos 32 tok/s escribiendo, 279 tok/s leyendo

Measured speeds are third-party results.


Índice

Cinco pasos para ejecutar Inkling 2 Mini con Ollama en un Mac: instala Ollama 0.40.17, descarga el modelo de 20 GB, ejecútalo, ajusta el contexto y lanza un agente de programación
Toda la guía en una imagen. Los pasos 1 a 3 llevan unos minutos más la descarga; el paso 4 es donde un Mac de 32 GB necesita cuidado.

Parte 1 — Antes de empezar: ¿está listo tu Mac?

Cuatro cosas deciden si puedes ejecutar Inkling 2 Mini con Ollama: tu chip, tu memoria, tu versión de macOS y tu espacio libre en disco. Las tres primeras están en una sola pantalla: abre el menú Apple y elige Acerca de este Mac. Para el espacio en disco, abre Ajustes del Sistema → General → Almacenamiento.

Requisito Mínimo Por qué
Chip Apple silicon (cualquier chip de la serie M) Ollama 0.40.17 ejecuta Inkling 2 Mini solo en Apple silicon. En Macs Intel, Ollama solo puede usar el procesador, no la GPU
Memoria 32 GB El mínimo compatible de Thinking Machines’ y Ollama’s; solo el modelo ocupa unos 20 GB
macOS 14 Sonoma o posterior Requisito propio de Ollama’s
Espacio libre en disco Unos 25 GB 20,2 GB para el modelo, más espacio para que macOS respire
Ollama 0.40.17 o posterior La primera versión que conoce el modelo (parte 2)

¿Y los Macs de 16 GB y 24 GB? No con el paquete de Ollama’s, que es un único archivo de 20 GB sin una versión más pequeña. Copias comprimidas sí existen: Unsloth publica archivos de 2 y 3 bits de unos 9 a 14 GB que funcionan con su propia compilación de llama.cpp. Es una ruta distinta y más técnica, que cubrí en Inkling 2 Mini frente a Qwen3.8-27B, junto con lo que pierdes en calidad.

¿Qué Mac de 32 GB tienes?

Tu chip importa por dos razones. La primera es la velocidad. Un modelo como este escribe cada palabra leyendo sus pesos activos de la memoria. Así que la velocidad de escritura depende mucho de ancho de banda de memoria: de lo rápido que el chip puede leer la memoria. El M1 Max y el M2 Max tienen el doble de ancho de banda que el M1 Pro y el M2 Pro, y unas tres veces el de los M4 y M5 básicos.

La segunda razón es nueva y específica de Ollama 0.40.17 (la parte 6 lo explica). Ollama tiene una forma de leer prompts largos que ahorra memoria para este modelo, pero solo está activada en algunos chips. Entre los Macs que vienen con exactamente 32 GB, hoy solo la tiene el M2 Pro.

Chip ¿Viene con 32 GB? Ancho de banda de memoria Lectura de prompts con ahorro de memoria en Ollama 0.40.17
M1 Pro Sí 204,8 GB/s No
M1 Max Sí 409.6 GB/s No
M2 Pro Sí 204,8 GB/s Sí
M2 Max Sí 409.6 GB/s No
M4 Sí 120 GB/s No
M5 Sí 153.6 GB/s No
M3 Pro, M3 Max, M4 Max versiones de 36 GB 153.6 / 307.2 / 409.6 GB/s No
M5 Max versión de 36 GB 460.8 GB/s Sí

Ancho de banda y opciones de memoria según las especificaciones de Apple recopiladas por Wikipedia. La compatibilidad con la lectura de prompts viene del código fuente de Ollama 0.40.17, que la activa para el M2 Pro, M2 Ultra, M3 Ultra, M4 Pro y los M5 Pro, Max y Ultra. El M4 Pro y el M5 Pro no se venden con 32 GB.

Los equipos con 36 GB tienen unos 4 GB más de margen del que supone toda esta guía, así que los mismos pasos funcionan con un poco más de holgura.

Qué Mac de 32 GB ejecuta mejor Inkling 2 Mini en Ollama: ancho de banda de memoria y lectura de prompts con ahorro de memoria según el chip de Apple, desde M1 Pro y M2 Max hasta M4 y M5
El ancho de banda marca la velocidad de escritura; la lectura de prompts con ahorro de memoria de Ollama, que hoy solo está activa en algunos chips, marca la longitud de prompt que tu Mac puede leer sin problemas.

Parte 2 — Paso 1: instalar o actualizar Ollama

Ollama es una aplicación gratuita que descarga modelos abiertos y los ejecuta en tu propio Mac. También levanta un pequeño servidor en segundo plano, y es con ese servidor con el que luego hablan los agentes de programación.

Si aún no tienes Ollama

  1. Ir a ollama.com/download y descarga la versión para Mac, Ollama.dmg.
  2. Abre el archivo y arrastra Ollama a tu Aplicaciones carpeta.
  3. Abre Ollama desde Aplicaciones. La primera vez que se inicia, comprueba si su ollama comando está disponible en Terminal. Si no lo está, pide permiso para añadirlo a /usr/local/bin. Di que sí e introduce la contraseña de tu Mac si te la pide. Mientras Ollama se está ejecutando, aparece un pequeño icono de llama en la barra de menús.
  4. Abre Terminal y escribe:
ollama --version

Necesitas 0.40.17 o superior.

Si ya tienes Ollama

Correr ollama --version. Si es anterior a la 0.40.17, actualízalo:

  • La aplicación: Ollama descarga las actualizaciones por su cuenta. Haz clic en el icono de la llama de la barra de menús y elige Reiniciar para actualizar si aparece la opción. Si no, vuelve a descargar Ollama desde ollama.com/download y sustituye la aplicación. Los modelos que ya has descargado se quedan donde están.
  • Homebrew: correr brew upgrade ollama. El paquete de Ollama de Homebrew ya estaba en la 0.40.17 el 21 de noviembre.

Comprobación de versión, 21 de noviembre de 2026: Ollama anunció la compatibilidad con Inkling 2 Mini en 0.40.17 el 20 de noviembre, como prelanzamiento. La versión final 0.40.17 se etiquetó en GitHub en menos de un día, y Homebrew ya la distribuye. Si la página de descargas todavía te da la 0.40.16, consigue la 0.40.17 o una posterior en la página de versiones de GitHub. Una versión anterior de Ollama rechaza la descarga con pull model manifest: 412: The model you are attempting to pull requires a newer version of Ollama.

Dos ajustes que vale la pena revisar (opcional)

Abre los Ajustes de Ollama desde el icono de la llama o la ventana de la app.

  • Cloud. Este interruptor activa los modelos en la nube de Ollama y la búsqueda web. Inkling 2 Mini se ejecuta por completo en tu Mac en cualquier caso; las propias preguntas frecuentes de Ollama dicen que, cuando ejecutas en local, no ve tus prompts ni tus datos. Desactiva Cloud si quieres tener la certeza de que nada puede recurrir a un modelo en la nube. Ten en cuenta, eso sí, que las herramientas de búsqueda web de algunos agentes usan la nube de Ollama.
  • Ubicación del modelo. Si tu disco interno anda escaso de espacio, apunta esto a un SSD externo antes de antes de descargar 20 GB.

Parte 3 — Paso 2: descargar Inkling 2 Mini

Un solo comando:

ollama pull inkling-2-mini

La descarga es de 20.188.097.271 bytes, un poco más de 20 GB. Aquí tienes aproximadamente cuánto tarda a velocidad máxima; las descargas reales suelen ser más lentas:

Tu conexión Tiempo de descarga
50 Mbit/s unos 54 minutos
100 Mbit/s unos 27 minutos
250 Mbit/s unos 11 minutos
500 Mbit/s unos 5½ minutos
1 Gbit/s unos 3 minutos

Si la descarga se detiene, vuelve a ejecutar el mismo comando y continúa donde lo dejó.

Algunas cosas que conviene saber sobre lo que acabas de descargar:

  • Solo hay una versión. Las tres etiquetas de la página de la biblioteca de Ollama, latest, 26b-a5b y 26b-a5b-nvfp4, son el mismo paquete de 20 GB. No hay una versión de Ollama más pequeña que elegir.
  • Es el original, no una copia comprimida. Thinking Machines entrenó la mayoría de los pesos del modelo en un formato de 4 bits llamado NVFP4, y sus cuatro últimas capas en un formato de 8 bits, MXFP8. Se distribuyen así. El paquete de Ollama contiene esos pesos, así que no se perdió nada en una conversión.
  • Puede ver. El paquete procesa imágenes además de texto y puede llamar a herramientas, que es lo que permite que los agentes de programación lo usen.

Comprueba que ha llegado:

ollama ls

Deberías ver inkling-2-mini:latest con un tamaño de 20 GB.


Parte 4 — Paso 3: ejecutar Inkling 2 Mini en Ollama por primera vez

Inicia un chat en Terminal:

ollama run inkling-2-mini --verbose

El primer arranque tarda un poco, porque Ollama carga 20 GB de tu disco en la memoria. Después aparece un >>> prompt. Prueba algo como:

Explica en tres frases qué es un transformer con bucles.

Inkling 2 Mini piensa antes de responder, así que verás aparecer primero su razonamiento y después la respuesta. Si prefieres no verlo pensar, arráncalo con --hidethinking en su lugar.

Lee los números

Como has añadido --verbose, Ollama imprime estadísticas después de cada respuesta. Dos líneas importan:

Línea Qué significa
tasa de evaluación del prompt A qué velocidad el modelo leer tu mensaje, en tokens por segundo
eval rate A qué velocidad escribió la respuesta, en tokens por segundo. Un token es más o menos tres cuartos de una palabra en inglés

Como referencia, la única prueba publicada de Ollama en un Mac de 32 GB, un M2 Max, midió unos 24 tokens por segundo. La parte 8 tiene las demás mediciones.

Algunas cosas que puedes hacer después

  • Sal del chat: tipo /bye o pulsa Ctrl-D. El modelo se queda en memoria cinco minutos por si vuelves.
  • Libera la memoria ahora: ollama stop inkling-2-mini.
  • Pregunta sobre una imagen: escribe tu pregunta y luego arrastra un archivo de imagen desde Finder a la ventana de Terminal, que pega su ruta completa. Pulsa Return.
  • Usa la app en su lugar: abre la app de Ollama, elige inkling-2-mini en el menú de modelos y chatea ahí. También puedes soltar imágenes en la ventana.

Comprueba que Inkling 2 Mini funciona bien

Con el modelo cargado, abre una segunda ventana de Terminal y ejecuta:

ollama ps
Columna Lo que quieres ver
NAME inkling-2-mini:latest
SIZE Cuánta memoria ocupa el modelo
PROCESSOR 100% GPU. En Apple silicon, eso significa que se ejecuta en el procesador gráfico dentro de la memoria unificada
CONTEXTO Cuántos tokens de conversación puede contener. En la mayoría de los Mac de 32 GB dice 4096 hasta que lo cambies en la Parte 5
RUNNER mlx, el motor de Ollama para Apple silicon
HASTA Cuándo lo descargará Ollama si no lo usas

También puedes preguntarle a Ollama qué detectó al arrancar:

grep "vram-based default context" ~/.ollama/logs/server.log | tail -1

En un Mac de 32 GB deberías ver un total_vram de unos 21 GiB y default_num_ctx=4096. Esa sola línea explica buena parte de la Parte 5.


Chatear funciona sin cambiar nada. Los agentes de programación y los documentos largos no, por cómo reparte su memoria un Mac de 32 GB. Todas las cifras de memoria de esta parte están en GiB, los gigabytes binarios que reportan macOS y Ollama; un Mac de "32 GB" tiene 32 GiB.

Este es el presupuesto. Los pesos de Inkling 2 Mini ocupan 18,8 GiB. En un Mac de 32 GB, macOS deja que el procesador gráfico use unos dos tercios de la memoria, unos 21,3 GiB, salvo que lo cambies. VisualInference midió estos mismos pesos originales en otra app MLX, mlx-vlm, en un M4 Pro de 48 GB. La memoria alcanzó un pico de 20,3 GiB con un prompt corto, 21,4 GiB con 4.000 tokens y 22,1 GiB con 16.000 tokens. En otras palabras, cuando el prompt se alarga, solo el modelo llega al límite del presupuesto de GPU por defecto. Y eso antes de que macOS y tus otras apps se lleven su parte.

Memoria de Inkling 2 Mini en un Mac de 32 GB: 18,8 GiB de pesos y picos medidos de 20,3 a 22,1 GiB frente al presupuesto predeterminado de GPU de 21,3 GiB y un presupuesto elevado de 24 GiB
A dónde van los 32 GiB. Los picos se midieron con mlx-vlm en un M4 Pro de 48 GB usando los mismos pesos originales que distribuye Ollama; las cifras propias de Ollama variarán un poco. Los presupuestos de GPU son los valores por defecto de macOS y el límite superior opcional.

Cuatro ajustes marcan la diferencia.

Ajuste 1: longitud de contexto (el que más importa)

El longitud de contexto es cuánto texto puede retener el modelo a la vez. Eso incluye tus mensajes y sus respuestas y, en un agente, el prompt del sistema, las definiciones de herramientas y cada archivo que haya leído. Si es demasiado pequeño, el agente pierde sus instrucciones sin avisar y empieza a cometer errores raros. Si es demasiado grande, reservas memoria que nunca usarás.

Ollama elige un valor por defecto según la memoria de GPU que detecta:

Memoria de GPU que detecta Ollama Contexto por defecto
Menos de 23 GiB (la mayoría de los Mac de 32 GB: unos 21,3 GiB) 4K tokens
23 a 47 GiB 32K tokens
47 GiB o más 256 000 tokens

La documentación de Ollama da los tramos como menos de 24, 24–48 y 48 GiB o más. El código de la 0.40.17 usa 23 y 47 GiB, para dejar margen a pequeñas diferencias en lo que informa cada Mac.

Cuánta memoria le cuesta a Inkling 2 Mini un contexto mayor, calculado a partir de su configuración:

Contexto Memoria adicional para el contexto
4K 0.28 GiB
8K 0.41 GiB
16K 0.66 GiB
32K 1.16 GiB
64K 2.16 GiB
128 K 4.16 GiB

Inkling 2 Mini necesita menos memoria por token de contexto que la mayoría de los modelos de su tamaño. Solo cuatro de sus 24 capas repasan toda la conversación. La memoria de trabajo que se usa al leer un prompt se suma aparte; los picos medidos de arriba la incluyen.

Qué configurar

Qué estás haciendo Contexto Por qué
Charlar y hacer preguntas cortas 4K–8K (el valor por defecto va bien) Es lo que menos memoria usa
Pegar documentos largos o archivos de código 16K Unas 12.000 palabras de inglés
Agente Pi 16K (8K en chips sin la lectura de prompts de bajo consumo de la parte 6) Las instrucciones propias de Pi son mínimas (parte 7)
OpenCode 32K, en un M2 Pro Lo máximo que puedes darle cómodamente con 32 GB. Ollama recomienda 64K o más para agentes, algo que este Mac no puede permitirse realmente junto a un modelo de 20 GB. En otros chips, lee primero la parte 6
Claude Code 64K o más, según Ollama Poco realista con 32 GB; consulta la parte 7

Cómo configurarlo

La forma más sencilla de cambiar la longitud de contexto de Ollama es la app: abre Ajustes → Longitud de contexto y mueve el control deslizante, que tiene paradas en 4k, 8k, 16k, 32k, 64k, 128k y 256k. Ollama reinicia su servidor para aplicarlo, y el ajuste sobrevive a un reinicio de tu Mac.

Hay otras tres formas, útiles más adelante:

# Solo para una sesión de chat, dentro de `ollama run`:
/set parameter num_ctx 16384

# Para la app de Ollama, hasta que reinicies tu Mac (luego cierra y vuelve a abrir Ollama):
launchctl setenv OLLAMA_CONTEXT_LENGTH 32768

Si ya has movido el control deslizante de la app, el control deslizante tiene prioridad sobre el launchctl ajuste.

O crea una copia del modelo con su propio contexto integrado, algo práctico cuando quieres 8K para chatear pero 32K para un agente. Pega esto en Terminal; crea un archivo de texto pequeño llamado Modelfile y luego el nuevo modelo:

cat > Modelfile <<'EOF'
FROM inkling-2-mini
PARAMETER num_ctx 32768
EOF
ollama create inkling-2-mini-32k -f Modelfile

La copia no descarga ni duplica los 20 GB de pesos. Luego usas inkling-2-mini-32k allí donde usarías inkling-2-mini. Elijas el método que elijas, confírmalo en la CONTEXTO columna de ollama ps.

Ajuste 2: Dale más espacio a la GPU (opcional)

macOS limita cuánta memoria puede quedarse la GPU para sí, y Ollama trata ese límite como tu "VRAM". En un Mac de 32 GB son unos 21,3 GiB. De ahí se siguen tres cosas. Ollama fija su contexto predeterminado a partir de él (Ajuste 1). El motor MLX de Ollama mantiene el modelo cargado residente en memoria hasta ese límite. Si el modelo es más grande, registra un aviso de que el rendimiento puede degradarse. Y cuando un solo paso de trabajo necesita más memoria de GPU de la disponible, macOS lo detiene. Ese es el Insufficient Memory crash de la Parte 6. La documentación de Apple dice que significa que la GPU no tenía suficiente memoria para ejecutar un búfer de comandos.

Puedes subir el límite hasta tu próximo reinicio; la documentación de MLX de Apple da el comando justo para esto. Comprueba primero el valor actual; 0 significa el valor predeterminado de macOS:

sysctl iogpu.wired_limit_mb

Súbelo a 24 GiB, lo que deja 8 GiB para macOS y tus apps:

sudo sysctl iogpu.wired_limit_mb=24576

Luego cierra Ollama desde la barra de menús y vuelve a abrirlo, porque Ollama solo lee el límite cuando arranca. Ejecuta el grep comando de la Parte 4 otra vez y total_vram debería indicar ahora unos 24 GiB.

Cuatro cosas que debes saber

  • También cambia tu contexto predeterminado. Con 24 GiB detectados, el valor predeterminado de Ollama salta de 4K a 32K (la tabla de arriba), así que puede que no necesites el Ajuste 1 en absoluto.
  • Le da más espacio a la GPU, no más memoria. Mueve la línea entre la GPU y macOS; no añade ninguna. Si tus otras apps se quedan cortas, macOS recurre a la swap.
  • Se restablece cuando reinicias tu Mac. Es una red de seguridad, no un fallo. Para deshacerlo antes: sudo sysctl iogpu.wired_limit_mb=0.
  • No es un ajuste oficial de macOS. Se usa mucho para la IA local, pero si tu Mac tira mucho de swap, se congela o se reinicia sin avisar durante una sesión, vuelve a ponerlo en 0. No subas mucho más de 24 GiB en un Mac de 32 GB.

Ajuste 3: Esfuerzo de razonamiento

Inkling 2 Mini decide cuánto pensar según un esfuerzo de razonamiento ajuste. El valor predeterminado de Ollama es alto. Así traduce Ollama 0.40.17 los nombres al valor que recibe realmente el modelo:

Ajuste de Ollama Esfuerzo que recibe el modelo Ideal para
ninguno o false 0 (pensamiento oculto) Consultas simples
minimal 0.1 Datos rápidos
bajo 0.2 Respuestas cortas, resúmenes, reformulaciones
medio 0.7 Preguntas del día a día
alto o verdadero (predeterminada) 0.9 Programación y trabajo con agentes
xalto o max 0.99 Problemas difíciles, cuando puedes esperar

Del renderizador de Inkling 2 Mini de Ollama 0.40.17. Thinking Machines señala que incluso el mínimo no desactiva del todo el razonamiento.

Esfuerzo de razonamiento de Inkling 2 Mini en Ollama: los valores de think none, minimal, low, medium, high y max, asignados a los números de esfuerzo que recibe el modelo, con high como predeterminado
Siete nombres, seis niveles de esfuerzo: xalto y max envían el mismo valor. El predeterminado, high, es el ajuste adecuado para programar.

Para ajustarlo en un chat:

ollama run inkling-2-mini --think=low

Dentro de un chat, /set nothink lo baja al nivel más bajo y oculta el razonamiento, y /set think lo vuelve a activar. En la API de Ollama los mismos nombres van en el think campo.

Mi recomendación: déjalo en alto para programar y para agentes, donde el razonamiento se amortiza. Usa bajo o medio para preguntas rápidas, así no esperas un razonamiento largo para una respuesta de una línea.

Ajuste 4: mantenlo cargado y descárgalo cuando termines

Ollama descarga un modelo tras cinco minutos sin usarlo, y volver a cargar 20 GB lleva tiempo. En una sesión de agente con pausas, eso resulta molesto. Para mantenerlo cargado 30 minutos después de cada uso:

launchctl setenv OLLAMA_KEEP_ALIVE 30m

Después cierra y vuelve a abrir Ollama. Para un solo chat, ollama run inkling-2-mini --keepalive 30m hace lo mismo. La otra cara: cuando termines, devuelve la memoria con ollama stop inkling-2-mini.

Dos ajustes más, para los curiosos

  • El borrador integrado. Thinking Machines distribuye Inkling 2 Mini con una pequeña red auxiliar, DSpark, que adivina unas palabras por delante. El modelo principal las comprueba luego de una vez. Ollama lo admite y activa el borrado por defecto en cualquier modelo que incluya un borrador. En pruebas públicas de MLX fuera de Ollama, DSpark subió la velocidad de escritura de Inkling de 43,6 a 70,9 tokens por segundo en un M5 Max. En un M4 Pro, la bajó de 31,1 a 18,7. Así que pruébalo en tu Mac: en un chat, /set parameter draft_num_predict 0 lo desactiva; compara la eval rate con y sin.
  • Solicitudes en paralelo. Desde la 0.40.17, Ollama en Apple silicon puede responder varias solicitudes a la vez, y cada una necesita su propia memoria de contexto. Ollama elige un valor predeterminado prudente a partir de tu launchctl setenv OLLAMA_NUM_PARALLEL 1. Luego cierra y vuelve a abrir Ollama.

Ajustes que no ayudan aquí

Las guías para otros modelos suelen sugerir OLLAMA_KV_CACHE_TYPE=q8_0 para reducir a la mitad la memoria que usa un contexto, junto con flash attention. En Ollama 0.40.17 esos ajustes pertenecen a su llama.cpp motor; Inkling 2 Mini se ejecuta en el MLX motor, y nada en el código de ese motor los lee. Lo mismo pasa con ajustes de capas de GPU como num_gpu. Y deja temperature en paz: el paquete de Ollama usa el valor predeterminado de 1.0 de Thinking Machines, que es también el que recomienda Unsloth.

Antes de una sesión larga: libera memoria

Recargar Monitor de Actividad (en Aplicaciones → Utilidades) y haz clic en la Memoria pestaña. En la parte inferior verás el indicador de Presión de memoria y el de Swap usado. El verde es bueno, el amarillo significa que macOS está comprimiendo la memoria, y el rojo que está usando swap en tu disco, lo que ralentiza todo. Antes de una sesión con un agente, cierra los grandes consumidores: navegadores con muchas pestañas, Docker Desktop, simuladores de iPhone, editores de vídeo y de fotos. En un portátil, enchufa el cargador para las sesiones largas.


Parte 6 — La prueba de realidad de los 32 GB: tu chip importa

Esta parte importa si tu Mac tiene un chip distinto del M2 Pro (o un M5 Max de 36 GB), que es la mayoría de los Mac de 32 GB. También es la parte que las notas de la versión de Ollama no mencionan.

Qué ocurre cuando Inkling 2 Mini lee un prompt largo

Antes de escribir nada, un modelo lee todo tu prompt. El motor MLX de Ollama lo hace 2.048 tokens a la vez. Para cada bloque, Inkling 2 Mini calcula cómo se relaciona cada token nuevo con todos los anteriores, usando una medida de distancia aprendida entre ellos. Ese paso necesita una tabla temporal que crece con todo lo que el modelo ha leído hasta ese momento en la conversación.

forma de ahorrar memoria Ollama 0.40.17 incluye una para hacerlo, que procesa el prompt en piezas pequeñas para que la tabla nunca se haga grande. Su código fuente la activa solo para estos chips: M2 Pro, M2 Ultra, M3 Ultra, M4 Pro y los M5 Pro, Max y Ultra. Todos los demás chips recurren a un método general cuyo uso de memoria crece con el prompt. Eso incluye los M1 Pro y Max, el M2 Max, el M4 base y el M5 base.

Cómo se vio eso en un M2 Max de 32 GB

La única prueba publicada de Ollama 0.40.17 en un Mac de 32 GB viene de los desarrolladores de Genex. Probaron Inkling 2 Mini en un M2 Max con 32 GB:

  • La descarga funcionó, y una petición corta con llamadas a herramientas devolvió una respuesta correcta a unos 24 tokens por segundo.
  • Una petición de 18.003 tokens se bloqueó tras 12.288 tokens con el error mlx: [METAL] Command buffer execution failed: Insufficient Memory. Ajustar el contexto a 32.768 y el tamaño de lote a 512 no ayudó.
  • Su prompt real de 15.089 tokens se bloqueó del mismo modo.
  • Un bucle de uso del ordenador guiado por capturas de pantalla reales sí funcionó.

Concluyeron que el modelo cabe en un Mac de 32 GB para prompts cortos, pero no para los largos de su aplicación. Así que cambiaron su aplicación para recomendar Inkling 2 Mini solo a partir de 48 GB.

Qué hacer al respecto

Tu chip Qué esperar hoy Qué hacer
M2 Pro (32 GB) o M5 Max (36 GB) Los prompts largos usan memoria acotada Agentes con contexto de 16K–32K, con el presupuesto de GPU ampliado (Parte 5)
M1 Pro, M1 Max, M2 Max, M4, M5 (32 GB) Una sesión que crezca mucho más allá de unos 10.000 tokens corre el riesgo de un bloqueo por "Insufficient Memory" Úsalo para chat y documentos más cortos; para agentes, usa Pi con un contexto de 8K y empieza una sesión nueva para cada tarea; sube el presupuesto de GPU; actualiza Ollama en cuanto llegue una versión nueva
M3 Pro, M3 Max, M4 Max (36 GB) El mismo plan alternativo, con unos 4 GB más de margen Como arriba, con algo más de holgura

Dos cosas que conviene tener en cuenta. Primero, esto es un límite de software, no un límite de hardware. El código que ahorra memoria existe; simplemente aún no está activado para todos los chips, y Ollama saca versiones nuevas casi todas las semanas. Lee las notas de la versión cuando actualices. Segundo, lo que cuenta es cuánto texto tiene que procesar el modelo en una sesión, no el número del deslizador de contexto. Cada fragmento nuevo se compara con todo lo anterior, así que una conversación larga pesa tanto como un prompt largo, y los agentes de programación crean conversaciones largas enseguida. Un contexto pequeño mantiene las sesiones cortas; empezar sesiones nuevas las mantiene aún más cortas.


Parte 7 — Paso 5: usar Inkling 2 Mini como backend local para un agente de programación

Un agente de programación es un programa que le da herramientas a un modelo, como leer archivos, editarlos y ejecutar comandos. Le permite resolver una tarea paso a paso. Normalmente el modelo está en un centro de datos. Aquí, Inkling 2 Mini en tu Mac se convierte en el backend local: el agente envía sus peticiones a Ollama en su lugar.

Ollama como backend local para agentes de programación: Pi, OpenCode y Claude Code envían sus solicitudes de modelo a Inkling 2 Mini en localhost:11434, en el mismo Mac
Cómo encajan las piezas. Por defecto, Ollama solo escucha en tu propia Mac y habla los formatos de API que los agentes ya entienden.

Cómo funciona

Cuando Ollama está en marcha, escucha en http://localhost:11434, una dirección a la que solo pueden llegar los programas de tu Mac. Habla los formatos de API que los agentes ya conocen: uno compatible con OpenAI en http://localhost:11434/v1, uno compatible con Anthropic para Claude Code, y el suyo propio. El agente envía su prompt y las definiciones de herramientas, e Inkling 2 Mini decide qué herramienta llamar. El agente ejecuta esa herramienta en tu Mac y devuelve el resultado. El bucle se repite hasta que la tarea termina.

No tienes que configurar nada de eso a mano. El ollama launch comando instala los agentes compatibles si faltan, los apunta a Ollama y los inicia.

Antes de lanzar cualquier agente

  1. Configura primero el contexto (Parte 5). Importa más de lo que parece: cuando inicias OpenCode mediante ollama launch, Ollama lee el contexto con el que el modelo se cargó realmente y le dice a OpenCode ese número. Si Ollama sigue en 4K, OpenCode se lo cree.
  2. Trabaja en una carpeta de pruebas bajo Git, para que puedas ver y deshacer cada cambio:
mkdir -p ~/Projects/inkling-test
cd ~/Projects/inkling-test
git init

La primera vez que uses git, macOS puede ofrecerte instalar las herramientas de desarrollo de línea de comandos de Apple. Acepta; tarda unos minutos.

  1. Cierra las apps que consumen mucha memoria (Parte 5).

¿Qué agente deberías usar con 32 GB?

Pi OpenCode Claude Code
Configuración con un solo comando ollama launch pi --model inkling-2-mini ollama launch opencode --model inkling-2-mini ollama launch claude --model inkling-2-mini
Tú lo instalas primero Node.js Nada; Ollama te ofrece instalarlo Nada; Ollama te ofrece instalarlo
Instrucciones y herramientas enviadas antes de tu primera palabra Menos de 1.000 tokens Unos 6.900 tokens Unos 32.800 tokens
Pregunta antes de ejecutar comandos No, por diseño No por defecto; un cambio de configuración lo activa Sí, para la mayoría de acciones
Contexto que definir en 32 GB 16K (8K en chips sin la lectura de prompts que ahorra memoria) 32K en un M2 Pro Ollama recomienda 64K o más
Mejor en Cualquier Mac de 32 GB, en una carpeta desechable M2 Pro con 32 GB, o 48 GB o más 48 GB o más

La cifra de Pi viene de su autor. Las cifras de OpenCode y Claude Code proceden de la medición que hizo Systima en julio de 2026 de la primera petición de cada agente. Systima usó un proyecto vacío sin servidores MCP, OpenCode 1.17 y Claude Code 2.1 con un modelo de Claude. Ambos agentes se han actualizado desde entonces, así que toma las cifras como órdenes de magnitud. El consejo general de Ollama para agentes es un contexto de al menos 64K.

Pi frente a OpenCode frente a Claude Code con Inkling 2 Mini en un Mac de 32 GB: comando de configuración, instrucciones por solicitud, avisos de permisos y la mejor opción para cada uno
En un Mac de 32 GB el equilibrio es memoria frente a protecciones: Pi envía lo mínimo pero no pregunta nada; Claude Code pregunta lo máximo pero también envía lo máximo.

Opción A: Pi, el más ligero

Pi es un agente de programación deliberadamente minimalista con cuatro herramientas: read, write, edit y bash. Su autor dice que su prompt de sistema y las definiciones de sus herramientas juntos suman menos de 1.000 tokens. Eso lo convierte en el que mejor encaja en un Mac de 32 GB, y es el agente que Ollama sugirió en su propio anuncio de Inkling 2 Mini.

  1. Instalar Node.js: descarga el instalador LTS desde nodejs.org y ejecútalo. ollama launch pi necesita el npm de Node para instalar Pi.
  2. Ve a tu carpeta de pruebas y lanza:
cd ~/Projects/inkling-test
ollama launch pi --model inkling-2-mini

Ollama instala Pi, lo configura para usar tu modelo local y abre una sesión.

⚠️ Pi no pide nada. Su autor lo describe como si se ejecutara en "modo YOLO total": sin avisos de permiso para operaciones de archivos o comandos, y con acceso sin restricciones a tus archivos. Thinking Machines también advierte de que Inkling 2 Mini puede borrar o sobrescribir archivos sin confirmación. En conjunto, eso significa: ejecuta Pi solo en una carpeta desechable, nunca en tu carpeta personal ni en un proyecto sin copia de seguridad. Su autor sugiere ejecutarlo dentro de un contenedor si quieres un límite de verdad; mi guía de contenedores de Apple muestra cómo configurar uno en un Mac.

Un detalle más: cuando Pi se lanza a través de Ollama, su herramienta de búsqueda web usa la búsqueda web en la nube de Ollama. Eso requiere una cuenta de Ollama y la opción Cloud activada. Todo lo demás se queda en tu Mac.

Opción B: OpenCode, el punto intermedio pulido

OpenCode es un popular agente de programación de código abierto con una interfaz de terminal a pantalla completa, instantáneas por paso y un sistema de permisos que puedes endurecer.

cd ~/Projects/inkling-test
ollama launch opencode --model inkling-2-mini

Si OpenCode no está instalado, Ollama te pregunta si quieres instalarlo; di que sí. Después Ollama le pasa a OpenCode su configuración para esta sesión, sin sobrescribir la tuya ~/.config/opencode/opencode.json. Ajusta los límites de OpenCode a la ventana de contexto con la que se cargó el modelo y reserva una cuarta parte de ella, hasta 8K tokens, para la respuesta. Desde la 0.40.17 también le pasa las opciones de razonamiento de Inkling 2 Mini.

La petición inicial de OpenCode es moderada: unos 6.900 tokens en la medición de Systima de julio. Pero cada archivo que lee y cada salida de comando que recibe se suman a la conversación. En un Mac de 32 GB sin la lectura de prompts que ahorra memoria de la Parte 6, ese es el número que hay que vigilar. No hacen falta muchos archivos para pasar de los 12.000 tokens en los que se cayó el M2 Max.

OpenCode v2 también encuentra los modelos de Ollama por sí solo al arrancar, así que puedes simplemente ejecutar opencode y elegir el modelo con /models. Lanzarlo a través de Ollama sigue siendo la mejor vía en 32 GB, porque le dice a OpenCode la ventana de contexto que realmente tienes.

Haz que pregunte primero y limita sus pasos

De serie, OpenCode v2 deja que el modelo ejecute comandos de shell y edite archivos sin preguntar; sus reglas por defecto solo preguntan antes de leer .env archivos. Con un modelo cuyo fabricante avisa de acciones destructivas, cambia eso. Thinking Machines también recomienda limitar los turnos del agente, porque a veces el modelo se queda atrapado en bucles de razonamiento largos, sobre todo al depurar, y la opción steps de OpenCode hace eso. Pon ambas cosas en ~/.config/opencode/opencode.json (crea el archivo si no existe):

{
  "$schema": "https://opencode.ai/config.json",
  "permissions": [
    { "action": "shell", "resource": "*", "effect": "ask" },
    { "action": "edit", "resource": "*", "effect": "ask" }
  ],
  "agents": {
    "build": { "steps": 40 }
  }
}

El permissions hacen que OpenCode pregunte antes de cada comando de shell y de cada edición. El construir agente es el predeterminado de OpenCode; en su último paso permitido, OpenCode retira las herramientas y pide al modelo que resuma. Comprueba que ha surtido efecto pidiéndole a OpenCode que cree un archivo: ahora debería preguntarte primero. Si no lo hace, la documentación de permisos de OpenCode explica cómo los agentes pueden añadir sus propias reglas. Para todo lo demás sobre OpenCode, desde los planes hasta los servidores MCP, consulta mi guía de OpenCode.

Opción C: Claude Code, el más pesado

Claude Code funciona con Ollama a través de la API compatible con Anthropic de Ollama, así que sus peticiones van a tu Mac en lugar de a los servidores de Anthropic. Por defecto pide permiso antes de la mayoría de las acciones, lo que lo convierte en el más cauteloso de los tres.

cd ~/Projects/inkling-test
ollama launch claude --model inkling-2-mini

Ollama te ofrece instalar Claude Code si no lo tienes. Si prefieres arrancarlo tú más tarde, estos son los ajustes ollama launch que aplica:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model inkling-2-mini

Ollama 0.40.17 también permite que Claude Code cargue las herramientas MCP solo cuando hacen falta, en lugar de todas a la vez, lo que mantiene los prompts más cortos. Sin embargo, no toca las herramientas integradas de Claude Code, y son esas las que lo hacen pesado. En la medición de Systima de julio sin servidores MCP, la primera petición de Claude Code fue de unos 32.800 tokens, sobre todo definiciones de herramientas. Eso es más de lo que cabe en un contexto de 32K, y muy por encima de los 12.000 tokens en los que se cayó el M2 Max. Ollama recomienda para él un contexto de 64K o más. En un Mac de 32 GB, pruébalo si tienes curiosidad; cuenta con ello a partir de 48 GB.

Otros agentes y aplicaciones

La página de la biblioteca de Ollama lista lanzamientos de un solo comando para dos agentes más, y el mismo patrón funciona con 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

Cualquier otra herramienta que hable la API de OpenAI también puede usar Inkling 2 Mini. Dale la URL base http://localhost:11434/v1, el nombre del modelo inkling-2-mini y cualquier texto como clave de API. Ollama no comprueba la clave, pero muchas herramientas rechazan una vacía.

Tu primera tarea con un agente

Empieza con algo pequeño y visible, en tu carpeta de pruebas:

Crea una página web de lista de tareas de un solo archivo llamada index.html que guarde las tareas
en el navegador. Que sea sencilla y, cuando termines, explica cómo abrirla.

Fíjate en lo que hace: qué archivos lee, qué escribe, qué comandos ejecuta. Cuando termine, abre la página con open index.html, y comprueba el cambio con Git:

git status      # qué archivos cambiaron o aparecieron
git diff        # qué cambió en los archivos que Git ya conocía

Si no te gusta el resultado, borra la carpeta y vuelve a empezar. De eso se trata con una carpeta de pruebas.

Cinco reglas para ejecutar un agente local de forma segura

La ficha del modelo de Thinking Machines es inusualmente sincera sobre los modos de fallo de Inkling 2 Mini. Puede quedarse atrapado en bucles de razonamiento largos. Puede borrar o sobrescribir archivos sin confirmación, y puede que no informe con exactitud del resultado de su trabajo. También es más propenso que los modelos más grandes a afirmar datos falsos con seguridad. Nada de eso es raro en un modelo de este tamaño. Solo significa una cosa:

  1. Git o una copia, siempre. Nunca dejes suelto a un agente sobre archivos que no puedas restaurar.
  2. Activa las solicitudes de permiso allá donde el agente las tenga (OpenCode necesita el cambio de configuración de arriba), y lee lo que apruebas.
  3. Limita los pasos y la salida. Usa el steps; en un chat de Ollama, /set parameter num_predict 4096 limita una sola respuesta.
  4. Comprueba sus afirmaciones. Ejecuta tú mismo las pruebas antes de creerte que "todas las pruebas pasan".
  5. Nunca apuntes a un agente hacia tu carpeta personal. Y con Pi, usa una carpeta desechable o un contenedor.

Si quieres ir más lejos, mi guía de habilidades para agentes y servidores MCP explica cómo limitar hasta dónde pueden llegar las herramientas de un agente. Todos los harness de programación con IA, comparados analiza a fondo los propios agentes.


Parte 8 — ¿Qué tan rápido es Inkling 2 Mini en un Mac de 32 GB?

La velocidad tiene dos partes: lo rápido que el modelo lee tu prompt y lo rápido que escribe su respuesta. Estas son las mediciones relevantes publicadas hasta el 21 de noviembre, con el runtime que usó cada una:

Mac Duración Velocidad de escritura Velocidad de lectura Notas
M2 Max, 32 GB Ollama 0.40.17 Unos 24 tok/s Sin publicar Solicitud breve con llamadas a herramientas
M4 Pro, 48 GB Ollama 0.40.17 Unos 32 tok/s 279 tok/s Un prompt de 12.000 tokens, contexto de 64K; 65 segundos en total
M4 Pro, 48 GB mlx-vlm, los mismos pesos originales 25.9 tok/s Sin publicar VisualInference
M5 Pro, 48 GB MLX-VLM, compilación comunitaria de 4/8 bits Unos 27 tok/s Unos 123–144 tok/s con prompts muy cortos ModelFit; los prompts muy cortos se leen despacio, así que esto no es comparable con los 279 de arriba

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.

Velocidad de Inkling 2 Mini en Mac con Ollama y MLX: tokens por segundo medidos en un M2 Max de 32 GB, un M4 Pro de 48 GB y un M5 Pro de 48 GB
Velocidades de escritura publicadas, etiquetadas por runtime. Solo los dos resultados de Ollama 0.40.17 proceden de la configuración que usa esta guía.

Qué significan esos números en la práctica

  • Para chatear, unos 24 tokens por segundo es más rápido de lo que lees. Una respuesta de 300 palabras tras mil tokens de razonamiento, unos 1.400 tokens en total, tarda alrededor de un minuto a esa velocidad. Si bajas el esfuerzo de razonamiento para las preguntas rápidas, se acorta mucho.
  • Para agentes, la velocidad de lectura importa tanto como la de escritura, porque un agente envía un prompt largo en cada turno. En el M4 Pro de 48 GB, un prompt de 12.000 tokens tardó unos 43 segundos en leerse. Ollama reutiliza su caché del inicio compartido de una conversación entre turnos, así que en los turnos siguientes casi solo lee lo nuevo.
  • Para comparar, en ese mismo M4 Pro, Qwen3.8-27B tardó 122 segundos en la tarea de 12.000 tokens que Inkling 2 Mini terminó en 65. Qwen leyó a 107 y escribió a 27 tokens por segundo. Mi comparación de los dos modelos explica el porqué y también el único pero: Inkling 2 Mini tiende a escribir más tokens por tarea.

Qué esperar en otros Mac de 32 GB

Nadie ha publicado todavía cifras de Ollama para los M4 y M5 básicos. Su ancho de banda de memoria es de 120 y 153,6 GB/s, frente a los 409,6 GB/s del M2 Max que logró unos 24 tokens por segundo. Cuenta con que sean bastante más lentos. Cuánto más lento es difícil de decir por adelantado, porque con el software actual Inkling 2 Mini no acelera en proporción al ancho de banda. Si tienes uno, ejecuta la --verbose prueba de la parte 4 y lo sabrás en un minuto.


Parte 9 — Solucionar problemas de Inkling 2 Mini en Ollama

Busca tu síntoma abajo. Si no está en la lista, el registro de Ollama suele decir qué falló; la última sección de esta parte explica cómo leerlo.

Solución de problemas de Inkling 2 Mini en Ollama: arreglos para el error 412, los cierres por Insufficient Memory, un contexto de 4K, swapping intenso y bucles de agentes en un Mac de 32 GB
La mayoría de los problemas en un Mac de 32 GB se reducen a dos cosas: el ajuste de contexto y la presión de memoria.

Si Inkling 2 Mini no se descarga o no arranca

Síntoma Causa probable Fijar
ollama pull inkling-2-mini falla con 412 y "requiere una versión más reciente" Ollama anterior a 0.40.17 Actualiza (parte 2) y vuelve a hacer pull
ollama: command not found No se creó el enlace de línea de comandos Abre la app de Ollama y acepta su oferta de instalar el comando, o reinstala la app
PROCESSOR en ollama ps no dice 100% GPU Algo va mal en la configuración de la GPU Cierra y vuelve a abrir Ollama; comprueba que estás en Apple silicon y macOS 14 o posterior
Estás en Windows o Linux Ollama 0.40.17 solo admite Inkling 2 Mini en Apple silicon; los modelos exclusivos para Mac de Ollama se han negado a descargarse en otros sistemas con 412: this model requires macOS Espera a una versión posterior, o usa llama.cpp o vLLM

Si Inkling 2 Mini se cuelga, se olvida de cosas o te ralentiza el Mac

Síntoma Causa probable Fijar
El modelo se detiene a mitad de respuesta, con Insufficient Memory o Command buffer execution failed en el registro El prompt era demasiado largo para la memoria de tu chip hoy (parte 6), o otras apps se llevaron la memoria Cierra apps, acorta el prompt o los documentos que pegues, usa Pi en lugar de un agente más pesado, sube el presupuesto de GPU (parte 5) y actualiza Ollama
El agente olvida instrucciones, fallan las llamadas a herramientas, las ediciones se quedan a medias El contexto es demasiado pequeño: probablemente el valor por defecto de 4K Ajusta 16K–32K (parte 5) y comprueba la columna CONTEXT en ollama ps. Luego relanza el agente
Tu Mac se arrastra, los ventiladores giran, el swap crece Presión de memoria Comprueba el Monitor de Actividad; cierra apps; baja el contexto; ollama stop cualquier otro modelo cargado
La primera respuesta tras una pausa es lenta Ollama descargó el modelo tras cinco minutos de inactividad Conjunto OLLAMA_KEEP_ALIVE (Parte 5)

Si un agente de programación se comporta mal

Síntoma Causa probable Fijar
El modelo piensa durante una eternidad o se repite Bucles de razonamiento largos, de los que Thinking Machines advierte Dale tareas más pequeñas, limita los pasos y los tokens de salida, usa un esfuerzo menor para las preguntas simples
El agente dice que el modelo no existe Un error tipográfico en el nombre del modelo Usa exactamente inkling-2-mini; ollama ls enumera lo que tienes
La búsqueda web de Pi no funciona Usa la búsqueda web en la nube de Ollama Inicia sesión en Ollama y activa Cloud, o trabaja sin búsqueda web
OpenCode edita archivos sin preguntar OpenCode v2 permite ediciones y comandos de shell por defecto Añade las permissions reglas de la Parte 7

Revisa el registro de Ollama

Los registros de Ollama están en ~/.ollama/logs/server.log. Para ver las últimas líneas cuando algo va mal:

tail -n 40 ~/.ollama/logs/server.log

Parte 10 — Cuando 32 GB no bastan

Sabrás que has llegado al techo cuando los prompts largos fallen, cuando los agentes no paren de compactar su conversación o cuando tu Mac use swap cada vez que se carga el modelo. Las tres primeras opciones no cuestan nada; las tres últimas cuestan dinero, privacidad o ambas cosas.

En el Mac que tienes

  • Consérvalo y úsalo para lo que te sirva. El chat, los documentos cortos, las preguntas sobre imágenes y Pi en tareas pequeñas funcionan bien en cualquier Mac de 32 GB. Sigue las notas de la versión de Ollama: que la lectura de prompts con ahorro de memoria de la Parte 6 llegue a más chips cambiaría el panorama de la noche a la mañana.
  • Un archivo más pequeño en otro entorno de ejecución. La versión de 4 bits de Unsloth ocupa 17,6 GB, unos 2,6 GB menos que el paquete de Ollama, y funciona con la compilación propia de llama.cpp de Unsloth. Es más técnica, y el soporte del primer día fue más irregular; mi artículo comparativo lo cubre.
  • Un modelo local diferente. Qwen3.8-27B puntúa igual que Inkling 2 Mini en el índice de Artificial Analysis, funciona en todas partes y es mejor en preguntas de conocimiento, pero es más lento en el mismo Mac. Mismo artículo.

Más allá de tu Mac

  • Más memoria. A partir de 48 GB, Inkling 2 Mini ejecuta agentes con soltura, y desde 64 GB puedes mantenerlo cargado junto a otro modelo. Si estás decidiendo qué comprar, mis guías sobre si merece la pena un MacBook para LLM locales y el MacBook Pro M5 Pro con 64 GB repasar las ventajas y desventajas.
  • El hermano mayor, en la nube. Inkling 2 Small, el modelo de 594.000 millones de parámetros de Thinking Machines, está en la nube de Ollama como inkling-2-small:cloud. Funciona con los mismos comandos de lanzamiento, por ejemplo ollama launch opencode --model inkling-2-small:cloud. Necesita una cuenta de Ollama, y tus prompts salen entonces de tu Mac.
  • Un plan de programación para el 10 % más difícil. Mucha gente ejecuta un modelo local para el trabajo privado y del día a día, y envía la planificación y la depuración más difíciles a un gran modelo en la nube. Una opción asequible es el GLM Coding Plan de Z.ai, que funciona en OpenCode, Claude Code y otros agentes. Puedes obtener un 10% de descuento en el GLM Coding Plan con mi enlace de afiliado. (Enlace de afiliado — consulta la divulgación al principio.)

Preguntas frecuentes

¿Puedo ejecutar Inkling 2 Mini en un Mac con 32 GB de memoria?

Sí. Tanto Thinking Machines como Ollama admiten Inkling 2 Mini en Macs con Apple silicon y 32 GB o más, mediante Ollama 0.40.17 o posterior. El modelo ocupa unos 20 GB, así que el chat y los documentos cortos funcionan bien. Los prompts largos son el límite. En la mayoría de los chips de 32 GB, Ollama 0.40.17 todavía no usa su lectura de prompts que ahorra memoria. Una prueba en un M2 Max se cayó tras unos 12.000 tokens.

¿Qué versión de Ollama necesito para Inkling 2 Mini?

Ollama 0.40.17 o posterior. Ollama anunció el soporte de Inkling 2 Mini en la 0.40.17 el 20 de noviembre de 2026 como versión preliminar, y la 0.40.17 final llegó en menos de un día. Compruébalo con ollama --version. Las versiones anteriores rechazan la descarga con un error 412. En la 0.40.17, Inkling 2 Mini solo es compatible con Apple silicon.

¿Cuánto ocupa la descarga de Inkling 2 Mini en Ollama?

20.188.097.271 bytes, unos 20,2 GB o 18,8 GiB. Las tres etiquetas, latest, 26b-a5b y 26b-a5b-nvfp4, son el mismo paquete: los pesos NVFP4 y MXFP8 originales de Thinking Machines, con soporte de imágenes. No hay una versión más pequeña en Ollama. A 100 Mbit/s la descarga tarda unos 27 minutos.

¿Por qué Ollama solo da a Inkling 2 Mini un contexto de 4K en mi Mac?

Ollama fija su contexto por defecto según la memoria de la GPU que detecta: 4K por debajo de unos 23 GiB, 32K hasta unos 47 GiB y 256K por encima. En un Mac, esa cifra es el presupuesto de GPU que permite macOS, que en un Mac de 32 GB es de unos 21,3 GiB, así que obtienes 4K. Cámbialo con el control deslizante Context length en los ajustes de Ollama, o subiendo el presupuesto de GPU a 24 GiB.

¿Qué longitud de contexto debo usar para un agente de programación con 32 GB?

16K para Pi, y 32K para OpenCode en un M2 Pro, que es lo máximo que un Mac de 32 GB puede dar cómodamente junto a un modelo de 20 GB. En los chips sin la lectura de prompts que ahorra memoria de Ollama, usa 8K y sesiones cortas. Ollama recomienda 64K o más para agentes de programación, lo que funciona a partir de 48 GB. Configúralo antes de lanzar el agente, porque ollama launch opencode transmite el contexto cargado a OpenCode.

¿Debo subir el límite de memoria de la GPU con iogpu.wired_limit_mb?

En un Mac de 32 GB ayuda. Ejecutar sudo sysctl iogpu.wired_limit_mb=24576 sube el presupuesto de GPU de unos 21,3 GiB a 24 GiB y deja 8 GiB para macOS. Ollama pasa entonces a usar un contexto de 32K por defecto. Cierra y vuelve a abrir Ollama después. El ajuste se restablece al reiniciar el Mac; sudo sysctl iogpu.wired_limit_mb=0 restaura antes el valor por defecto. No es un ajuste oficial de macOS, así que deshazlo si tu Mac empieza a tirar mucho de swap o se vuelve inestable.

¿Cómo cambio el esfuerzo de razonamiento de Inkling 2 Mini en Ollama?

Usa la --think flag: ollama run inkling-2-mini --think=low. Ollama acepta ninguno, minimal, bajo, medio, alto (el valor por defecto), xalto y max, que envía al modelo como valores de esfuerzo de 0 a 0,99. Dentro de un chat, /set nothink establece el nivel más bajo y oculta el pensamiento. Ni siquiera el mínimo desactiva del todo el razonamiento.

¿Qué agente de programación funciona mejor con Inkling 2 Mini en un Mac de 32 GB?

Pi, porque su prompt de sistema y sus herramientas suman menos de 1.000 tokens, lo que mantiene los prompts cortos: ollama launch pi --model inkling-2-mini. Pero Pi ejecuta comandos sin preguntar, así que úsalo solo en una carpeta desechable. OpenCode abre con unos 6.900 tokens y funciona con un contexto de 32K, mejor en un M2 Pro. Pregunta antes de actuar en cuanto añades dos reglas de permisos a su configuración. Claude Code pregunta por defecto, pero su primera petición midió unos 32.800 tokens, más de lo que cabe en un contexto de 32K, así que va mejor a partir de 48 GB.

¿Por qué se cayó Ollama con "memoria insuficiente"?

Lo más probable es que el prompt o la conversación fueran demasiado largos para la memoria de la GPU de tu Mac. Ollama 0.40.17 lee los prompts largos con un método que ahorra memoria solo en el M2 Pro, M2 Ultra, M3 Ultra, M4 Pro y M5 Pro, Max y Ultra. En otros chips, el uso de memoria crece con todo lo que el modelo ha leído, y un M2 Max de 32 GB se cayó tras 12.288 tokens. Cierra otras apps, mantén las sesiones cortas, usa Pi, sube el presupuesto de GPU y mantén Ollama actualizado.

¿Cómo de rápido va Inkling 2 Mini en un Mac de 32 GB?

En la única prueba publicada de Ollama en un Mac de 32 GB, un M2 Max, una petición corta se ejecutó a unos 24 tokens por segundo. En un M4 Pro de 48 GB con Ollama 0.40.17, escribió a unos 32 tokens por segundo y leyó un prompt de 12.000 tokens a 279 tokens por segundo. Los Mac básicos con M4 y M5 tienen mucho menos ancho de banda de memoria y deberían ser más lentos; todavía no se ha publicado ninguna prueba.

¿Puedo ejecutar Inkling 2 Mini con Ollama en un Mac de 16 GB o 24 GB?

No con el paquete de Ollama, que es una única versión de 20 GB, y Thinking Machines admite 32 GB como mínimo. Unsloth publica archivos de 2 y 3 bits de unos 9 a 14 GB que funcionan con su propia compilación de llama.cpp en Macs más pequeños. Pierden algo de calidad y requieren más preparación.

¿Inkling 2 Mini envía mi código o mis prompts a algún sitio?

No cuando se ejecuta en local. Ollama ejecuta el modelo en tu Mac, y sus preguntas frecuentes dicen que no ve tus prompts ni tus datos cuando ejecutas en local. Los agentes de programación lanzados con ollama launch hablan con Ollama en localhost:11434, en tu propia máquina. Los modelos en la nube y la búsqueda web son distintos: envían datos a los servidores de Ollama, y puedes desactivarlos con el ajuste Cloud. Los agentes son programas aparte con sus propias herramientas de red, como la consulta web de OpenCode, así que revisa sus ajustes si necesitas trabajar totalmente sin conexión.

¿Puedo ejecutar Inkling 2 Mini con Ollama en Windows o Linux?

No en Ollama 0.40.17, cuyas notas de la versión dicen que Inkling 2 Mini solo es compatible con Apple silicon en esa versión. En hardware NVIDIA, Thinking Machines admite vLLM y SGLang, y la compilación de llama.cpp de Unsloth ejecuta sus archivos GGUF. Una versión posterior de Ollama podría añadir otras plataformas.

¿Cómo elimino Inkling 2 Mini y libero el espacio?

Correr ollama rm inkling-2-mini. Elimina las copias que hayas creado con ollama create, como inkling-2-mini-32k, de la misma forma: los 20 GB de pesos se liberan en cuanto ningún modelo los usa. Para quitar Ollama en sí, ciérralo, bórralo de Aplicaciones y elimina la carpeta .ollama carpeta de tu carpeta personal; la documentación de macOS de Ollama enumera todos los archivos.

Conclusión

Inkling 2 Mini es un modelo abierto y capaz que su creador admite en un Mac de 32 GB, y Ollama hace que lo básico sea realmente fácil: instalar, descargar y ejecutar. Para chat, documentos y preguntas sobre imágenes, un Mac de 32 GB es todo lo que necesitas.

Los agentes son donde 32 GB se queda corto, por dos razones. Ollama arranca la mayoría de los Mac de 32 GB con una ventana de contexto de 4K, lo que rompe los agentes sin avisar hasta que lo cambias. Y en la mayoría de chips de 32 GB, los prompts largos aún pueden quedarse sin memoria, porque la lectura de prompts de bajo consumo de Ollama solo cubre algunos chips. Así que ajusta el contexto, sube el presupuesto de GPU y cierra el navegador. Empieza con Pi en una carpeta desechable y actualiza Ollama a menudo.

Si tienes un M2 Pro, estás en la mejor posición en la que puede estar un Mac de 32 GB hoy. Si tienes 48 GB o más, la mayoría de las advertencias de aquí desaparecen. Y sea cual sea el Mac que tengas, ollama run inkling-2-mini --verbose te dice más sobre tu propia máquina en cinco minutos que cualquier tabla de esta guía.


¿Ejecutas Inkling 2 Mini en un Mac de 32 GB? Comparte tu chip, la versión de Ollama, el ajuste de contexto y --verbose los números en los comentarios, sobre todo de un M1, M4 o M5. Añadiré los resultados más útiles a la Parte 8, con crédito. Las correcciones también son bienvenidas: con un soporte tan reciente, algunos detalles de hoy cambiarán rápido.

Aviso: Esta guía contiene un enlace de afiliado, al GLM Coding Plan de Z.ai (en la parte 10). Si te suscribes a través de él, obtienes un 10 % de descuento y puede que yo gane una comisión sin coste adicional para ti. Ningún otro producto o empresa de esta guía está patrocinado, y ninguno de ellos la revisó antes de su publicación.

Datos comprobados: 21 de noviembre de 2026.

Añade tu señal.

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

es_ESEspañol