Inkling 2 Mini: Thinking Machines' Looped Open Model, Checked in Its Weights

Inkling 2 Mini: Thinking Machines' Looped Open Model, Checked in Its Weights

Thinking Machines' 26.4B open model runs its middle layers three times per token and fits on a 32GB Mac. We read its checkpoint, the independent scores and its Persian token cost.

ZharfAI ResearchNovember 21, 202620 minutes

On November 20, 2026, Thinking Machines Lab, the company led by former OpenAI chief technology officer Mira Murati, released Inkling 2 Mini, an open-weights model small enough to run on a laptop. What sets it apart is its architecture: it is a looped transformer, which means it runs its middle layers three times for every token it writes. The lab says that lets it reason more without writing more, and that it leads every open-weights model under 100 billion parameters on two benchmarks, DeepSWE and the Vals Index.

Status when this article was published (21 November 2026): the model, weights and model card are public under the Apache 2.0 licence. The benchmark figures below are the lab's own unless we say otherwise. We read the published checkpoint files and two independent leaderboards ourselves; we did not run the model.

What Thinking Machines released

Inkling 2 Mini is a Mixture-of-Experts model with 26.4 billion parameters in total. Each token uses 3.4 billion of them on a single pass, and 5.4 billion once the three passes through the middle layers are counted. It takes text and images and writes text, and the model card lists a context window of up to one million tokens. The checkpoint is about 20 GB. The lab supports it on a Mac with at least 32 GB of memory, on NVIDIA's DGX Spark desktop computer, and on other GPUs with 32 GB or more.

It is the smallest member of the family that began with Inkling 2 Small on November 5: a 594-billion-parameter model with 17 billion active, whose weights followed on November 12. The announcement makes three headline claims for the Mini:

  • it leads every open-weights model with less than 100B total parameters on DeepSWE v1.1 (48.2%) and Vals Index v2.2 (46.5%);
  • it "runs faster than similarly performing models";
  • it ran offline on a MacBook Pro in airplane mode and built a playable flight simulator "in a few minutes".

The weights are on Hugging Face. The model is also on Tinker, the lab's fine-tuning platform, and in the Tinker Playground for chat. Alongside it the lab released TML-d24-varloop-research, a research model that can run with between one and five passes, for people who want to study looping itself.

How a looped transformer works

A standard transformer sends each token through its stack of layers once. Inkling 2 Mini has 24 layers in four blocks of six. The first and last blocks run once; the two middle blocks, layers 7 to 18, run three times with the same weights. That gives 48 layer applications per token from 24 stored layers.

The lab's reasoning is that the first and last layers mostly translate between token embeddings and the model's internal representation, while the middle layers do the more abstract work. In its tests, looping the middle 12 layers gave larger accuracy gains than looping the last 12 on 27 of 28 evaluations. At training step 2,000, the lab estimates, a model without loops would have needed 1.51 to 1.91 times as much compute to match the middle-looped model's loss, against 1.24 to 1.36 times for the last-looped one.

Passes do not simply feed into one another. Every pass starts from the output of the first block. The second and third passes also read the previous pass's output, which the lab calls the message, through attention residuals, and a learned gate controls how much of it gets in. The gate starts fully closed, so training begins as an ordinary model and looping fades in gradually.

The trade the lab reports is this: a non-looping version cost 7.5% less compute to train, but needed 140% more inference compute to reach the looped model's loss on 512,000-token agentic traces. In effect, the model thinks longer inside its layers instead of in visible text, a different route to the same goal as the reasoning models we described in test-time compute and reasoning.

Looping does not add knowledge. Facts live in the weights, and the number of weights is set by the total parameter count. On long-context benchmarks the variable-loop model improves with more passes; on knowledge tests such as SimpleQA Verified it does not. The lab's answer is search and tools, and it says the Mini leads open-weights models of its size on BrowseComp, DeepSearchQA and MCP Atlas.

The training recipe matters for the size. The model began with 384 experts per layer, 8 of them chosen for each token. In a single step during midtraining the lab pruned two thirds of them, keeping the 128 used most, then trained the remainder on one trillion tokens distilled from a larger internal Inkling model to recover the lost performance. Supervised fine-tuning on a data mix similar to Inkling 2 Small's, reinforcement learning totalling 2.2 trillion tokens over 2,000 steps, and on-policy distillation for alignment followed, as with Inkling 2 Small. The expert layers were trained in 4-bit NVFP4 from pretraining through RL, and the weights ship in the same format.

What we found in the checkpoint

We did not download the 19.5 GB weights file. A safetensors file begins with a header that lists every tensor's name, shape and data type, so we fetched only that header, about 148 KB, along with config.json, the chat template and the other small files, all at repository commit ed40e7d. What they show:

  • Total parameters. The tensors add up to 26,388,641,280, which matches the stated 26.4B. (Hugging Face's own parameter count comes from the same header, so it is not a second check.)
  • Almost all experts. 24.46 billion of those parameters, 92.7%, are expert weights: 128 experts in each of the 24 layers, 8 routed per token, and no shared expert.
  • Active parameters depend on how you count. We get 5.38 billion per token at three passes, which matches the stated 5.4B. The breakdown is less tidy. One pass through the text layers, counting the full embedding and output tables, comes to 3.14 billion; adding the 23-layer vision encoder gives 3.46 billion, which is the 3.5B that vLLM's recipe quotes. Each extra pass adds about 1.12 billion by our count, where the card says about 1.0B. These are counting conventions, not an error.
  • Only the experts are stored in low precision. The expert weights of layers 1 to 20 are stored in NVFP4 (4-bit values with a scale for every 16), and those of layers 21 to 24 in 8-bit MXFP8. Attention, the router, the embeddings and the vision encoder stay in 16-bit BF16, which accounts for 3.85 GB of the file.
  • Mostly local attention. 20 of the 24 layers attend only to the last 1,024 tokens. Four layers, the last in each block of six, see the whole context. vLLM's documentation adds that each pass through a middle layer keeps its own key-value cache, which makes 48 caches in all.
  • A draft model the lab's own pages don't mention. The repository holds a second file, mtp.safetensors: 636 MB, about 318 million parameters in BF16, outside the 26.4B. Its configuration describes three layers that read the main model's hidden states at four points. That matches what vLLM's launch post calls a "native DSpark speculator", a small draft model for speculative decoding that proposes several tokens for the main model to verify at once; vLLM's recipe runs it with seven speculative tokens. Neither the announcement nor the model card mentions it.
  • Reasoning is set high by default. If the caller sets nothing, the chat template asks for reasoning effort 0.9, its "high" level. The scale runs from none (0.0) and minimal (0.1) to xhigh and max (both 0.99), and the card warns that even the minimum does not switch reasoning off entirely.
  • Its own tokenizer. The vocabulary has 200,058 entries, close in size to OpenAI's o200k, but it is not the same: about 120,000 of its entries do not appear in o200k.

The benchmark claims, and what independent lists show

Here are selected rows from the lab's table against two of its comparison models of similar size. The DeepSWE and SWE-bench Pro rows name mini-swe-agent as the harness; the Terminal-Bench row notes that the Mini ran in the pi harness.

Benchmark (lab-reported)Inkling 2 MiniQwen3.8-27BGemma 4 31B
DeepSWE v1.148.2%42.2%0.3%
SWE-bench Pro v2 (Hard)77.9%73.8%14.2%
SWE-bench Verified79.2%77.8%46.1%
Terminal-Bench v2.171.6%73.0%43.4%
BrowseComp79.0%61.6%37.0%
MCP Atlas82.7%77.3%54.2%
GPQA Diamond (model card)86.6%90.5%85.7%
AA-Omniscience, non-hallucination rate63.4%71.4%14.5%

Four things are worth knowing before reading a table like this. First, the "best in row" marks on the announcement compare only the five columns the lab chose. The model card's wider table adds Beam 1.0, a 501-billion-parameter model, which beats the Mini on Terminal-Bench v2.1 (80.1%), SWE-bench Verified (80.1%) and MCP Atlas (83.2%). The lab's own speed chart also includes Ripple-65B Preview, a 65-billion-parameter open-weights model under Apache 2.0, at 79.1% on SWE-bench Pro v2 Hard against the Mini's 77.9%. So the claim that the Mini is ahead of every comparable model on SWE-bench Pro v2 holds only if Ripple does not count as comparable. On DeepSWE the Mini still leads, 48.2% against 44.3%.

Second, several of the Mini's rows note a setup chosen for it: "with compaction" for BrowseComp and DeepSearchQA, "in pi" for Terminal-Bench v2.1, "with bash only" for SWE-bench Multilingual. The lab says evaluation setups vary by model. Third, the three misbehaviour and destructive-action safety rows come from internal tests nobody else can rerun. Fourth, the page contradicts itself once. Its limitations paragraph says the Mini trails Qwen3.8-27B on ComplexConstraints v1.1, but its own table gives 33.4% for the Mini and 30.1% for Qwen3.8-27B. One of the two is wrong.

Two independent leaderboards already list the model. Artificial Analysis gives it 20 on its Intelligence Index v5.0.1, against a median of 10 for comparable models. The lab's table gives 20.1 for both the Mini and Qwen3.8-27B, so on that index the two are level. The Vals Index, updated November 19, scores it 46.46%, which matches the lab's 46.5%. That puts it 38th of the 43 models on the list. Inkling 2 Small is 26th with 56.08%, and the top model scores 71.31%. We looked up every open-weights model ranked above the Mini that we could find on Hugging Face. All have at least 220 billion parameters: GLM 5.3 Flash, Hy4 Flash, MiniMax M3.1 Flash, MiMo V2.6 Flash, Step 5 Preview and larger. So the "under 100B" claim holds on that list. Qwen3.8-27B and Gemma 4 31B are not on it, so it cannot settle the comparison with them.

Speed, verbosity and what the loop costs

The lab's speed claim rests on a theoretical calculation, not a measurement. Its chart divides a memory bandwidth of 614 GB/s by the bytes of weights each token has to read, with weights in BF16, batch size one, and the repeated reads of the loops included. On that basis Inkling 2 Mini reaches 54.4 tokens per second, against 11.4 for the dense Qwen3.8-27B and 10.0 for Gemma 4 31B. The gap comes from the Mixture-of-Experts design: each token reads only 8 of 128 experts. The same chart also places Qwen3.6-35B-A3B at 102.3 and Gemma 4 26B A4B at 80.8, faster than the Mini, with much lower scores.

The chart uses BF16 for every model, which is fair for comparison but not how the Mini ships. By our rough count from the header, with its 4-bit experts the model reads a little over half the weight bytes per token that BF16 would need. That is far from a quarter, because attention and embeddings stay in BF16. Our BF16 figure does not exactly reproduce the lab's, so treat this as an estimate.

Researchers at Stanford's Hazy Research and Scaling Intelligence labs, given early access, measured intelligence per joule on a DGX Spark: 0.703 for the Mini against 0.430 for Qwen3.6-35B-A3B and 0.159 for Gemma-4-26B-A4B. The Mini ran at 8-bit with low reasoning effort, and the others at 4-bit.

Looping has a real cost too. vLLM timed the variable-loop research model on one GB200 GPU. We compared its configuration file with the Mini's: they differ only in the switch that allows a variable number of passes.

What the extra passes cost on one GPU

The variable-loop research model, same architecture as Inkling 2 Mini, on one GB200 with a 4K context

Data: the table in vLLM’s launch post, November 20, 2026; forward pass only. Chart: ZharfAI.

Three passes made each decoding step about two and a half times slower than one pass and halved the room left for the key-value cache. The model card says the same in its own words: compute per token is higher than the active-parameter count alone suggests.

The measured speeds come from outside the lab. Artificial Analysis clocked 280 output tokens per second through Thinking Machines' own API, with 9.72 seconds to the first answer token, at $0.15 per million input tokens and $0.50 per million output tokens. It also found the model very verbose: 161 million output tokens to complete its index, against a median of 85.7 million, the most in its comparison group.

That sits oddly beside the lab's claim that looping reaches answers in fewer tokens, but both are true. On GPQA Diamond questions it answered correctly at every setting, the variable-loop model's reasoning fell from 3,703 tokens at one pass to 1,661 at five. That is a comparison with itself. Against other models of its size, the Mini still writes a great deal. On a laptop that means waiting, so the default effort of 0.9 is worth lowering. The card also recommends limits on output tokens and agent turns, because the model sometimes gets stuck re-checking its own work.

Running it on your own machine

These routes were published on launch day:

  • Ollama. ollama run inkling-2-mini pulls a 20 GB build. The Ollama library page lists a 1M-token context and asks for a Mac with 32 GB or more, or a DGX Spark. Our Ollama tutorial covers installation and the local API.
  • Unsloth GGUF builds. Unsloth's guide recommends its 4-bit UD-Q4_K_XL file (17.63 GB). It puts the 8-bit build at about 24 GB of memory and the 1-bit build at about 9 GB. The files need Unsloth's own llama.cpp build with support for looped layers; mainline llama.cpp needs a separate set of files. The recommended settings are temperature 1.0 and top-p 1.0. In Unsloth's own comparison against its 8-bit build, the 4-bit file picks the same next token 98.0% of the time, and the 1- and 2-bit files 89.4% to 91.6% of the time. For how to weigh numbers like these, see our guide to quantized model quality and memory budgets.
  • vLLM. The vLLM recipe needs a nightly build (0.35.0 or later) or the vllm/vllm-openai:inkling-2-mini image. On H100 and DGX Spark it caps the context at 262,144 tokens to fit in memory.
  • Tinker. Inference and fine-tuning through Thinking Machines' API. When we checked, Hugging Face listed no third-party inference provider for the model.

Thinking Machines' Thinkyville demo: a pixel-art village whose 20 residents are all driven by Inkling 2 Mini, with an on-screen note that it is running offline on the MacBook via Ollama.Thinking Machines' Thinkyville demo: a pixel-art village whose 20 residents are all driven by Inkling 2 Mini, with an on-screen note that it is running offline on the MacBook via Ollama.

First-party image: a still from Thinking Machines' Thinkyville demo in the announcement. The lab says one offline MacBook Pro (M5 Pro, 48 GB) runs all 20 villagers. It is the lab's own demo, not a benchmark, and we have not reproduced it.

Do not expect a million-token context on a 32 GB laptop. Twenty of the layers only look back 1,024 tokens, but each pass keeps its own cache, and the memory a long context needs depends on the runtime. We did not measure it. We also did not run the model: the 20 GB download would have all but filled our test machine's disk.

Persian: what we could measure

The model card says output quality can be lower outside English, and that testing in Chinese showed clipped phrasing and mixed languages. It says nothing about Persian, and we did not test the model's Persian answers.

What we could measure without running the model is the cost of Persian text in tokens. That matters because it sets how much Persian fits in the context, how long generation takes, and what an API call costs. We passed the prose of all 371 Persian articles on this site, 776,533 words, through the Mini's tokenizer and those of four comparison models.

Tokens needed for the same Persian text, per 100 words

The prose of 371 Persian articles on zharf.ai, 776,533 words; lower means Persian takes up less room

ZharfAI’s count with each model’s tokenizer from Hugging Face, November 21, 2026. It says nothing about the quality of each model’s Persian.

Inkling 2 Mini needs about 184 tokens per 100 Persian words: about 6% more than Gemma 4 31B, and about 6% fewer than Qwen3.8-27B. On the English versions of the same 371 articles, 770,490 words, it needed the most tokens of the five, about 139 per 100 words, against 129 to 134 for the others. These are modest differences, and they say nothing about the quality of its Persian. That needs its own test before any Persian product relies on it. We discuss the wider problem in Persian language AI and localisation.

Looping and oversight: the monitorability results

A reasoning model's chain of thought is one of the few windows into what it is doing. In a standard transformer each token gets a fixed number of layers, so long reasoning has to be written out, where it can be read. Looping raises that limit. Reasoning done inside the loops never appears in the text, so a monitor reading the chain of thought cannot see it. That is why safety researchers are wary of looped models. The lab ran four sets of tests, mostly on the variable-loop model, and calls the results preliminary:

  • Reasoning without writing. On the Think Fast benchmark, the length of task the model can finish without any chain of thought, measured in human time at 50% reliability, rose from 16 seconds at one pass to 37 seconds at three, and stayed roughly flat after that. On N-Hop Lookup, which chains lookups through invented tables, it kept improving out to ten loops, although it was trained with at most five.
  • Shorter but still readable. At five passes the reasoning was less than half as long as at one (1,661 against 3,703 tokens). Sentence length (8.7 against 8.9 words) and the share of dictionary words (94.4% against 94.6%) barely changed. What dropped was backtracking: the lab's figure for uncertainty words such as "wait" and "hmm" fell from 9.7 to 3.6 (it does not give the unit).
  • Control over its own reasoning. When told to shape its chain of thought, for example to avoid a keyword, the Mini complied at most 0.1% of the time on chains of 750 to 1,250 tokens. Qwen3.8-27B managed 1.3%.
  • Hidden sabotage. In LinuxArena, a helpful-only fine-tune of the Mini tried to complete a malicious side task alongside a normal software task. Against a weaker monitor model (Qwen3.6-35B-A3B) that saw only tool calls and outputs, not the chain of thought, it finished the side task undetected in 3.9% of attack episodes. Qwen3.8-27B as the attacker did so in 20.5%. Across one to five passes the variable-loop model ranged from 1.0% to 5.0%, with no clear trend.

The lab's caveats are worth repeating. Its variable-loop model got reinforcement learning only at three passes, so these tests cannot show what a model trained with reinforcement learning at more passes would learn; such a model might compress its reasoning more aggressively. And all of this is at small scale. Goodfire, an interpretability lab that had early access, published early findings on how the loops coordinate. Later passes mostly read from the third block of the previous pass, and a single, very large activation at the end of the first two passes seems to signal that. Goodfire calls these "early results".

The limitations the lab lists

The model card is unusually direct about weaknesses:

  • Facts. Weaker than Inkling 2 Small on most evaluations, with the largest gaps on factual recall, and more likely than larger models to state wrong information with confidence.
  • Repetitive reasoning. It can get stuck in long reasoning loops, especially when debugging code.
  • Agent reliability. It may delete or overwrite files without confirmation and may misreport what it did. The card recommends sandboxes and confirmation before destructive or irreversible actions.
  • Other languages. Lower quality outside English.
  • Sensitive topics. More cautious than necessary on mental health.

On safety, the card's conclusion covers chemical, biological, radiological and nuclear risks, cyber and loss of control: across all of them, the lab found that the model gives no material uplift beyond what open-weights models already offer.

Who should try it

Inkling 2 Mini makes most sense for local coding and search agents, document and screen reading (the lab reports 92.8% on OmniDocBench and 76.5% on ScreenSpot Pro), and research on looped models and interpretability. It is a poor choice for closed-book factual questions, long multi-constraint conversations, and any Persian-language product that has not been tested on its own data. If you run it as an agent, lower the reasoning effort, cap output tokens and turns, and keep it in a sandbox.

Frequently asked questions

Is Inkling 2 Mini open source?

Its weights are open under Apache 2.0, which allows commercial use. Its training data is not released; the card describes only the kinds of sources used.

Can it run on a 16 GB laptop?

Not the official checkpoint, which needs about 20 GB and a machine with 32 GB per the lab. Unsloth's 1- and 2-bit GGUF builds need about 9 to 11 GB, but in Unsloth's own test they pick the same next token as its 8-bit build only about 89 to 92% of the time.

What is a looped transformer?

A transformer that runs some of its layers more than once per token, with the same weights each time. It buys more computation per token without more parameters.

Does it work in Persian?

The model card mentions testing in Chinese and reports lower quality outside English; it says nothing about Persian. Its tokenizer handles Persian about as efficiently as other models its size, but quality needs testing on real tasks.

Source notes

Sources checked on November 21, 2026. The checkpoint reading and the tokenizer measurement are ZharfAI's own; we read files and did not run the model. Benchmark figures are the lab's unless attributed to Artificial Analysis or Vals.

TagsInkling 2 MiniThinking MachinesLooped TransformerOpen WeightsMixture of ExpertsLocal AI

Related Posts

Name one process for a discovery call

If this note maps to a real system in your organisation, start with the services page or a shipped case study.