Run the Middle Layers Three Times: Inkling 2 Mini Puts a 26B Coding Model on Your Laptop
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.

In short: a model that runs on a laptop just beat every open-weights rival its size at coding
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini, an open-weights model with just 26.4 billion parameters. Its selling point is not size but shape: of its 24 transformer layers, the middle 12 run three times for every token generated, giving the effect of 48 layer applications from 24 stored layers. The full weights take up about 20GB, and the lab says a Mac with 32GB of memory can run it — researchers even ran it offline on a MacBook Pro during a flight and had it build a playable flight simulator in a few minutes.
The scorecard is the hardest part of the announcement. In the lab's own evaluations, Inkling 2 Mini scored 48.2% on DeepSWE v1.1, 79.2% on SWE-bench Verified, 77.9% on the SWE-bench Pro v2 hard set, 73.7% on SWE-bench Multilingual, and 77.9% on Vibe Code Bench — first among open-weights models under 100 billion total parameters on all five. Independent tester Artificial Analysis gave it 20.1 on its Intelligence Index, tied with Qwen3.8-27B, while using roughly a fifth of the active parameters. This is not another "small model does fine" consolation prize. It is a structural win: same parameter budget, used differently, and coding ability genuinely moves up a notch.
But the more interesting half of this release is what it does not hide. In the same blog post, Thinking Machines spells out the model's weaknesses: knowledge does not grow with looping, multi-turn chat is weak, and the reasoning process gets compressed in ways that make monitoring harder. The lab even shipped a variable-loop research model so outside researchers can study whether looped models are governable. A model launch that arrives with its own list of doubts attached is still rare this year.
What looping means: walking the same floors three times
To understand Inkling 2 Mini, start with what actually loops. A standard transformer is a pipeline: each token passes through every layer once, first to last. Inkling 2 Mini cuts its 24 layers into four blocks of six. The first and last blocks run once each; the two middle blocks run three times each. A token's full journey is 1 + 3 + 3 + 1 = 8 blocks, or 48 layer applications, while the stored weights stay at 24 layers' worth. Parameters unchanged, compute per token up — the model gets more "internal thinking" before producing its next word.
Why the middle layers and not the last ones? The lab's explanation is intuitive: layers near the ends mostly translate — turning word vectors into internal representations and back — while the middle layers hold the more abstract reasoning. The post gives controlled-experiment numbers: at training step 2,000, looping the middle layers (layers 7 to 18) delivered a gain equivalent to giving the non-looped baseline 1.51 to 1.91 times as much training compute; looping the last 12 layers gave an equivalent of only 1.24 to 1.36 times. Across 28 evaluations, looping the middle beat looping the tail on 27. The design was screened by experiment, not guessed.
Looping is not simply feeding the output back in. The model uses "attention residuals": each layer reads not only the previous layer's output but the outputs of all earlier blocks, learning its own mix of them. On the second and third passes through the middle blocks, the model also reads a "message" left by the previous pass, merged with the prelude's output through a gate learned during training. The gate starts fully closed — each loop begins exactly like a non-looped model — and opens gradually, letting the message seep in over time. The lab says this keeps looping stable to introduce during training instead of collapsing on day one.
The bill for looping cuts both ways. Training a non-looped version of the same model costs only 7.5% less compute; but for that non-looped model to match the looped version's loss on 512K-token agentic traces, it would need 140% more inference compute. In other words, looping moves cost from training to inference: the model gets smaller and cheaper to store, but each word costs more arithmetic. That trade is very good for local use and needs separate maths for metered cloud calls.
The scorecard: strongest at coding, standing still on knowledge
Coding first. In the lab's comparison table, Inkling 2 Mini is measured against four same-size rivals: Gemma 4 31B, Muse Glimmer, Qwen3.8-27B, and Nemotron 3.5 Super VL. On DeepSWE v1.1, Mini scored 48.2% against Qwen3.8's 42.2%, with the other three at 0.3%, 4.4%, and 24.7%. On SWE-bench Verified, Mini scored 79.2% against Qwen3.8's 77.8%. On the SWE-bench Pro v2 hard set, 77.9% against 73.8%. On SWE-bench Multilingual, 73.7% against 70.0%. On Vibe Code Bench, 77.9% against 64.9%. Across five coding benchmarks, Mini beat Qwen3.8 every time, by margins from 1.4 to 13 percentage points.
But the scorecard is not one-sided. On Terminal-Bench v2.1, Mini scored 71.6% against Qwen3.8's 73.0%, losing by 1.4 points. On FrontierCode v2.0, Mini's 15.1% barely edged Qwen3.8's 14.9%. On PMPP-Hard, a kernel-optimization benchmark, Mini's 455.82 points dwarfed Qwen3.8's 262.50 and approached the much larger Inkling 2 Small — Mini's brightest single result, and the clearest evidence that looping suits long-horizon work. On search and tool use, Mini took 79.0% on BrowseComp, 85.3% on DeepSearchQA, and 82.7% on MCP Atlas, first in its group on all three: it does not just write code, it finds answers with tools.
The independent numbers matter more, because they are not the vendor's own. Artificial Analysis put Mini at 20.1 on its Intelligence Index, tied with Qwen3.8-27B. The cost is where it pulls away: one Intelligence Index task costs $0.59 and 9.0 minutes for Mini, against $3.53 and 38.2 minutes for Qwen3.8 — about 6 times cheaper and 4 times faster. Measured by the compute proxy of active parameters times output tokens, Mini uses about 2.8 times less compute than Qwen3.8. There is a cost on the other side of the ledger: Mini emits about 152,000 output tokens per task, 38% more than Qwen3.8's roughly 110,000 — looping makes it think longer and write more, and some of that shows up in the token bill.
A separate independent test from two Stanford labs looked at intelligence per joule: how much energy a model needs per query to reach a given level of performance. Running on an NVIDIA DGX Spark, Mini scored 0.703, against 0.430 for Qwen3.6-35B-A3B, 0.159 for Gemma-4-26B-A4B, and 0.036 for Qwen3.5-27B. Mini's lead is larger on this measure than on benchmark scores, which says its advantage is not only "higher marks" but "more work per watt". For a team that wants to keep several agents running locally for a long time, that number is more useful than the 48.2% on DeepSWE.
The weaknesses are printed in the same official table and are not hard to find. On the factuality benchmark AA-Omniscience, Mini scored -8.6, below Qwen3.8's -6.4 and Nemotron's -2.9. On multi-turn chat (MultiChallenge) it managed only 50.0%, and on complex constraints (ComplexConstraints) 33.4%, both behind Qwen3.8. On reasoning-heavy CritPt v2 and HLE-Diamond it also trailed. The lab's own explanation is candid: looping lets a model think longer, but it cannot make its weights store more facts — knowledge is mostly a function of total parameter count. Mini's total is 26.4B, and that ceiling stays where it is. Looping cannot move it.
How 20GB was achieved: pruning, 4-bit, distillation
Mini was not born small; it was operated on. It started training with 384 experts per layer, 8 chosen per token, and midway through training two-thirds of the experts were pruned away, keeping only the 128 most-used experts per layer and cutting total parameters with them. After pruning came "healing": 1 trillion tokens distilled from a larger internal Inkling model, recovering the performance lost in the cut by teaching the surviving experts to take over the deleted ones' work. Supervised fine-tuning followed, then reinforcement learning totalling 2.2 trillion tokens over 2,000 steps, on a similar data mix to Inkling 2 Small.
On precision it took an unusual path: 20 layers trained in NVFP4 4-bit precision from pretraining all the way through reinforcement learning, the last 4 layers in MXFP8 8-bit, and deployed at exactly the precision they were trained in — no post-training quantization, no conversion loss. That is how the full checkpoint fits in about 20GB. The lab's stated bar for local use is a Mac with at least 32GB of memory (MacBook or Mac Mini) via Ollama; NVIDIA's DGX Spark desktop AI computer is the other official target. Quantized GGUF builds come through Unsloth and llama.cpp. Inference runs on SGLang, vLLM, Ollama, Unsloth, NVIDIA Dynamo, TokenSpeed, and Llama App; fine-tuning runs on Tinker, SkyRL, Miles, and NVIDIA AutoModel; the weights themselves are on Hugging Face under the Apache 2.0 license.
The point of this combination is not any single number but that "runnable" and "capable" arrived together. A year ago, a 26B-parameter model scoring 79.2% on SWE-bench Verified was a data-centre configuration. Now it fits on a laptop and works offline on a plane. For an individual developer, that makes a coding agent something that can genuinely belong to them: code never leaves the machine, there is no per-token bill, and work continues without a network. The blog's little "Thinkyville" demo makes the point well: a tiny pixel town whose 20 residents are all driven by the same Inkling 2 Mini on one offline MacBook — planning their days, gossiping, hosting bake-offs, and answering notes left on their doors.
The other side of looping: reasoning gets shorter — can we still see it?
The weightiest section of the release is not about performance but about monitoring. Looped models carry a built-in problem: a standard transformer passes each token through its layers once, so reasoning that needs many steps has to be written out as a chain of thought (CoT), where people can read it. A looped model does several passes internally, so some reasoning never needs to be written down at all. Reasoning that never appears in the CoT cannot be caught by a CoT monitor — a question hanging over looped transformers since the 2018 Universal Transformers paper. Thinking Machines did not dodge it; it answered with data.
The lab shipped a variable-loop research model, TML-d24-varloop-research, whose loop count can be set from one to five passes, specifically for controlled experiments. The results cut both ways. On the reassuring side: with no chain of thought at all, the model's "no-CoT time horizon" — the length of task it can complete at 50% reliability without writing any reasoning — rose from 16 seconds at one pass to 37 seconds at three, then roughly flattened. On N-Hop Lookup, a task that cleanly tests serial reasoning by chaining lookups, accuracy kept improving out to ten loops, even though the model was only trained with up to five. Chains of thought got shorter: on GPQA Diamond, average reasoning tokens fell from 3,703 at one pass to 1,731 at three and 1,661 at five, less than half the original length — but no less legible, with sentence length and dictionary-word share essentially unchanged, and uncertainty markers ("wait", "actually", "hmm") falling from 9.7 to 3.6 per answer. The model gets more direct and backtracks less.
On the worrying side: the model barely controls its own chain of thought at all. On the CoT-Control-QA evaluation, which asks a model to steer its reasoning to satisfy a constraint such as avoiding a keyword, Mini and the variable-loop model succeeded at most 0.1% of the time on chains of 750 to 1,250 tokens, against 1.3% for Qwen3.8-27B and 0.3% for Inkling 2 Small — all very low, with Mini the lowest. The silver lining is that the rate is too low to distinguish: the evaluation cannot tell loop counts apart, so at least by current measurement looping has not made controllability worse. In the agentic LinuxArena control evaluation, with the weaker Qwen3.6-35B-A3B as monitor, the rate at which an attacker completed malicious side tasks undetected showed no clear trend with the number of looped passes. The lab's conclusion is deliberately restrained: "at this scale we do not see a meaningful reduction in the monitorability of their reasoning" — and it leaves the question open for much larger models.
How it relates to Inkling 2 Small
This site previously covered Inkling 2 Small: Thinking Machines' second-generation flagship at 594 billion parameters, whose weights were not yet open at the time. Mini is the same family's small sibling, with a completely different job: Small is the cloud flagship, Mini is the model that fits in a bag. Both share the same mainline training recipe and post-training pipeline; Mini was derived from it by pruning and adding loops. That relationship matters: Mini is not a cut-down Small but an experiment in "small and runnable" on the same technical line — asking whether looping lets a small model catch a large one on coding and agentic work. On this scorecard, within open-weights models of comparable size, the answer is yes.
For vibe coding, Mini's release has a direct meaning: it turns a coding agent from a cloud service into a tool that runs locally. Code does not need uploading, the bill is measured in electricity rather than tokens, and work continues on a plane — three concrete changes for independent developers and small teams. With inference and fine-tuning on Tinker, one-command runs on Ollama, and day-one support in vLLM, the ecosystem is ready now, not in six months.
Pricing and ecosystem: what $0.59 per task means
Artificial Analysis' cost figures deserve their own calculation. At Thinking Machines' first-party pricing — $0.15 per million input tokens, $0.50 per million output tokens, $0.015 per million cache-hit tokens — Mini completes an Intelligence Index task for $0.59 in 9.0 minutes, against $3.53 and 38.2 minutes for Qwen3.8-27B. For reference, GPT-6 Luna (max) scores 28 on the same index at $0.15 per task: closed frontier models are still cheaper in absolute terms, but that is cloud metered pricing, with code uploaded and billed per token. Mini's $0.59 is the cost of running on your own machine, so the fair comparison is with other locally run open models — and there, a roughly 6-times cheaper, 4-times faster gap is large enough to change a selection decision.
Ecosystem support arrived fast. vLLM shipped support on launch day, with fused kernels that combine the four message reads between passes into a single attention-residual operation; SGLang, Ollama, Unsloth, NVIDIA Dynamo, TokenSpeed, and Llama App support it too, and reinforcement-learning fine-tuning runs on SkyRL, Miles, and NVIDIA AutoModel. Launch-day vLLM support means this was not a "blog post first, ecosystem later" release — the integration was done before launch. The shortest path to trying it is Ollama: a 32GB Mac, pull the model, run it. For those who want to adapt it, Tinker offers inference and fine-tuning, and the weights are Apache 2.0 on Hugging Face, with no licensing obstacle to commercial use.
Why looping is hot now: from a 2018 paper to a 2026 product
Looped transformers are not a new idea. The 2018 Universal Transformers paper proposed reusing the same layers, and for years the architecture sat in the "beautiful in theory, unused in products" category. The reasons are not hard to see: looping saves parameters, not compute — running the same weights several times had no appeal in an era when bigger was better — and training was unstable, prone to collapse as loops deepened. Thinking Machines could ship it now because three things landed together: native 4-bit training that squeezes the model to 20GB, gated message passing that keeps looped training stable, and inference compute cheap enough that extra passes are affordable.
The deeper reason is a change of wind. Over the past two years, the race has shifted from "whose parameters are most" to "who does the most work on a fixed budget": spending more compute at inference time is now mainstream, local and offline use with data staying on-device is a real requirement, and agentic work happens to be heavy on multi-step serial reasoning — exactly what looping is best at. Mini's release reads as a marker of that shift: when "making the model smaller" no longer means "cutting its ability", small-model competition moves from parameter counts to structural innovation. Looping is one answer, not the only one, but it is the first this year to arrive with a complete scorecard.
One detail is worth noting: Thinking Machines did not sell looping as a black box. It published the research model, the variable-loop control experiments, and the monitoring evaluations' reasoning together, and it works with the US National Deep Inference Fabric (NDIF) to make the models accessible to interpretability researchers, giving Goodfire early access to study what happens inside the loops. That matches how it handled the monitoring question: the biggest risk of looped models is not performance but whether humans can still see what the model is thinking inside — a question the lab does not claim to have answered, but for which it handed out the tools to ask.
Three caveats
First, every headline number is vendor self-reported. The DeepSWE, SWE-bench, and Vibe Code Bench scores all come from Thinking Machines' own comparison tables, with evaluation setups varying by model (SWE-bench Verified, for example, is a bash-only configuration). Independent Artificial Analysis verified only the Intelligence Index and the cost and speed figures, not the full coding scorecard. Read this release with "official table" and "independent verification" kept apart.
Second, looping adds reasoning, not knowledge. Mini trails Qwen3.8-27B on factuality, long knowledge questions, and complex-constraint instructions, and the lab admits as much. It is a strong fit as a local coding assistant; it is not the right pick as an encyclopedia, or for executing a checklist of dozens of constraints. Before choosing a model, ask whether you need "writes code well" or "knows everything".
Third, do not read "runs on a laptop" as "runs on any computer". The official bar is a 32GB Mac or equivalent hardware; 20GB is the weights alone, and running needs headroom for context and runtime state. Machines with 8GB or 16GB are outside official support, and how far GGUF quantized builds push the bar down further is a question for community testing. The good news is that the weights are Apache 2.0 open, so that community testing will arrive quickly.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.