Thinking Machines Lab just did the thing everyone asked for after Inkling 2 Small landed two weeks ago. That model was impressive and, at 594 billion parameters, basically un-runnable for anyone without a data centre. Yesterday, 20 November 2026, the lab released Inkling 2 Mini: 26.4 billion parameters, open weights, Apache 2.0, and a roughly 20GB footprint that runs offline on a laptop.

I haven't run it myself yet — it has been out for hours, and the honest version of this post is a source-checked breakdown, not a hands-on review. But the design idea behind it is genuinely interesting, and the numbers, if they hold up, change what a local coding agent can do. Here's what's real, what's reported, and what I'd actually do with it.

The trick: run the middle layers three times

Most models get smarter by getting bigger. Inkling 2 Mini gets smarter by re-reading its own work.

It's a 24-layer mixture-of-experts transformer, split into four blocks of six layers. The first block and the last block run once per token, like normal. The two middle blocks run three times. So each token makes 48 layer visits from 24 stored layers, and the model refines its internal representation before it produces the next token — more sequential thinking, without storing more parameters.

The numbers that matter:

Spec Inkling 2 Mini
Total parameters 26.4B (MoE)
Active per token 3.4B
Weight activations per token 5.4B, counting looped passes
Architecture 24 layers; middle 12 looped 3x per token
Footprint ~20GB (NVFP4, last 4 layers MXFP8)
Context window 1M tokens
Inputs Text and images
Licence Apache 2.0

The 3.4B-active figure is the one to hold onto. A 26B model that only fires 3.4B parameters per token is cheap to run, and the looping is what buys the reasoning back. The lab says an unpruned non-looped model cost 7.5% less to train but needed 140% more inference compute to match the looped version's loss on long agentic traces. In other words, looping trades a little training pain for a lot of inference savings. That's the right trade for a model meant to live on your machine.

There's a neat detail in how they built it, too. Training started with 384 experts per layer, then two-thirds were pruned mid-training, leaving the 128 most-used experts. The pruned model was then "healed" on a trillion tokens distilled from a larger internal Inkling model. Prune, then teach the survivors to cover the gaps. It's the kind of recipe other labs will copy.

The benchmark story: strong on coding, read the fine print

All of these scores are company-reported, and the company itself notes that evaluation setups vary between models. I haven't independently verified any of them. Take them as a first signal, not a verdict.

  • DeepSWE v1.1: 48.2%, against 42.2% for Qwen3.8-27B
  • SWE-bench Pro v2, Hard: 77.9%, against 73.8% for Qwen3.8-27B
  • SWE-bench Verified: 79.2%
  • Vals Index v2.2: 46.5%
  • Artificial Analysis Intelligence Index: 20.1, tied with Qwen3.8-27B
  • BrowseComp: 79.0%, DeepSearchQA: 85.3%, MCP Atlas: 82.7% — the browsing and tool-use scores lead its size class

The cost angle is the part that made me sit up. The company reports about $0.59 per Intelligence Index task against $3.53 for Qwen3.8-27B — roughly 6x cheaper and 4x faster per task. If that survives independent testing, the model isn't just capable, it's cheap enough to leave running. An independent energy-efficiency check from Stanford's Hazy Research and Scaling Intelligence labs, on an NVIDIA DGX Spark, put its intelligence-per-joule at 0.703, against 0.430 for Qwen3.6-35B-A3B and 0.159 for Gemma-4-26B-A4B. That's a third-party measurement, and it points the same way.

Now the honest counterweight, from the same release:

  • It is not the strongest small model for multi-turn chat or fussy instructions: 50.0% on MultiChallenge, 33.4% on ComplexConstraints v1.1. If your workflow is long conversations with many constraints, this is not the pick.
  • It trails larger models on hard reasoning: CritPt v2 and HLE-Diamond both favour the big models.
  • Looping does not add knowledge. The lab says this plainly: extra passes add computation, not stored facts. Its factual recall is in line with other models its size. The browsing and MCP scores look strong partly because the model is good at using search and tools to fetch what it doesn't know. Give it tools, or accept its limits.
  • Looping complicates oversight. A model that does more of its reasoning internally, before writing anything down, is harder to monitor by reading its chain of thought. The lab released a companion research model, TML-d24-varloop-research, trained with one to five passes, precisely so researchers can study that. Their early tests found no clear rise in stealth as loop count grew, but they call the results preliminary, and I would too.

What you can actually do with it

This is where Mini is a different story from Small. Small was a hosted model you admired from a distance. Mini is a model you can download.

Local coding agents, offline. The lab's demo has it building a playable flight simulator in a few minutes on a MacBook Pro in airplane mode. A demo is a demo, but the shape of it is the point: a coding agent that works on a plane, in a café with bad wifi, or on code you cannot send to a cloud API. If you handle client code under NDA, or work somewhere with flaky connectivity, that's a real change.

Twenty agents on one laptop. Their second demo runs one local instance driving all 20 residents of Thinkyville, a simulated pixel town. Persistent agents, each with their own state, on one machine. That's the shape of multi-agent experiments that used to need a server bill.

Fine-tuning without asking permission. The weights are Apache 2.0, and day-one support covers SGLang, vLLM, Ollama, Unsloth, llama.cpp, NVIDIA Dynamo and TokenSpeed for inference, plus SkyRL, Miles and NVIDIA AutoModel for RL fine-tuning. You can adapt this model to your codebase, your style, your tools — and the 1M-token context means you can feed it a lot of your repo at once.

The catch: 32GB of RAM. The weights are ~20GB, but Thinking Machines recommends at least 32GB of unified memory for Ollama on a Mac, to cover runtime overhead and context state. A base 16GB laptop won't cut it. That's still a normal developer machine in 2026, but check before you download.

How to try it today

  1. Hugging Face — the full weights are there now, Apache 2.0. GGUF versions via Unsloth and llama.cpp.
  2. Tinker Playground — chat with it hosted, no download. Good first stop if you just want to poke at it.
  3. Tinker — hosted inference and fine-tuning if you want to adapt it without running hardware.
  4. Ollama — local, on a Mac with 32GB or more unified memory. This is the "runs on your laptop" route.

If you're coming from the Inkling 2 Small story, one naming note: Inkling 2 Small (594B, hosted, weights promised later) and Inkling 2 Mini (26.4B, downloadable now) are different models. Don't mix up their benchmarks or their download links.

Should you care? A quick checklist

  • You run coding agents locally or offline — yes, this is the most interesting local model release of the year so far. Try it on a real task from your own repo, not a toy prompt, and compare it against whatever you're running now.
  • You fine-tune open models — the Apache 2.0 licence plus day-one RL tooling makes this a genuine candidate. The 1M context is the other half of the story.
  • You need a chat model for long, constrained conversations — probably not this one. The MultiChallenge and ComplexConstraints numbers say to look elsewhere.
  • You just want the cheapest capable model per task — worth testing. The reported $0.59 per task is a company number, so verify it on your own workload before believing it.

The bigger question this release asks is whether looping is a real direction or a clever one-off. A model that thinks harder by re-reading its own middle layers, instead of by getting bigger, fits exactly where developers actually live: on laptops, offline, with their own data. If the benchmarks hold up outside the lab, expect every open model after this one to have a looped variant.

Have you got it running yet? I'd genuinely like to hear what it does on your machine, especially if you tried it on a real repo. What broke first?