Inkling 2 Mini: How a Looped Transformer Squeezes 26B Parameters Into 20GB
The short version: Thinking Machines released the weights for Inkling 2 Mini on November 20, 2026. It has 26.4B total parameters but activates only 3.4B per token, ships as a ~20GB checkpoint, runs locally on a 32GB Mac, and scores 79.2% on SWE-bench Verified. It doesn't invent a new architecture — it takes an old idea, looping layers, and makes it work. The reasoning comes from thinking several times, not from adding more parameters.
What the model actually is
Inkling 2 Mini is an open-weight multimodal model from Thinking Machines Lab (Mira Murati's team): text and image in, text out. Apache 2.0 license, weights on Hugging Face, and it hit #1 on HF trending the day it dropped.
The key numbers, straight from the model card:
| Metric | Value | Source |
|---|---|---|
| Total parameters | 26.4B | HF model card |
| Activated per token | 3.4B | HF model card |
| Expert structure | 128 experts, 8 routed per token | Model card |
| Layers | 24 decoder-only sparse MoE layers | Model card |
| Checkpoint size | ~20GB | Model card |
| Context | Up to 1M tokens | Model card |
| License | Apache 2.0 (+ AUP) | HF model card |
Looped transformers: the same layers, several passes per token
A standard transformer walks each layer once: input goes from layer 1 to layer 24, each layer computes once, done. Inkling 2 Mini loops its middle layers — the same stored layers run multiple passes over each token, with 24 stored layers expanding to 48 layer passes (MarkTechPost's reading).
Why does that save parameters? Reasoning depth gets decoupled from parameter count. The traditional way to reason deeper is to add layers and parameters; looping reuses the same parameters and spends more compute instead. The trade is direct: more compute per token, but a much smaller checkpoint — a 26.4B model that fits in 20GB.
One caveat on the numbers: sources disagree on the exact loop count — some say 12 layers reused three times, others say 24 layers expanding to 48 passes. This post doesn't pick a single number; the mechanism itself (middle layers looping) is the confirmed part.
How 20GB happens: mixed precision + sparse MoE
The size budget has two line items. First, precision: 20 layers in NVFP4 and the last 4 in MXFP8, mixed precision stored natively rather than post-training quantized, so the accuracy loss starts small. Second, MoE: 128 experts, 8 activated per token. 3.4B activated means only a fraction of the model actually computes at inference time, which brings both memory footprint and compute down with it.
| Model | Total params | Activated per token | Context | Local hardware bar |
|---|---|---|---|---|
| Inkling 2 Mini | 26.4B | 3.4B | 1M | 32GB Mac / 1x DGX Spark |
| Qwen3.8-27B | 27B | 27B (dense, fully activated) | 262K (native) | Not disclosed |
| Gemma 4 31B | 31B | 31B (dense, fully activated) | 262K | Not disclosed |
A dense 27B model activates 27B. Inkling 2 Mini activates 3.4B out of 26.4B. That gap is the whole reason it fits in a laptop.
The benchmarks: lab-reported, with the strength in agentic coding
All lab-reported, no independent reproduction yet:
- SWE-bench Verified: 79.2%
- SWE-bench Pro v2 (Hard): 77.9%
- DeepSWE v1.1: 48.2%
- AA Intelligence Index v5.0: 20.1
Against Qwen3.8-27B, the lab claims Inkling 2 Mini leads on multiple agentic coding benchmarks, including DeepSWE, SWE-bench Pro v2 Hard, SWE-bench Multilingual, SWE-bench Verified, and Vibe Code Bench. VentureBeat's summary is blunter: roughly tied with Alibaba's 27B dense flagship on general intelligence benchmarks, but about 4x faster and about 1/6 the cost per task.
Stay calm about that: these are the lab's own comparisons. Whether the looped architecture's edge in long-context retrieval (1M vs 262K) and agentic coding survives independent testing is the thing to watch over the next few weeks.
Running it locally: three ready-made paths
The model card lists three official hardware tiers: 1x NVIDIA DGX Spark, 32GB+ Apple silicon (MacBook / Mac mini / Mac Studio), and other GPUs with 32GB+ VRAM recommended.
The runtime support is already broad: SGLang, vLLM, Ollama, Unsloth, NVIDIA Dynamo, TokenSpeed, Llama App; GGUF quantized builds via llama.cpp/Unsloth; on Apple silicon, MLX runs the original NVFP4/MXFP8 checkpoint directly, no conversion needed.
The shortest path (llama.cpp, 4-bit):
llama serve -hf ggml-org/Inkling-2-Mini-GGUF:IQ4_NL The lab's own demo ran on a 48GB M5 Pro MacBook Pro in airplane mode, offline — building a playable flight simulator in minutes, plus a local small-town simulation with 20 persistent autonomous villagers running at the same time. Running offline is the essential difference from a cloud API model.
Don't want to run it locally? First-party hosted pricing is $0.15/$0.50 per million tokens, and OpenRouter lists it from $0.08/$0.35.
Five honest limitations, stated before you try it
- Local runtime support for looped models is new. The model card's own words: "Support for looped models in local runtimes is new, and speed varies by runtime and hardware." The same machine can run very differently across frameworks.
- The benchmarks are lab-reported. The 79.2% figures have no independent reproduction yet. Treat them as "worth trying," not "already won."
- 1M context is a weights ceiling, not every entry point. Tinker hosting caps at 256K; you only get a shot at 1M running locally.
- There are two parameter numbers. The model card says 3.4B activated per token; the Tinker directory says 5.4B effective. Different counting conventions — this post uses the model card's 3.4B.
- Sources disagree on the loop count. This post states no single multiplier, only the looping mechanism.
The takeaway
Looped transformers aren't a new idea. What's new is someone shipping one as a 20GB, Apache 2.0 model that runs on a 32GB Mac and holds its own on coding benchmarks. The bar for local models in the agent era has moved: it used to be "can it run," now it's "can it do the work." Inkling 2 Mini is an answer to the second question.
Are you going to run it locally? If you do, drop your machine specs and actual speeds in the comments — I'll pull together a real-world comparison from what comes in.