# Run Inkling 2 Mini on a 32GB Mac today: official setup, scores, and caveats

> Source: <https://dev.to/kargatharaaakash/run-inkling-2-mini-on-a-32gb-mac-today-official-setup-scores-and-caveats-1dlj>
> Published: 2026-11-22 18:36:37+00:00

**Key takeaway:** Inkling 2 Mini is a 26.4B-total, 3.4B-active looped MoE with a 20GB checkpoint that runs on 32GB Apple silicon via 'ollama run inkling-2-mini', but its middle 12 layers loop three times, so per-token compute exceeds what the active-parameter count implies and minimum reasoning effort does not fully

This post was written with AI assistance and checked against official sources from Thinking Machines Lab, the model card, and Hugging Face. I have not independently rerun the benchmarks.

Thinking Machines Lab released [Inkling 2 Mini](https://thinkingmachines.ai/news/inkling-2-mini/) on November 20, 2026: an Apache 2.0, open-weights model that officially runs on a 32GB Mac. If you want to try it before reading the rest, the supported Ollama command is:

```
ollama run inkling-2-mini
```

The rest of this post is the official spec, the official scores, and the official caveats I would read before pointing it at a real repository.

All of the figures below come from the [launch post](https://thinkingmachines.ai/news/inkling-2-mini/), the [model card](https://thinkingmachines.ai/model-card/inkling-2-mini/), or the [Hugging Face model page](https://huggingface.co/thinkingmachines/Inkling-2-Mini).

| Item | Official figure | 
|---|---|
| Release | November 20, 2026, Thinking Machines Lab | 
| License | Apache 2.0 | 
| Architecture | 24-layer decoder-only MoE, with the middle 12 layers run three times | 
| Parameters | 26.4B total, 3.4B active, 5.4B effective active per token | 
| Context | Up to 1M tokens | 
| Inputs / outputs | Text and image in, text out | 
| Checkpoint size | About 20GB, NVFP4 plus MXFP8 on the last four layers | 
| Local hardware (supported) | Apple silicon with 32GB+ memory via Ollama; NVIDIA DGX Spark; 32GB+ VRAM recommended for other GPUs | 
| DeepSWE v1.1 | 48.2% (mini-swe-agent v2.4.6) | 
| SWE-bench Pro v2 Hard | 77.9% (mini-swe-agent v2.4.6; launch chart says 51 tasks) | 
| SWE-Bench Verified | 79.2% (bash only) | 
| Vals Index v2.2 | 46.5% | 
| AA Index v5.0 | 20.1 | 
| Weights | [thinkingmachines/Inkling-2-Mini](https://huggingface.co/thinkingmachines/Inkling-2-Mini) | 
| Hosted try path | [Tinker Playground](https://tinker.thinkingmachines.ai/playground) | 

The launch post says Inkling 2 Mini "leads every open-weights model with less than 100B total parameters" on DeepSWE v1.1 and Vals Index v2.2.

I have not run this checkpoint myself for this post. These are the official paths.

**On a Mac with 32GB or more RAM**, Ollama is the supported local runtime:

```
ollama run inkling-2-mini
```

A basic HTTP check, from the [Ollama model page](https://ollama.com/library/inkling-2-mini):

```
curl http://localhost:11434/api/chat \
  -d '{
    "model": "inkling-2-mini",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

Python:

``` python
from ollama import chat

response = chat(
    model="inkling-2-mini",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(response.message.content)
```

The model card also lists SGLang, vLLM, Unsloth, NVIDIA Dynamo, TokenSpeed, llama.cpp (for GGUF quantizations), and Llama App. For fine-tuning, the lab points to Tinker, and to Miles, SkyRL, and NVIDIA NeMo AutoModel.

If you do not want to download 20GB first, start in the [Tinker Playground](https://tinker.thinkingmachines.ai/playground). The variable-loop research variant is separate, at [thinkingmachines/TML-d24-varloop-research](https://huggingface.co/thinkingmachines/TML-d24-varloop-research).

Inkling 2 Mini is not a shrunk copy of a dense 27B model. It is a looped transformer. Layers 0–5 run once, layers 6–17 run three times with shared weights, and layers 18–23 run once. That is 48 layer applications per token from 24 stored layers. Each layer routes a token to 8 of 128 experts.

The useful consequence, if the lab is right, is more reasoning compute per token and fewer written chain-of-thought tokens. The cost is that compute per token is higher than the 3.4B active-parameter number suggests. The model card is explicit: setting reasoning effort to its minimum does not fully disable reasoning, because the middle layers still loop.

Thinking Machines also studied monitorability — whether you can still oversee the model by reading its chain of thought, even though more work happens inside the network. In the announcement, a variable-loop research model improved its no-CoT time horizon from 16 seconds at one pass to 37 seconds with three, and a serial-reasoning benchmark kept improving out to ten loops. The lab says the chain of thought got shorter but stayed legible, and that sabotage tests did not trend upward as loops were added. That is their result at this scale. They also say it may not hold for larger models.

On the lab's published table, Qwen3.8-27B is the closest repeated baseline. A few rows:

| Benchmark | Inkling 2 Mini | Qwen3.8-27B | Source notes | 
|---|---|---|---|
| DeepSWE v1.1 | 48.2% | 42.2% | mini-swe-agent v2.4.6 | 
| SWE-bench Pro v2 Hard | 77.9% | 73.8% | mini-swe-agent v2.4.6 | 
| SWE-Bench Verified | 79.2% | 77.8% | bash only | 
| Terminal Bench v2.1 | 71.6% | 73.0% | Inkling 2 Mini in pi v0.83.0 | 
| AA Index v5.0 | 20.1 | 20.1 | tie | 
| MCP Atlas Public | 82.7% | 77.3% |  | 
| AutomationBench-AA v1.0.6 | 41.8% | 48.2% | Qwen ahead | 
| ComplexConstraints v1.1 | 33.4% | 30.1% | openhands v1.45.0 in the table; the launch post still describes Inkling as behind Qwen on this and on MultiChallenge | 

The launch post's own summary is the one I would keep in your head: ahead on the agentic coding benches they highlight, behind Qwen3.8-27B on some others. The same post says "evaluation setups vary by model." If a third-party harness later prints a different number, that is expected, not a scandal.

*Image credit: Official PlaneBench flight-simulator demo still, showing Inkling 2 Mini running offline on a MacBook Pro. Source: Thinking Machines Lab, [Introducing Inkling 2 Mini](https://thinkingmachines.ai/news/inkling-2-mini/).*

The official demos are worth watching, and they are still demos. In the launch post, researchers ran the model offline on a MacBook Pro (M5 Pro, 48GB) in airplane mode and built a playable flight simulator in a few minutes. A second clip, Thinkyville, is "a tiny pixel town built by Inkling 2 Mini, where the same model powers all 20 villagers on one offline MacBook."

*Image credit: Official Thinkyville demo still, a pixel town built by Inkling 2 Mini, with the same model powering 20 villagers on one offline MacBook. Source: Thinking Machines Lab, [Introducing Inkling 2 Mini](https://thinkingmachines.ai/news/inkling-2-mini/).*

Before you aim this at a working tree, read the model card's limitations:

The official X announcement from [@thinkymachines](https://x.com/thinkymachines/status/2123871643797995872) puts the pitch in one sentence: a looped transformer with 26B parameters, "small enough to run on your laptop, powerful enough for agentic work," with a score of 20.1 on the AA Index.

If you have a 32GB Mac or a single 32GB GPU, what is the first *local* task you would actually trust to Inkling 2 Mini — and what would you still leave to a hosted model?
