Last week I wrote that Inkling 2 Small was a great open-weights release that almost nobody could run at home. Thinking Machines Lab clearly heard that complaint from a lot of people. On Friday, Nov. 20, the company released Inkling 2 Mini, a model built from the start to fit on a laptop, and the weights are up on Hugging Face under the Apache 2.0 license.
The headline numbers are friendly to home hardware. It’s a Mixture-of-Experts model with 26.4 billion total parameters, 3.4 billion of them active per token, and the official checkpoint is about 20GB. It takes text and images as input, and Thinking Machines lists a context window of up to 1 million tokens. The interesting part is how it gets more out of those parameters. Inkling 2 Mini is a looped transformer, which means it runs part of its own network more than once for every token it generates.
Why a looped model is a big deal for local AI
Here’s how the loop works. According to the official model card, the model has 24 layers. The first six and last six run once. The middle 12 run three times with the same shared weights. So every token gets 48 layer passes while the file on your SSD only stores 24 layers’ worth of weights. Thinking Machines says each extra pass adds about 1 billion effective active parameters, which is how it arrives at 5.4 billion “weight activations” per token.
The company’s reasoning is that the middle of a transformer does most of the abstract thinking, while the outer layers mostly translate between tokens and internal representations. In its own experiments, looping the middle 12 layers beat looping the last 12 on 27 of 28 evaluations. Hugging Face’s launch write-up adds a useful detail: each pass through the looped core starts from the same output of the first six layers, and the passes trade information through small learned “cross-pass messages” with gates that decide how much to keep.

Why should a gamer with a decent PC care? Memory is the wall for local AI. A model that does more computation per token without getting bigger on disk or in VRAM is exactly the tradeoff home users want. If you remember the PS2 era, it’s a bit like developers squeezing more out of a fixed 32MB of RAM by being clever with the hardware instead of waiting for more of it. There’s a cost, though, and Thinking Machines is upfront about it: because the middle layers run three times, the compute per token is higher than the 3.4 billion active parameters suggest. Speed depends heavily on your runtime.
The weights were trained and ship natively in NVFP4, with the last four layers in MXFP8. That’s why the checkpoint stays near 20GB without a separate quantization step that loses quality. Officially supported local hardware is NVIDIA’s DGX Spark and Apple silicon Macs with 32GB or more of memory. For other GPUs, the model card says they’re “possible,” with 32GB or more of VRAM recommended.
Software support was ready on launch day, which isn’t something you can always count on. The model card lists SGLang, vLLM, NVIDIA Dynamo, TokenSpeed, Unsloth, llama.cpp, Llama App, Ollama and Exo Labs. Ollama’s library page lists a 20GB build with the full 1M context. The ggml-org GGUF repo has an IQ4_NL file at about 17.6GB and Q8_0 at about 27.8GB. Unsloth’s quants range from about 7.8GB for an extreme 1-bit version up to 22.9GB. By Unsloth’s own measurements, its 4-bit builds pick the same top token as its 8-bit reference about 98% of the time. That suggests a 24GB graphics card is a realistic target for a 4-bit quant, though long contexts will eat into that headroom fast. Thinking Machines also released a research variant, TML-d24-varloop-research, that lets you pick how many loop passes to run. Fewer passes means faster output, and Hugging Face says it may also mean slightly lower quality.
On benchmarks, the company says Inkling 2 Mini leads every open-weights model under 100 billion total parameters on DeepSWE v1.1 (48.2%) and the Vals Index v2.2 (46.5%). In its comparison table against Gemma 4 31B, Muse Glimmer, Qwen3.8-27B and Nemotron 3.5 Super VL, it posts 79.2% on SWE-bench Verified (bash only) against 77.8% for Qwen3.8-27B, and 79.0% on BrowseComp. Hugging Face counts 32 wins out of 48 benchmarks in that comparison. These are vendor-reported numbers with varying evaluation setups, so treat them as a starting point, not a verdict.

The catches: knowledge gaps, thinking spirals and early tooling
The thing I respect most about this launch is how plainly Thinking Machines lists the weak spots. Looping helps reasoning, but the company says it doesn’t let the weights store more facts. Knowledge mostly comes down to total parameter count, so Inkling 2 Mini’s factual recall is roughly what you’d expect from a model its size. The plan is to cover that gap with search and tools. That’s fine on a desk with Wi-Fi, but it matters for those “runs offline on a plane” demos.
Multi-turn chat isn’t its strength either. Thinking Machines reports 50.0% on MultiChallenge and 33.4% on ComplexConstraints v1.1, behind Qwen3.8-27B on both. The model card also warns about “repetitive reasoning,” where the model gets stuck re-checking its own work. It recommends caps on output tokens and agent turns, and says the model may take destructive actions like overwriting files without asking. Run it in a sandbox if you hand it a terminal.
Early users are seeing the same things. In the Hacker News discussion, which passed 1,100 points, one tester said a simple Python CSV task went great but a coin-identification prompt spiraled past 12,000 tokens. Another commenter running Unsloth’s Q4 build said a WordPress plugin prompt hit their 19,200-token thinking limit without finishing. They also said that once tools were allowed it wrote good code but still used the wrong hook name. These are anecdotes, not benchmarks, but they match the company’s own warnings closely. The model card also admits that support for looped models in local runtimes is new and speed “varies by runtime and hardware.” Expect a few weeks of llama.cpp and Ollama updates before performance settles.
There’s also a research angle that goes beyond local inference. A looped model can “think” more inside its layers without writing that reasoning out, and that makes it harder to oversee by reading its chain of thought. Thinking Machines tested this using the variable-loop model. It says the amount of work the model could do without a written chain of thought grew from 16 seconds to 37 seconds of equivalent human time as it went from one pass to three, while the chain of thought got shorter but stayed readable. That’s an honest, measured result, and it’s good to see the company publish it rather than skip the question. Whether it holds up for much bigger looped models is still an open question.
Cody’s take
This is the Inkling I was hoping for. Apache 2.0, a roughly 20GB footprint, day-one GGUF and Ollama builds, and a new architecture that open-source tools now have to support. That’s a fun weekend for anyone with a 24GB-plus GPU or a 32GB Mac. The Thinkyville demo, with 20 villagers all run by one model on a single offline MacBook, shows the kind of multi-agent tinkering a small, efficient model makes possible.
I’d keep expectations in check, though. The benchmark lead over Qwen3.8-27B is narrow on many tests and comes from Thinking Machines’ own evaluations. The thinking spirals early testers describe are a real usability problem, and runtime support is still settling. If you already have a local coding setup you like, run Inkling 2 Mini next to it with a token cap and compare results on your own tasks before switching. If you’ve been waiting for a frontier-lab model that fits on a gaming PC, this one is worth the download.
Featured image: a flight simulator Thinking Machines says Inkling 2 Mini built offline on a MacBook Pro during a flight. Image: Thinking Machines Lab.




