Inkling 2 Mini Loops Its Middle Layers 3x for Deep Reasoning in a 20GB Laptop Memory
Running code models on a local laptop presents a classic deadlock for developers.
Models with too few parameters are fine for single-line completion, but once you ask them to handle multi-file modifications or agentic tasks, the reasoning chain quickly breaks. Slightly larger models typically require hundreds of gigabytes of VRAM, which ordinary people's computers simply can't accommodate, forcing them to keep paying for cloud APIs.
On November 20, 2026, Thinking Machines Lab officially open-sourced Inkling 2 Mini, along with a variant-loop research version (TML-d24-varloop-research) for community study. In the official demo, researchers switched a 48GB M5 Pro MacBook Pro to airplane mode and, within minutes, used it to write a working flight simulator entirely offline, while simultaneously driving 20 pixel-town residents' daily interactions on the same offline Mac.
The model has 26.4B total parameters, uses about 20GB of memory, and officially supports local operation on MacBooks or Mac Minis with 32GB or more RAM via Ollama. News quickly hit the Hacker News front page, earning over 1200 upvotes.
What made the community stop and study it closely is the architectural choice behind it: since you can't fit more layers into the parameter count, run the same network layers multiple times during inference.
Not by stacking parameters, but by looping the middle 12 layers 3 times
A conventional Transformer processes every token by going from the first layer to the last, passing through each layer exactly once. If you want deeper sequential reasoning, the traditional path is only one: keep adding layers and parameters, making the model fatter and fatter.
Inkling 2 Mini takes a different approach. It has only 24 physical layers, divided into 4 modules of 6 layers each. The first and last blocks run only once, responsible for translating input/output into internal representations; the middle two blocks (a total of 12 layers, layers 7-18) are designed to loop continuously 3 times.
Thus, the model stores only 24 layers' weights on disk and in memory, but each token actually experiences a computation depth of 48 logical layers. Because it uses a mixture-of-experts (MoE) architecture, it has 26.4B total parameters, 3.4B activated per pass, and when accounting for the 3x loop through the middle layers, the weight activation per token is 5.4B.
To make the loop effective, the team didn't simply add the previous round's results; they introduced an Attention Residuals mechanism proposed by the Kimi team. Starting from the second loop iteration, the middle layers use a learned gating switch to read the previous loop's output as needed, then continue reasoning with the initial features from the first block. Early in training, this gate is nearly closed, letting the model start smoothly; as training progresses, cross-round information transfer is gradually opened up.
This approach is very cost-effective in terms of compute. In their ablation comparison on the unpruned version, Thinking Machines Lab calculated that although the non-loop model saves 7.5% compute during training, at inference time, to achieve the same loss on a 512k-token long-horizon agent trajectory, the non-loop model requires 140% more inference compute.
The increased loop depth also brings a direct byproduct: less rambling. On the official variant-loop research model TML-d24-varloop-research, facing the same GPQA Diamond scientific reasoning set, running the loop once averages 3703 reasoning tokens, while running the loop 5 times only needs 1661 tokens. The chain-of-thought length is cut in half, while sentence readability and vocabulary norms remain essentially unchanged. The model just reasons internally and reduces output like "wait" or "no, let me restart" – the tentative backtracking.
Reflected in the official self-reported benchmarks, Inkling 2 Mini leads several metrics for open-weight models under 100B parameters: DeepSWE v1.1 scores 48.2% (compared to Qwen3.8-27B at 42.2% and Gemma 4 31B at 0.3%), SWEBench Pro v2 (Hard) reaches 77.9%, SWEBench Verified (bash only) reaches 79.2%, and Vals Index v2.2 reaches 46.5%.
Note that these scores come from the official technical report's self-reported tests, and the evaluation frameworks and configurations for compared models are not entirely consistent. Real-world performance still needs validation against your own codebase.
Training is 4-bit from the start, 20GB fits in a 32GB laptop
Many models claim to run on consumer devices by taking 16-bit weights from training and then having the community squeeze them into 4-bit quantized versions. After compression, the size shrinks, but coding and reasoning abilities often drop significantly.
Inkling 2 Mini's other core engineering change is using low-bit precision throughout the entire pipeline, from pretraining to reinforcement learning. The first 20 layers run entirely on native 4-bit NVFP4 precision, accelerated by dedicated operators on the NVIDIA GB300 platform; the last 4 layers retain 8-bit MXFP8 precision. The deployed weights are exactly the same numeric precision as training, avoiding conversion loss from post-training quantization.
To further compress the total size into the sweet spot of an ordinary laptop's memory, the model underwent an aggressive slimming during mid-training: originally each layer had 384 experts and selected 8 each time; the team directly pruned two-thirds of the least-used experts, leaving only 128 high-frequency experts, then used an internal large model to distill 1T tokens to help the remaining experts "catch up," recovering lost precision from pruning. Finally, they completed SFT and a total of 2.2T tokens with 2000 steps of reinforcement learning.
The final model's memory footprint is about 20GB. This means a 32GB MacBook or Mac Mini can fit the entire model comfortably while leaving system headroom, without external GPU clusters. Ecosystem support also landed the day of release: Hugging Face opened full weights, and Ollama, vLLM, SGLang, Unsloth, and llama.cpp all followed up immediately.
In independent third-party testing, Stanford's Hazy Research Lab and Scaling Intelligence Lab received early access and tested Intelligence per Watt (unit energy efficiency) using MXFP8 precision on a 128GB NVIDIA DGX Spark. Inkling 2 Mini scored 0.703, notably higher than the Qwen3.6-35B-A3B (0.430), Gemma-4-26B-A4B (0.159), and Qwen3.5-27B (0.036) tested on the same platform. For developers who need to keep multi-agent background tasks running locally for long periods, this energy efficiency is very valuable.
Loops have limits: they save reasoning tokens but can't expand knowledge capacity
Before treating this model as a universal small powerhouse, you must be aware of several boundaries; the official limations section states them bluntly.
Looped computation can increase reasoning depth, but it cannot make weights magically remember more obscure facts. In the variant-loop experiments on TML-d24-varloop-research, for tasks involving long-context retrieval or multi-step reasoning, increasing loop count steadily improves scores; but once you switch to closed-book knowledge QA (like SimpleQA Verified and WorldVQA), accuracy barely moves no matter how many loops you run. On the factual evaluation AA-Omniscience v1.1, Inkling 2 Mini scored -8.6, lower than Qwen3.8-27B's -6.4.
The official solution is to make the model use search and external tools to compensate for knowledge gaps. It indeed leads open-source models of similar size on BrowseComp (79.0%), DeepSearchQA (85.3%), and MCP Atlas (82.7%). Conversely, if your use case is purely offline QA without retrieval tools, it doesn't have an advantage.
Multi-turn dialogue and complex constraint following are also weak spots. It scores only 50.0% on MultiChallenge and 33.4% on ComplexConstraints v1.1, both clearly behind Qwen3.8-27B. If you need an assistant that strictly follows a dozen formatting requirements and does fine-grained copywriting, a dense model of the same size may be more reliable.
Also, the more internal loops, the higher the proportion of the model "thinking silently" without writing into the chain-of-thought. Although Thinking Machines Lab has not yet detected a noticeable decline in monitoring readability or an increase in malicious deception tendencies at the current scale, they admit that if larger-scale looped models with higher loop counts undergo reinforcement learning in the future, supervising the model's implicit reasoning remains an open problem.
For front-line developers, the signal from Inkling 2 Mini is clear: if you have only a 32GB machine and want to run a programming agent locally and offline that can interface with terminal tools, decompose long-horizon coding tasks, and respond quickly, it offers a cost-effectiveness sweet spot that was hard to get before. But if your core needs are closed-book knowledge base QA or strict multi-turn instruction following, test it against your real evaluation set before switching, rather than just trusting leaderboards.
Top 1 from juejin.cn, machine-translated. The original thread is authoritative.
The loop approach fits local deployment better than simply stacking more layers. Reusing the middle layers lets 24 layers achieve 48 layers of depth, and combined with native 4-bit training, the size is squeezed to around 20GB, which is more convincing than post-hoc quantization. However, multichallenge is only 50.0% and complexconstraints 33.4%, so following complex constraints remains a weak spot. Before running long-context tasks locally, validate on your own codebase first, and don't just trust the official self-reported scores.