Inkling 2 Mini: Thinking Machines loops 12 of 24 layers three times and matches Qwen3.8 27B with 5.4B active parameters
Thinking Machines released Inkling 2 Mini on November 20 under Apache 2.0: a 26.4B mixture-of-experts model in a 20GB NVFP4/MXFP8 checkpoint that runs on a 32GB Mac. It ties Qwen3.8 27B on the Artificial Analysis index at about a sixth of the cost per task, but it is verbose and weaker on multi-turn chat.
Thinking Machines Lab released Inkling 2 Mini on Friday, November 20, 2026, as open weights under Apache 2.0. It is a 26.4B-parameter mixture-of-experts model with an unusual design: of its 24 stored layers, the middle 12 run three times for every token with shared weights, so each token passes through 48 layer applications. The whole checkpoint is about 20GB and runs on an Apple silicon machine with 32GB of memory or a single DGX Spark.
The result that matters is efficiency. Artificial Analysis gives it 20 on its Intelligence Index, the same score as Qwen3.8 27B (xhigh), while using about 5x fewer active parameters, and it finishes the index’s tasks for $0.59 each against $3.53 for Qwen. It follows Inkling 2 Small, the 594B model that launched on Tinker on November 5 with its weights still pending. This time the weights shipped on day one, on Hugging Face.
How the looping works
The 24 layers are split into four blocks of six. The first block runs once and the last block runs once; blocks two and three (layers 7 to 18) run three times in a row. Thinking Machines’ argument, building on the Universal Transformers line of work, is that the outer layers mostly translate between token embeddings and internal representations, while the middle layers do the more abstract work, so that is where extra passes pay off.
Two details make the loops trainable. Each layer reads earlier block outputs through its own learned mix (attention residuals), and every pass starts from the output of the first block rather than only from the previous pass. Passes two and three also receive a “message” from the pass before, behind a learned gate that starts closed, so at the beginning of training each loop behaves like an ordinary non-looped model and the network learns how much to use the extra passes.
Inside each layer the feed-forward blocks are sparse. Training started with 384 experts per layer and 8 chosen per token; partway through midtraining the lab pruned two thirds of them, keeping the 128 most used, then healed the model on 1T tokens distilled from a larger internal Inkling model. Post-training used supervised fine-tuning, reinforcement learning over 2.2T tokens and 2,000 steps, and on-policy distillation for alignment. Attention mixes local and global layers, and a vision encoder makes the model natively multimodal: text and images in, text out, with a 1M-token context window per the model card.
The parameter accounting needs care. The lab and model card say 3.4B unique weights are active per token, plus about 1.0B for each extra loop pass, which gives the 5.4B “active” figure used in comparisons. Artificial Analysis says 3.1B unique weights per text token. Either way, the model reads more weights than its unique active count suggests, and the model card warns that compute per token is higher than that number implies.
The evidence that looping helps
The launch post includes ablations, which is more than most releases offer. At training step 2,000, a model without loops needed 1.51-1.91x the compute to match the loss of the middle-looped version, while looping only the last layers was worth 1.24-1.36x. Looping the middle 12 layers beat looping the last 12 on 27 of 28 evaluations at equal training compute.
The more useful number for anyone deploying it compares unpruned looped and non-looped models on 512k-token agentic traces: skipping the loops saved 7.5% of training compute but needed 140% more inference compute to reach the same loss. That is the trade Thinking Machines is making. Looping costs FLOPs, not memory, and on a laptop or a small box memory is usually the binding limit. A 26B model that behaves like a larger one fits where the larger one does not.
The weights are stored the way they were trained: 20 layers in NVFP4 and the last 4 in MXFP8, so there is no post-training quantization step to lose quality. Support landed across the usual local and server stacks at launch, including vLLM, SGLang, llama.cpp, Ollama, Unsloth GGUFs, Exo on Apple silicon, Transformers, NVIDIA Dynamo and Docker Model Runner. The lab’s demo ran on a 48GB M5 Pro MacBook Pro in airplane mode.
Benchmarks and cost
Thinking Machines compares it against Gemma 4 31B, Muse Glimmer, Qwen3.8-27B and Nvidia’s Nemotron 3.5 Super VL. The pattern is that it beats or ties Qwen3.8-27B on agentic coding and search, roughly ties on reasoning, and trails on knowledge and some business tasks:
| Benchmark | Inkling 2 Mini | Qwen3.8-27B | Gemma 4 31B |
|---|---|---|---|
| SWE-bench Verified | 79.2% | 77.8% | 46.1% |
| SWE-bench Pro v2 Hard | 77.9% | 73.8% | 14.2% |
| DeepSWE v1.1 | 48.2% | 42.2% | 0.3% |
| Terminal Bench v2.1 | 71.6% | 73.0% | 43.4% |
| BrowseComp | 79.0% | 61.6% | 37.0% |
| MCP Atlas | 82.7% | 77.3% | 54.2% |
| ARC-AGI v2 | 49.3% | 42.4% | n/a |
| AutomationBench-AA | 41.8% | 48.2% | 4.9% |
| GDPVal-AA (Elo) | 1319 | 1427 | 627 |
These are the lab’s numbers. The independent view from Artificial Analysis is consistent with them on the headline: a score of 20 against a median of 10 for comparable open-weights models. Its cost and speed figures are where the model stands out. On Thinking Machines’ own API it priced at $0.15 per million input tokens and $0.50 per million output, ran at about 280 tokens per second, and averaged 9.0 minutes per index task against 38.2 minutes for Qwen3.8 27B, which Artificial Analysis summarizes as about 6x cheaper and 4x faster per task.
The catch is verbosity. It used about 152K output tokens per index task, roughly 38% more than Qwen3.8 27B for the same score, and 161M output tokens across the whole index against a median of 85.7M for comparable models. It wins on cost because each token is cheap and fast, not because it is concise. On local hardware, where you pay in time rather than dollars, that verbosity will be felt.
Limitations, safety and what to watch
The model card is unusually direct about weaknesses. Thinking Machines says this is not the strongest small model for multi-turn chat or heavily constrained instructions (50.0% on MultiChallenge and 33.4% on ComplexConstraints, both behind Qwen3.8-27B). Knowledge tracks total parameters, so extra loops do not help factual recall, and the card says it is more likely than larger models to state wrong information with confidence. It can get stuck in long reasoning loops, especially when debugging code, so the card recommends capping output tokens and agent turns. Setting reasoning effort to minimum does not turn reasoning off entirely, non-English output is weaker (testers saw clipped phrasing and mixed languages in Chinese), and the card warns that in agentic use it may take destructive actions without confirmation and misreport outcomes.
On safety, the lab reports pre-release evaluations for CBRN and cyber uplift, including on refusal-suppressed variants, and concludes the model gives no material uplift beyond existing open-weights models. Its internal agentic misbehavior rates are much lower than the comparison models (destructive actions 10.2% against 35.2% for Qwen3.8-27B), and chain-of-thought controllability, a proxy for whether a model can hide its reasoning from a monitor, was at most 0.1%. Thinking Machines calls its monitorability work preliminary, and it notes that looped models raise a new question: some computation happens across repeated passes rather than in visible tokens. At this scale it reports no meaningful loss of monitorability, and it released a research sibling, TML-d24-varloop-research, trained with one to five passes, so others can study the effect.
Three things to watch. First, independent local benchmarks: runtime support for looped models is new, the card says speed varies by stack, and most published speed numbers so far come from Thinking Machines’ own API. Second, whether the Inkling 2 Small weights follow, which would show whether Mini’s day-one release is a policy or a one-off. Third, whether other labs copy the approach. A recipe that trades inference FLOPs for memory is exactly what on-device and single-GPU deployments want, and the ablations give competitors a clear target to reproduce.
Get Insanely Good at AI
The book for developers who want to understand how AI actually works. LLMs, prompt engineering, RAG, AI agents, and production systems.
Keep Reading
How to Run Gemma 4 E2B on Raspberry Pi 5 with LiteRT
Deploy the Gemma 4 E2B model locally on a Raspberry Pi 5 using the LiteRT-LM runtime for real-time edge workflows and robotics.
Thinking Machines' Inkling 2 Small jumps 18 points on Artificial Analysis, with Apache 2.0 weights still pending
The 594B-parameter, 17B-active model launched November 5 on Tinker with closed weights. It scores 31 on the Artificial Analysis index, but uses about four times the output tokens of its predecessor.
Meta Opens Muse Spark: 816B Parameters, the Most Capable US Open-Weight Model
Meta released Muse Spark Open on October 15: an 816B-parameter MoE with 42B active, 1M-token context, natively multimodal, downloadable under a limited-commercial license, and claiming the most capable US open-weight title.
Mistral Large 4 Launches: 1T Parameters, Trained in Europe, Open Weights Promised
Mistral released Large 4 on October 6, a 1T-parameter MoE with 49B active, priced at $1.36/$4.18 per million tokens, served from European datacenters, with Apache-style open weights promised by the end of October and a claimed 82% score on a cyber index because it does not refuse.
Germany's Sovereign Kolibri Model Lands With Open Weights on Reunification Day
Aleph Alpha released Kolibri on October 3, a 78B-parameter bilingual English-German MoE with open Apache 2.0 weights, a 1M token context window, and a compliance story built entirely on German infrastructure and EU law.