Thinking Machines Lab released Inkling 2 Mini on November 20, 2026, bringing a multimodal, Apache 2.0-licensed model to developers running local AI. The download is about 20GB, with supported hardware including Apple silicon machines with at least 32GB of memory and a single NVIDIA DGX Spark.
Inkling 2 Mini’s unusual feature is a looped transformer: its middle layers run three times for each generated token. Thinking Machines reports strong coding and tool-use results for its size, including 48.2% on DeepSWE v1.1. Those headline comparisons come from the company’s evaluations, with differing setups across models. Thinking Machines’ announcement
The practical appeal is the combination of downloadable weights, local hardware targets and launch-day inference support. The important qualification is that a small checkpoint does not automatically mean low runtime memory, fast generation or safe autonomous operation.
Inkling 2 Mini Specs and What You Can Download
Thinking Machines’ Inkling 2 Mini accepts text and images, generates text, and supports a context window of up to one million tokens. The model card positions it for coding assistants, tool-using agents, retrieval-augmented generation and general conversation.
| Specification | Inkling 2 Mini |
|---|---|
| License | Apache 2.0 |
| Total parameters | 26.4 billion |
| Active parameters | 3.4 billion |
| Effective active parameters per token | 5.4 billion, accounting for repeated computation |
| Architecture | Decoder-only, looped mixture-of-experts transformer |
| Stored decoder layers | 24 |
| Layer applications per token | 48 |
| Context window | Up to 1 million tokens |
| Inputs / output | Text and images / text |
| Distributed checkpoint | About 20GB, mixed NVFP4 and MXFP8 |
The weights are available through Hugging Face. Thinking Machines also offers access through its Tinker platform for inference and customization, while third-party providers offer API access. The local download therefore sits alongside hosted options. Inkling 2 Mini model card
This extends the open-weight direction covered in Zeniteq’s reporting on Inkling 2 Small’s Apache 2.0 release. Mini’s differentiator is its explicitly supported local-computing footprint.
How Inkling 2 Mini’s Looped Transformer Works
Thinking Machines’ Inkling 2 Mini reuses the weights of its middle 12 layers three times, giving it 48 layer applications from 24 stored decoder layers.
The sequence is straightforward:
- Layers 0–5 run once.
- Layers 6–17 run three times with shared weights.
- Layers 18–23 run once.
That produces 6 + (12 × 3) + 6 = 48 layer visits per token. Each layer also uses sparse mixture-of-experts routing, selecting eight experts from a pool of 128. The model stores all those experts, but each token uses only a subset. Model card

The repeated passes are more structured than simply feeding the last layer’s output back into the beginning. Hugging Face explains that each pass through the middle block starts from the output of the first six layers. Learned messages carry information between passes, and gates control how that information changes the current computation. Hugging Face’s architecture breakdown
Three numbers describe different costs:
- 26.4B total parameters describes the stored model.
- 3.4B active parameters describes its sparse activation.
- 5.4B effective active parameters per token accounts for repeated work across loops, not additional unique weights.
My view is that the distinction matters more than the “26B” label. Looping buys additional computation without storing an entirely separate stack of layers, but that computation still takes time.
Thinking Machines also reports that extra passes help reasoning and some long-context tasks without improving knowledge-intensive benchmarks. Reusing weights can refine a calculation; it does not give those weights more facts to store. Thinking Machines’ announcement
Inkling 2 Mini Hardware Requirements and Memory Limits
Thinking Machines’ Inkling 2 Mini officially supports local inference on Apple silicon with 32GB or more memory and on one NVIDIA DGX Spark. Other platforms are possible, with at least 32GB of GPU memory recommended.
| Hardware route | Published support | Documented software options |
|---|---|---|
| Apple silicon MacBook, Mac mini or Mac Studio | 32GB or more memory | Ollama, Exo Labs; Hugging Face also documents MLX |
| NVIDIA DGX Spark | One system supported | NVIDIA inference frameworks listed in the model card |
| Other GPU platforms | Possible; 32GB or more VRAM recommended | Compatibility depends on the framework and dependencies |
| GGUF-based local inference | Quantized versions available | llama.cpp and Unsloth ecosystem |
Most weights use NVFP4, with the final four layers using MXFP8. These are low-precision numerical formats that help reduce the checkpoint’s storage and memory requirements. Model card
Treat 20GB as a checkpoint figure, not a complete memory budget. Inference also needs memory for runtime state, cached attention information and framework overhead. Hugging Face specifically notes that the model’s 48 layer visits retain their own key-value and short-convolution state despite sharing weights.
That makes the advertised one-million-token context window a separate deployment consideration. The supported architectural limit is not a promise that a 32GB Mac can process a full million-token prompt at a useful speed. Neither opened launch document supplies that measurement. Hugging Face’s technical guide
I’d start with a short context, one request at a time and a representative task before increasing prompt length or concurrency. That recommendation follows from the model’s runtime-state requirements, not from a hands-on test.
The company’s offline MacBook demonstration used an M5 Pro machine with 48GB of memory. It illustrates the intended local use case, but it is a vendor demonstration on a machine above the minimum supported memory configuration. Thinking Machines’ announcement
Day-One Tooling and a Documented Loading Example
Thinking Machines’ Inkling 2 Mini launched with support documented by Hugging Face for Transformers, llama.cpp/Llama App, Apple’s MLX and SGLang. The model card additionally lists frameworks including vLLM, NVIDIA Dynamo and Unsloth.
Hugging Face’s Transformers example uses AutoModelForMultimodalLM and AutoProcessor. The following follows its documented loading and text-generation pattern:
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:]))
The processor formats the conversation, the model generates up to 1,024 new tokens, and the final line decodes the generated portion. This is a usage example, not a complete installation recipe: the appropriate framework build, dependencies, device placement and numerical-format support still matter. Hugging Face’s inference guide
Hugging Face also documents a separate variable-loop research checkpoint. Researchers can change its pass count to study the tradeoff between computation and output quality. The standard Inkling 2 Mini checkpoint uses three passes; developers should not assume that reducing its loops is a supported speed setting.
Hugging Face says it tried the research variant but had not evaluated it in depth. That makes variable looping an experimental option, not an established deployment optimization.
Inkling 2 Mini Benchmarks: Claims and Evidence Limits
Frequently Asked Questions
3 questions
1What hardware runs Inkling 2 Mini locally?
Inkling 2 Mini officially supports Apple silicon devices with at least 32GB of memory and a single NVIDIA DGX Spark. Other GPU platforms are possible, with 32GB or more VRAM recommended. Its roughly 20GB checkpoint leaves additional runtime memory requirements, so context length and inference-framework settings still affect whether a workload fits. Model card