Inkling 2 Mini: Can Your Laptop Run It?
Check Inkling 2 Mini’s memory requirements for your Mac or GPU, see how its looped layers work, and start with Hugging Face, Ollama, llama.cpp or Tinker.
Published

Inkling 2 Mini is a small open-weights model that Thinking Machines Lab released on November 20, 2026 to run on laptops. If you have an Apple silicon MacBook with 32 GB of memory or more, the lab supports running it locally with Ollama. The download is about 20 GB.
What Inkling 2 Mini can do
Give Mini text, an image, or both, and it generates text. That text can be code. For example, you could give it a screenshot of a settings form and ask for HTML that preserves the field labels and their order. You can then open the HTML in a browser and compare it with the screenshot.
Thinking Machines Lab showed what that looks like on a larger task. On a flight, its researchers ran Mini offline on an M5 Pro MacBook Pro with 48 GB of memory and had it build a playable flight simulator. The lab’s recording shows the game running. For a developer, the interesting detail is that the model generating the code was aboard the plane too.
What “looped” means
The lab describes Mini as “running the middle layers of the model three times for every token.” A token is a small unit of text, sometimes just part of a word. Each time Mini produces one, it works through the first six layers, takes three laps through the same middle twelve, then goes through the last six.

That adds up to 48 layer applications from 24 stored layers. Like a cyclist covering more distance by riding another lap, the model does more computation using weights it already has in memory. The extra laps still take work. You can’t estimate how fast Mini will answer on your laptop from the active parameter count alone.
Which machines can run Mini?
On a Mac, open About This Mac and check Chip and Memory. Look for an Apple silicon chip and at least 32 GB of unified memory, the pool shared by the CPU and GPU. On a laptop with a separate graphics card, look up the card’s own video memory (VRAM). A laptop advertised with 32 GB of system RAM can have much less memory on its GPU.
The lab’s model card, checked November 22, 2026, lists one native checkpoint of about 20 GB, stored in mixed NVFP4 and MXFP8 precision. A checkpoint is the saved set of learned weights. Loading it also takes working memory for the software and the conversation. Mini supports up to a million tokens of context, but the amount you can use locally depends on the runtime and the memory left after loading the weights.

The three parameter figures on the card describe that same checkpoint. 26.4 billion is the total number of learned values. Mini selects a subset of its specialist networks for each token, activating 3.4 billion distinct parameters. Counting the reused weights again on each lap gives 5.4 billion effective activations per token. There’s no separate 3.4-billion-parameter Mini to download.
Licence. The model card lists Apache 2.0 and links the lab’s acceptable use policy. Developers can download the weights for research, fine-tuning or integration into an application.
Cost. Running the open weights on your own hardware carries no per-token fee from the lab. Hosted sampling is metered under Tinker’s published rates.
How to start with Inkling 2 Mini
Choose Ollama for a first local prompt on a supported Mac. Choose Hugging Face if you want to call the model from Python, GGUF if you already use llama.cpp, or Tinker to try Mini before downloading the weights.
Hugging Face for a Python application
- Open the lab’s Hugging Face repository. Use the identifier
thinkingmachines/Inkling-2-Minifor the fixed-loop release. - In a Python environment with PyTorch and a version of Transformers that supports Inkling, run the fixed-loop example below. The processor formats the prompt, and the model loader fetches the weights.
- Read the decoded answer, then replace the sky question with a prompt from your own application. The Hugging Face integration guide also shows how to pass an image.
import torch
from transformers import AutoModelForMultimodalLM, AutoProcessor
model_id = "thinkingmachines/Inkling-2-Mini"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(
model_id,
)
messages = [{"role": "user", "content": [{"type": "text", "text": "Why is the sky blue?"}]}]
inputs = processor.apply_chat_template(
messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt",
).to(model.device)
input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=1024)
print(processor.decode(outputs[0][input_len:], skip_special_tokens=False))Ollama for a first local prompt
- Follow Ollama’s macOS installation guide. Open the disk image, drag Ollama into Applications and launch it. Allow it to set up the terminal command if prompted.
- Open Terminal and run the command from Ollama’s Mini listing. Let the initial download finish.
ollama run inkling-2-mini- At the prompt, paste a short function and ask Mini to explain its return value for a particular input. Check the answer by calling the function yourself.
If you prefer a desktop interface, compare Ollama and LM Studio. For other ways to serve a model to an application, see the Ollama alternatives guide.
GGUF with llama.cpp for a local server
- Install the current llama.cpp tooling that provides the
llamacommand. GGUF is the model file format this runtime reads. The GGUF release card lists the available conversions and the separate vision encoder. - Start the local server with the maintainers’ command. The suffix selects the IQ4_NL quantization, a compact representation of the weights.
llama serve -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NL- Wait for the model to load, then use the local address printed by the server to send a prompt. If you need to choose between running this server yourself and letting Ollama manage the model, see Ollama vs. llama.cpp.
Tinker for hosted access
- Open the Tinker Playground. The public entry page asks you to sign in with email or Google. With access, choose Inkling 2 Mini and send a prompt. The playground runs inference, so you can try the model on a machine that cannot hold its weights.
- For API access or fine-tuning, follow the Tinker Cookbook setup. Once your account has access, create a key in the Tinker console and export it in your environment as
TINKER_API_KEY. - In a Python environment with
uvinstalled, use the cookbook’s stable install command. It includes the SDK and the Inkling renderer that formats messages for the model.
uv pip install tinker-cookbookUse thinkingmachines/Inkling-2-Mini wherever the cookbook example asks for model_name. You can stop after the playground step if all you want is a conversation.
Who should use Mini?
Mini suits a developer who wants offline coding help and has a way to check the result. Give it a failing test and the function it exercises, ask for a small change, then run the test and inspect the diff. For that kind of work, other local coding models are worth comparing on the same task.
For an agent that can edit files, the lab reports that Mini sometimes rechecks its work repeatedly while debugging and can overwrite files without asking. Give it a disposable working copy, cap its turns and require approval for destructive edits. If your work depends mainly on accurate factual recall, choose a stronger model and check its answers against source material.
Is it a chat app? How does it differ from Inkling 2 Small?
Inkling 2 Mini is the model behind an interface. Downloading the weights gives you the learned parameters. Ollama or another runtime loads them, and a chat interface collects your message and displays the reply. For a ready-made chat, use the playground.
Inkling 2 Small is a separate, much larger model. The lab gives Small 594 billion total parameters and 17 billion active. Its Mini card reports that Small performs better on most of its evaluations, with the largest gaps on factual and knowledge-heavy questions. If someone recommends “Small,” check the full name before applying Mini’s laptop guidance.
Where to go next
If keeping the work on your machine matters most, use the local model guide to find a model that fits the memory you already own. If you specifically need Mini and your machine is too small, try your task in Tinker first. For control over the runtime, the GPU cloud provider comparison covers rented GPUs including Runpod. Check the VRAM on the particular GPU before renting it.
- Published
- Category
- AI











