Un modelo de 26,4 mil millones de parámetros que cabe en una laptop suena como un truco, y en cierto sentido lo es. Inkling 2 Mini almacena 26,4 mil millones de parámetros, pero su diseño disperso activa solo una parte de ellos por cada token, y sus capas medias se ejecutan tres veces para sumar profundidad de razonamiento sin sumar pesos almacenados. Thinking Machines dice que el checkpoint completo ocupa unos 20 GB. La ruta GGUF lo reduce aún más, y corre por llama.cpp, el motor de inferencia local sobre el que se construyen la mayoría de las herramientas de pesos abiertos.
Este tutorial usa los archivos GGUF publicados por la ggml org, el equipo detrás del propio llama.cpp. Esa elección importa. El soporte para modelos con bucle en los motores locales es nuevo, la tarjeta del modelo lo dice con claridad, y el lugar más seguro para obtener un build de una arquitectura nueva es con la gente que mantiene el motor.
Qué vas a construir o aprender
Terminarás con Inkling 2 Mini corriendo en tu propia máquina de dos formas. Primero, un servidor local con una API compatible con OpenAI y una página de chat en el navegador, listo para que lo llamen tus propias herramientas. Segundo, el conocimiento de qué archivo GGUF necesitas en realidad, porque elegir el equivocado es la forma más rápida de quedarte sin memoria en una máquina que debería haber alcanzado.
Inkling 2 Mini acepta texto e imágenes como entrada y produce texto. Tiene 24 capas, 128 expertos con 8 activos por token, y una ventana de contexto de hasta 1 millón de tokens en el papel. Ese último número es un límite del modelo, no una promesa local. En una laptop fijarás un contexto mucho menor, y el Paso 3 explica por qué esa es la decisión correcta.

Antes de empezar
Dos advertencias van al frente, antes de que empiece cualquier descarga.
La tarjeta del modelo también trae un límite franco que vale la pena conocer antes de hacer planes con este modelo. Thinking Machines dice que Inkling 2 Mini puede caer en bucles largos de razonamiento, sobre todo cuando depura código, y recomienda límites en los tokens de salida y en los turnos del agente. También dice que el modelo puede tomar acciones destructivas en montajes de agente sin confirmación. Hazlo correr primero como asistente de chat y de código. Dale herramientas y acceso a archivos después, en un entorno aislado, con la confirmación activada. Nuestro tutorial sobre darle herramientas reales a un modelo local con Ollama y MCP cubre ese trabajo de correa en detalle.
Paso 1: Instala llama.cpp
Acción: instala llama.cpp con el instalador oficial para tu sistema. En macOS y Linux, ejecuta esto en una terminal.
curl -LsSf https://llama.app/install.sh | sh
En Windows, ejecuta esto en PowerShell, o instala el paquete con winget install llama.cpp.
irm https://llama.app/install.ps1 | iex
Quien use Homebrew en macOS o Linux puede usar brew install llama.cpp en su lugar. Todas estas rutas instalan el mismo proyecto. Lo que importa es que el build sea actual, porque el soporte de la arquitectura Inkling 2 es reciente.
Resultado esperado: el instalador termina y el comando llama responde. Verifícalo antes de descargar 17 GB de modelo.
llama --help
El texto de ayuda nombra los subcomandos, entre ellos llama cli para el chat en terminal y llama serve para el servidor. Si la shell dice que falta el comando, abre una ventana de terminal nueva para que se cargue la ruta actualizada, y ejecuta la verificación otra vez.
Paso 2: Elige tu archivo GGUF
Acción: elige una fila de la tabla GGUF oficial antes de ejecutar nada. La ggml org publica tres tamaños para este modelo.
| Archivo | Tamaño en disco | Qué dice el editor |
|---|---|---|
| IQ4_NL | 17.6 GB | Calibrado con una matriz de importancia; expertos de 4 bits en las capas 0 a 19, todo lo demás en Q8_0 |
| Q8_0 | 27.8 GB | Casi sin pérdida; todas las matrices de pesos en Q8_0 |
| BF16 | 52.2 GB | Precisión de 16 bits; los expertos originales convertidos a BF16 |
El editor midió ambos archivos pequeños contra BF16 en el mismo texto de prueba. Q8_0 eligió el mismo token principal el 97,6 por ciento de las veces. IQ4_NL lo eligió el 95,5 por ciento de las veces. Esa brecha es real pero modesta, y la brecha de disco es de 10 GB.
Resultado esperado: una elección clara. Elige IQ4_NL si tu máquina está cerca del objetivo de 32 GB de memoria, que es el caso de la mayoría de las laptops que califican. Elige Q8_0 si tienes memoria de sobra y quieres la coincidencia más cercana. Salta BF16 para uso local; existe como referencia, no como archivo de laptop. Recuerda que el uso de memoria es el tamaño del archivo más la caché de contexto más los búferes de trabajo, así que un archivo de 27,8 GB en una máquina de 32 GB deja muy poco espacio para respirar.
Paso 3: Sirve el modelo
Acción: inicia el servidor con el archivo que elegiste. Este comando usa IQ4_NL. Cambia el sufijo a Q8_0 si elegiste el archivo más grande.
llama serve -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NL --port 8080
La bandera -hf le dice a llama.cpp que descargue el modelo desde Hugging Face y lo guarde en caché en tu máquina, así que el primer inicio incluye la descarga completa. La bandera --port 8080 fija la dirección a propósito. Los builds recientes de llama.cpp han cambiado su puerto por defecto, y fijarlo tú mismo hace que tus herramientas y este tutorial coincidan en dónde vive el servidor.
Mantén el contexto modesto al principio. El modelo soporta hasta 1 millón de tokens, pero cada token de contexto cuesta memoria en tu máquina, y las capas con bucle ya gastan cómputo extra por token. Si quieres un tamaño fijo desde el inicio, suma -c 8192 al comando y súbelo después solo si tu trabajo lo necesita y tu memoria lo permite.
Resultado esperado: tras la descarga y la carga, la terminal anuncia el servidor escuchando en 127.0.0.1 en el puerto 8080. Deja esa terminal abierta. Cerrarla detiene el servidor.
Paso 4: Chatea en la terminal en su lugar
Acción: si solo quieres hablar con el modelo, salta el servidor y usa el comando de chat en una terminal nueva. Descarga el mismo archivo en caché.
llama cli -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NL
Resultado esperado: se abre una invitación de chat una vez que el modelo carga. Pídele algo que puedas verificar, como explicar un trozo corto de tu propio código o resumir un párrafo que pegues. Un buen resumen de un texto que tú diste es una mejor primera prueba que una pregunta de trivia, porque este modelo es más débil en recuerdo factual que su hermano mayor, según su propia tarjeta. Escribe el comando de salida que muestra la ayuda del chat cuando termines.
Paso 5: Suma la entrada de imagen solo si la necesitas
Acción: salta este paso para el trabajo de texto. Para la entrada de imagen, el repo GGUF también publica un archivo codificador de visión, llamado mmproj, de 642 MB en BF16 o 346 MB en Q8_0. Descarga el archivo mmproj del mismo repo y pásalo cuando inicies el servidor.
llama serve -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NL --port 8080 --mmproj /path/to/mmproj-file.gguf
Reemplaza la ruta de ejemplo por la ruta real del archivo que descargaste. La tarjeta del modelo dice que cada dimensión de imagen debería estar entre 40 y 4096 píxeles para mejores resultados.
Resultado esperado: el servidor inicia con el archivo de visión cargado junto al modelo, y la página de chat del navegador acepta entrada de imagen. Si el servidor falla en este paso y nombra el archivo mmproj, la ruta está mal o la descarga está incompleta. El chat de texto sigue funcionando sin este archivo, así que quita la bandera y confirma primero el montaje base.
Paso 6: Fija un límite de razonamiento
Acción: evita que el modelo piense en círculos. Las notas GGUF dicen que la profundidad de razonamiento se fija con reasoning_effort, con valores none, minimal, low, medium, high, xhigh y max, más números de 0.0 a 0.99. High es el valor por defecto. Para preguntas locales rápidas, fija un valor más bajo en tu solicitud de cliente, y limita el largo de la salida cuando tu cliente lo permita.
Resultado esperado: respuestas más cortas y rápidas en tareas simples, con menos riesgo de los bucles largos de razonamiento de los que advierte la tarjeta del modelo. Sube el ajuste para trabajo de código difícil, donde las pasadas extra ganan su tiempo. Este modelo marcó 48,2 por ciento en DeepSWE v1.1 en las pruebas de laboratorio publicadas en su tarjeta, por delante de cada modelo de pesos abiertos bajo 100 mil millones de parámetros en esa tabla, así que el razonamiento vale la pena en el trabajo que lo necesita y vale recortarlo en el que no.
Verificación
No confíes solo en el aviso de la terminal. Verifica el servidor desde una segunda terminal mientras corre.
curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/v1/models
La llamada de salud debería anunciar el servidor como listo, y la llamada de modelos debería nombrar el GGUF de Inkling 2 Mini que iniciaste. Luego abre http://127.0.0.1:8080/ en tu navegador y envía un mensaje en la página de chat integrada. Una respuesta ahí prueba el bucle completo: descarga, carga, servidor y generación, todo en tu máquina.
Para una verificación de API, envía una solicitud de chat con curl. Usa el nombre del modelo exactamente como lo devolvió el endpoint de modelos.
curl http://127.0.0.1:8080/v1/chat/completions -H "Content-Type: application/json" -d '{"model": "MODEL_NAME_FROM_MODELS_ENDPOINT", "messages": [{"role": "user", "content": "Name three primary colours."}]}'
Una respuesta JSON con tu respuesta dentro significa que tus propias herramientas ya pueden llamar este endpoint igual que llamarían una API alojada, sin cuenta y sin factura por token. Ese es todo el sentido del montaje, el mismo patrón local primero que usamos en la instalación de Hermes Agent.
Solución de problemas
| Problema | Causa probable | Solución |
|---|---|---|
| Arquitectura desconocida o el modelo se niega a cargar | El build de llama.cpp es anterior al soporte de Inkling 2 | Actualiza llama.cpp con el instalador del Paso 1 y ejecuta el mismo comando serve otra vez |
| Sin memoria durante la carga | Q8_0 más la caché de contexto deja muy poco espacio en una máquina de 32 GB | Cambia el sufijo a IQ4_NL y suma -c 8192 para mantener el contexto pequeño |
| La descarga se reinicia o se traba | La conexión cayó durante una descarga de 17 GB o más | Ejecuta el mismo comando otra vez; llama.cpp retoma desde su caché cuando puede, y una cuenta gratuita de Hugging Face puede hacer más estables las descargas grandes |
| La página del navegador no abre | El servidor está en otro puerto, o la terminal serve se cerró | Revisa la dirección de escucha en la terminal serve, mantenla abierta y confirma que usaste --port 8080 |
| Las respuestas divagan o entran en bucle en preguntas simples | El esfuerzo de razonamiento está en el valor alto por defecto para una tarea que no lo necesita | Baja reasoning_effort como en el Paso 6 y limita el largo de la salida en tu cliente |
| Falta la entrada de imagen en la página de chat | El servidor inició sin el archivo de visión | Reinicia con la bandera --mmproj y una ruta correcta, como en el Paso 5 |
| El servidor responde lento | El contexto está fijado muy por encima de lo que el trabajo necesita, en un modelo con bucle que gasta cómputo extra por token | Baja el contexto con -c, cierra otras apps pesadas y mantén expectativas acordes al hardware de laptop |
Próximos pasos
Una vez que el servidor responde, apunta una herramienta que ya uses hacia el endpoint local. La mayoría de los clientes compatibles con OpenAI aceptan una dirección base a medida, y http://127.0.0.1:8080/v1 es la dirección para darles. Empieza con trabajo de bajo riesgo, como resúmenes y primeros borradores de código, y mantén un modelo alojado cerca para preguntas factuales, donde este modelo es más débil.
Desde ahí, la comparación honesta vale la pena. Ejecuta las mismas tres indicaciones por IQ4_NL y, si tu memoria lo permite, por Q8_0, y mira si el archivo más grande cambia respuestas que te importan. Los números del editor dicen que la brecha es pequeña. Tu propio trabajo es la prueba que cuenta, y ahora no te cuesta más que tiempo y electricidad correrla. Para contexto sobre cómo este motor llegó a su forma actual, mira nuestro reportaje sobre llama.cpp llegando a 1.0.
Comandos, tamaños de archivo y datos del modelo verificados contra el repo GGUF de la ggml org, la tarjeta oficial del modelo Inkling 2 Mini y la nota de lanzamiento de Thinking Machines, el 21 de noviembre de 2026. Este procedimiento se verificó contra esos documentos y no se ejecutó de punta a punta en hardware local para este artículo.
Sources
- ggml org, repo Inkling 2 Mini GGUF en Hugging Face. El comando serve, los tamaños IQ4_NL, Q8_0 y BF16, los archivos de visión mmproj, las cifras de coincidencia de tokens y el ajuste de esfuerzo de razonamiento.
- Thinking Machines Lab, tarjeta del modelo Inkling 2 Mini en Hugging Face. Objetivos de hardware, arquitectura, límite de contexto, fecha de lanzamiento, licencia Apache 2.0, límites y notas de seguridad.
- Thinking Machines Lab, Introducing Inkling 2 Mini, 20 de noviembre de 2026. Diseño con bucle, afirmaciones de benchmarks y la historia del vuelo en laptop, todo presentado como afirmaciones del laboratorio.
- Proyecto llama.cpp, llama.app. Comandos de instalación para macOS, Linux y Windows, y los comandos unificados llama cli y llama serve.
- Crédito de imagen: la imagen del cuerpo es la imagen de encabezado de la tarjeta oficial del modelo Inkling 2 Mini en Hugging Face, de Thinking Machines Lab. La imagen principal es una ilustración de estilo casa de Dirty Static.
FIN DE LA TRANSMISIÓN
Mantén la curiosidad. Cuestiónalo todo.


