Most small models get better the boring way: more parameters, more data, more tokens of reasoning. Inkling 2 Mini tries something else. It runs the same middle layers three times for every token it produces.
Thinking Machines Lab released Inkling 2 Mini on November 20. It is an open-weights Mixture-of-Experts model with 26.4B total parameters and 3.4B active per token. Its memory footprint is about 20GB, and the launch post shows it running offline on a MacBook Pro. A day later, EXO Labs posted local speed numbers from their work with the lab on Apple hardware.
I have not run the model myself. This breakdown is built from the Thinking Machines launch post and the EXO Labs post. All benchmark numbers below are reported by those two sources, not independently checked. The goal is to understand the one idea that makes this release different, looping, and to read the numbers with the right amount of caution.
What "looping" means
A normal transformer is a fixed stack. A token goes through layer 1, then layer 2, and so on to the last layer, once. The depth of the stack limits how many steps of computation the model can do before it has to write the next token.
A looped transformer reuses some of its layers. Instead of adding more layers (which means more weights and more memory), it sends the token's internal state through the same layers again. You get more computation per token without storing more parameters.
The idea is not new. The launch post credits earlier work such as Universal Transformers (Dehghani et al., 2018). What is new is a lab shipping a competitive, open-weights looped model that people can actually download and study.
How Inkling 2 Mini is wired
The model has 24 layers, split into four blocks of six:
- Block 1 (the "prelude") runs once. It turns token embeddings into the model's internal representation.
- Blocks 2 and 3 run three times. They share weights across all three passes.
- Block 4 runs once. It turns the internal state back into a next-token prediction.
That gives 6 + (12 x 3) + 6 = 48 layer applications per token from 24 stored layers. This is why the lab gives two "active" numbers: 3.4B active parameters, but 5.4B weight activations per token once you count the repeated reads.
Why loop the middle and not the end? The lab's intuition is that middle layers do the more abstract reasoning, while the first and last layers mostly translate between embeddings and internal representations. They tested it. Looping the middle 12 layers beat looping the last 12 on 27 of 28 evaluations. At training step 2,000, a no-loop baseline was estimated to need 1.51 to 1.91 times the compute to match the middle-loop model's loss, compared with 1.24 to 1.36 times for the last-loop version.
Two details make the loops work in practice:
- Attention residuals. Instead of adding every layer's output into one running sum, each layer learns its own mix of earlier blocks' outputs (an approach from the 2026 "Attention Residuals" paper by the Kimi Team). Every pass reads the prelude's output. Passes 2 and 3 also read the previous pass's output, which the lab calls the "message".
- A learned gate on the message. At the start of training the gate blocks the message completely, so each loop behaves like a normal non-looped model. The gate opens gradually. This lets looping be introduced without destabilizing training.
The cost and benefit, according to the lab's scaling comparison: the non-looped model was 7.5% cheaper to train, but needed 140% more inference compute to match the looped model's loss on 512k-token agentic traces.
How they made it small enough for a laptop
Looping is only half the story. Three other choices get the model down to about 20GB.
Native 4-bit weights. Most of the weights were trained in NVFP4, a 4-bit floating point format, on every forward pass from pretraining through reinforcement learning (RL). The last four layers use 8-bit MXFP8. The released weights use the same precision the model was trained in, so there is no extra loss from converting a 16-bit model down to 4-bit after the fact. That is a real difference from the usual "download the big model, then quantize it" workflow.
Expert pruning. The model started with 384 experts per layer and picked 8 per token. Midway through training, the lab deleted two-thirds of them, keeping the 128 most-used experts in each layer.
Healing. After pruning, the model trained on 1T tokens distilled from a larger internal Inkling model, so the surviving experts could take over the work of the deleted ones. Then came supervised fine-tuning and an RL phase of 2.2T tokens over 2,000 steps.
What the benchmarks show
The lab compares Inkling 2 Mini with open-weights models under 100B total parameters: Gemma 4 31B, Muse Glimmer, Qwen3.8-27B and Nemotron 3.5 Super VL. Some reported scores:
- DeepSWE v1.1: 48.2%, against 42.2% for Qwen3.8-27B.
- SWE-bench Verified (bash only): 79.2%, against 77.8% for Qwen3.8-27B.
- SWE-bench Pro v2 (Hard): 77.9%, against 73.8% for Qwen3.8-27B.
- Vals Index v2.2: 46.5%.
- BrowseComp (with compaction): 79.0%, essentially tied with Nemotron 3.5 Super VL at 78.9%.
- MCP Atlas: 82.7%, against 77.3% for Qwen3.8-27B.
The pattern is clear. The model is strongest on long, multi-step agentic work: coding agents, search and tool use. On several other rows it sits just behind Qwen3.8-27B, for example Terminal Bench v2.1 (71.6% vs 73.0%) and GDPVal-AA v2.1.
There is an important footnote in the launch post: "Evaluation setups vary by model." Different harnesses, agent scaffolds and settings can move these numbers a lot. Treat a gap of one or two points as a tie until independent runs confirm it.
What looping does not fix
This is the most useful part of the release for anyone choosing a model.
Looping gives the model more computation per token. It does not give it more memory for facts. Knowledge is mostly a function of total parameter count, and the lab says so directly. Using the variable-loop research model, they found that more passes helped long-context and multi-hop tasks (GraphWalks BFS, MRCR v2), but did not help knowledge-heavy benchmarks such as AA-Omniscience, SimpleQA Verified and WorldVQA.
The lab's answer is tools. A small model that knows fewer facts can still do well if it searches efficiently, and that matches the strong BrowseComp and DeepSearchQA scores.
The launch post also lists clear limitations:
- It is not the best small model for multi-turn chat. It scores 50.0% on MultiChallenge, behind Qwen3.8-27B.
- It is weaker at following many constraints at once: 33.4% on ComplexConstraints v1.1, also behind Qwen3.8-27B.
- It trails larger models on hard reasoning benchmarks such as CritPt v2 and HLE-Diamond.
So the practical reading is: a strong pick for agent loops that call tools, a weaker pick as a pure chat assistant or a closed-book fact source.
How fast it runs on a Mac
The lab's own speed chart uses a theoretical ceiling (614 GB/s memory bandwidth, BF16 weights, batch size one), so it is not a real measurement. The EXO Labs post gives measured local numbers:
- 96GB M5 Ultra Mac Studio: 210 tokens/sec decode, 3,620 tokens/sec prefill.
- 48GB M5 Max MacBook Pro: 125 tokens/sec decode, 1,750 tokens/sec prefill.
EXO also says the model built a native weather app 1.8 times faster than Claude Sonnet 5.5 and 11 times cheaper at API pricing, on the M5 Ultra. That is one task, and the post does not describe the setup in detail, so read it as a demo, not a benchmark.
Their explanation of why looping suits Macs is the key point. Apple machines are usually limited by memory size and bandwidth, not raw compute. Looping adds compute per token without adding weights, so it spends the resource a Mac has spare and saves the one it lacks.
There is a separate efficiency data point from Stanford's Hazy Research and Scaling Intelligence labs, which had early access. On an NVIDIA DGX Spark, they measured "intelligence per joule" at 0.703 for Inkling 2 Mini, against 0.430 for Qwen3.6-35B-A3B and 0.159 for Gemma-4-26B-A4B. Note that the models ran at different precisions in that test (MXFP8 for Inkling, NVFP4 or INT4 for the others).
The safety question: can you still read its reasoning?
This section is why the release matters beyond speed.
One way to oversee a reasoning model is to read its chain of thought (CoT), the reasoning it writes out before answering. This works partly because a normal transformer has a fixed depth per token. Reasoning that needs more steps than that has to be written down, where a human or a monitor model can see it.
Looping raises that limit. A looped model can do more thinking internally, without writing it out. The worry is that this hidden reasoning could make models harder to monitor.
To study this, the lab also released TML-d24-varloop-research, a variant that can run with one to five passes. Their early findings:
- More silent reasoning, but it levels off. On the Think Fast benchmark, the no-CoT time horizon (how long a task, in human time, the model can solve half the time without writing reasoning) rose from 16 seconds at one pass to 37 seconds at three, then stayed roughly flat. On a serial lookup task (N-Hop Lookup), accuracy kept improving out to ten passes, even though the model was never trained with more than five.
- Shorter reasoning, still readable. On GPQA Diamond questions it answered correctly at every pass count, reasoning at five passes averaged 1,661 tokens versus 3,703 at one pass. Sentence length and the share of real English words did not change. The model mostly backtracked less: "wait", "actually" and "hmm" dropped from 9.7 to 3.6 per answer.
- Poor control over its own CoT. When asked to reshape its reasoning (for example, avoid a keyword), Inkling 2 Mini followed the instruction at most 0.1% of the time on 750 to 1,250 token CoTs. Low control is good news here, because a model that cannot steer its CoT also struggles to hide things from a monitor.
- No clear trend in sabotage stealth. In LinuxArena, where a model tries to complete a hidden malicious side task while doing normal engineering work, a weaker monitor caught most attempts. The stealth rate moved between 1.0% and 5.0% across pass counts with no clear upward trend.
The lab's own conclusion is careful: looping increases what the model can do without a visible CoT, but "at this scale" they do not see a meaningful loss of monitorability. They also note the variant was trained with RL at three passes only. A model trained with RL at higher pass counts might compress its reasoning more aggressively. That is an open research question, and releasing the weights is how others can test it.
How to try it
According to the launch post, as of November 2026:
- Mac: any Mac with at least 32GB of RAM via Ollama. If your machine has 24GB or less, the official Mac path does not cover you.
- Quantized GGUF builds: via Unsloth and llama.cpp.
- Servers: SGLang, vLLM, NVIDIA Dynamo and TokenSpeed, among others.
- Hosted: inference and fine-tuning on Thinking Machines' Tinker platform, plus chat in the Tinker Playground.
- Weights: both Inkling 2 Mini and the variable-loop research model are on Hugging Face.
The takeaway
Inkling 2 Mini is a bet that, for small models, reusing layers is a better deal than adding them. The reported results support that bet for agentic coding and tool use, and the limitations section is honest about where it does not help: facts, multi-turn chat and dense instruction following.
If you build agents that need to run locally, the useful questions are simple. Does your task depend on reasoning or on memorized knowledge? Can your agent give the model search and tools to cover the knowledge gap? And does your hardware have enough memory to hold about 20GB of weights with room for context?
Which part matters more for your work: the local speed, or the chance to study a model that thinks partly out of sight?