Quick Answer
Inkling 2 Mini is Thinking Machines Lab’s looped-transformer AI model, released on November 20, 2026. It has 26.4 billion total parameters with 3.4 billion active per token, and its middle 12 layers run three times per token, giving 48 layer applications from 24 stored layers. It reads text and images and answers in text, with a context window of up to 1 million tokens. The weights are open under Apache 2.0 and fit in about 20GB, so it runs on a 32GB Mac or one DGX Spark — or on Tinker from $0.15 per million input tokens. Thinking Machines reports 79.2% on SWE-bench Verified and 20.1 on the Artificial Analysis Intelligence Index; the first is the lab’s own score, the second is an independent evaluation.
What Is Inkling 2 Mini?
Inkling 2 Mini is the second model of Thinking Machines Lab’s second Inkling generation, and the smallest model the lab has released. The first generation had two models — Inkling (975 billion total parameters, 41 billion active) and Inkling-Small (276 billion total, 12 billion active) — and the second generation started with Inkling 2 Small (594 billion total, 17 billion active) on November 5, 2026. Mini is the lightweight branch of that same generation: 26.4 billion total parameters, 3.4 billion active per token.
The trick is looping. A normal transformer passes each token through its layers once. Inkling 2 Mini has 24 layers in four blocks of six, and the two middle blocks — layers 7 to 18 — run three times per token, with shared weights. That gives 48 layer applications from 24 stored layers, so the model does more reasoning per token without adding parameters. The lab’s own experiments found looping the middle layers gave a bigger accuracy gain than looping the last 12 on 27 out of 28 evaluations, and that the extra passes help multi-hop reasoning and long-context retrieval most, while factual recall barely moves — knowledge, the lab says, is mostly a function of total parameter count.
It is a sparse Mixture-of-Experts model: each token is routed to 8 of 128 experts per layer, with a hybrid of local and global attention. The model started training with 384 experts and was pruned mid-training to the 128 most-used experts per layer, then healed with 1 trillion tokens distilled from a larger internal Inkling model. Most weights were trained and are deployed natively in 4-bit NVFP4 precision, with the last four layers in 8-bit MXFP8, so the checkpoint is about 20GB with no conversion loss from quantization.
The lab showed it off by running the model offline on a MacBook Pro (M5 Pro, 48GB) in airplane mode, where it built a playable flight simulator in a few minutes. It also built Thinkyville, a tiny pixel town where the same model powers all 20 villagers on one offline MacBook.
Release Date and Availability
- November 5, 2026 — Inkling 2 Small arrives on Tinker with closed weights; its weights land on Hugging Face a week later, on November 12.
- November 20, 2026 — Inkling 2 Mini is released, with open weights from day one. The announcement is “Introducing Inkling 2 Mini” on Thinking Machines Lab’s site, and the Hugging Face model card lists the same date.
- Where to get it — the weights are on Hugging Face as
thinkingmachines/Inkling-2-Mini, a single checkpoint of about 20GB under Apache 2.0, with a separate Model Acceptable Use Policy. It is also available for inference and fine-tuning on Tinker, and for chat on the Tinker Playground. - Local inference — any Mac with at least 32GB of RAM via Ollama, one NVIDIA DGX Spark, or other GPUs with 32GB or more of VRAM. Quantized GGUF versions are available via Unsloth and llama.cpp. Open-source inference is supported on SGLang, vLLM, Ollama, Unsloth, NVIDIA Dynamo, TokenSpeed and the Llama App, with RL fine-tuning support on SkyRL, Miles and NVIDIA AutoModel.
- A research sibling — the lab also released a variable-loop research model, TML-d24-varloop-research, on Hugging Face, for studying how different amounts of looping affect what a model can do and how easy it is to oversee.
Key Inkling 2 Mini Features
1. Looped layers — 48 passes from 24 stored layers
The middle 12 of the model’s 24 layers run three times per token, with shared weights. Each extra pass adds about 1.0 billion effective active parameters, so the model behaves like a 5.4-billion-active model while storing only 26.4 billion parameters in total. The passes share a “message” — the middle blocks’ output from the previous pass — merged with the first block’s output through a learned gate.
2. Sparse Mixture-of-Experts: 26.4B total, 3.4B active
Only about 13% of the model works on any given token. Each token is routed to 8 of 128 experts per layer. Counting the three loop passes, the model applies 5.4 billion weight activations per token — so quote both numbers: 3.4 billion unique active weights, 5.4 billion counting the loops.
3. Native 4-bit weights, about 20GB
Twenty layers run in NVFP4 and the last four in MXFP8, the same precision the model was trained in. There is no post-training quantization step and no conversion loss, and the whole checkpoint fits on a laptop.
4. Text and image in, text out — up to 1M tokens
The model accepts text and pixel-based images (each side ideally between 40 and 4096 pixels) and answers in text. The model card lists a context window of up to 1 million tokens. On Tinker, sampling reaches 1M; training contexts are 64K and 256K.
5. Runs on a laptop — 32GB Mac or one DGX Spark
The model card supports one NVIDIA DGX Spark, Apple silicon devices with 32GB or more of memory, and other GPUs with 32GB or more of VRAM. The lab’s offline MacBook Pro demo and the Thinkyville village are the proof points it leads with.
6. Open weights under Apache 2.0, from day one
Unlike Inkling 2 Small, which launched closed and opened a week later, Mini’s weights were on Hugging Face the same day, under Apache 2.0. That covers running, modifying and redistributing the weights, including for commercial use, subject to the lab’s Model Acceptable Use Policy.
7. Built for agentic coding and tool use
The lab’s headline results are on agentic coding: 79.2% on SWE-bench Verified and 77.9% on SWE-bench Pro v2 Hard, both the best in its own comparison table. Tool-use scores are strong too: 82.7% on MCP Atlas and 85.3% on DeepSearchQA.
8. A research model for looped transformers
Looping lets a model do more computation without writing its reasoning down, which raises a real question: can we still oversee it by reading its chain of thought? The lab released Mini partly so researchers can study that. Its own finding, at this scale, is that looping does not meaningfully reduce monitorability: the chain of thought gets shorter with more loops but stays legible, and the model has very little control over steering its chain of thought — it followed a steering instruction at most 0.1% of the time.
Inkling 2 Mini Pricing Explained
The weights are free to download under Apache 2.0. You pay only when you use the hosted model on Tinker, per million tokens, in US dollars. Tinker’s Models & Pricing page lists:
| Billing item | 64K context | 256K context |
|---|---|---|
| Prefill (input) | $0.15 | $0.15 |
| Cached prefill | $0.015 | $0.015 |
| Sample (output) | $0.50 | $0.50 |
| Train (fine-tuning) | $0.75 | $1.50 |
That is exactly half of Inkling 2 Small’s rates on every meter — Small is $0.30 prefill, $0.03 cached, $1.00 sample and $1.50/$3.00 train. There is no subscription and no published free tier for the model on Tinker.
A worked example: 1 million uncached input tokens and 200,000 output tokens cost $0.15 + $0.10 = $0.25. A longer agent session — 2 million prefill tokens and 200,000 output tokens — costs $0.30 + $0.10 = $0.40. Artificial Analysis, using the same first-party Tinker prices, puts a full Intelligence Index task at $0.59 and 9.0 minutes for Mini, against $3.53 and 38.2 minutes for Qwen3.8-27B — about 6 times cheaper and 4 times faster per task, even though Mini uses about 38% more output tokens per task (~152,000 vs ~110,000), because its per-token price is so much lower.
Two things to know before budgeting. First, Tinker’s serverless inference beta does not include Mini — it covers Inkling and Inkling-Small only — so hosted use means the Tinker sampling and fine-tuning routes. Second, third-party hosts that serve the open weights set their own prices; the $0.15/$0.50 rates are Thinking Machines’ own Tinker prices.
Inkling 2 Mini vs Inkling 2 Small
| Spec | Inkling 2 Small | Inkling 2 Mini |
|---|---|---|
| Released | 5 Nov 2026 | 20 Nov 2026 |
| Total / active parameters | 594B / 17B | 26.4B / 3.4B (5.4B counting loops) |
| Layers | 48 | 24 (middle 12 looped 3x) |
| Weights at launch | Closed | Open on day one |
| Weights now | Apache 2.0 on Hugging Face (since 12 Nov) | Apache 2.0 on Hugging Face |
| Checkpoint size | ~394GB (NVFP4) | ~20GB |
| Hardware to run locally | GPU cluster, 500GB+ VRAM | 32GB Mac / 1x DGX Spark |
| Context | Up to 1M (Tinker 64K/256K) | Up to 1M (Tinker sample 1M) |
| Artificial Analysis Index | 31 | 20.1 |
| SWE-bench Verified | 82.2% | 79.2% |
| DeepSWE v1.1 | 72.1% | 48.2% |
| Terminal-Bench 4.0 | 13.1% | 5.6% |
| Tinker prefill / sample per 1M | $0.30 / $1.00 | $0.15 / $0.50 |
| Best for | Frontier agentic work on Tinker | Local runs, laptop agents, research |
The honest read: Small is still the stronger model — 31 vs 20.1 on the Artificial Analysis index, and ahead on every coding benchmark the lab reports. Mini’s win is access: it is 22 times smaller, its weights were open from day one, and it runs on hardware you may already own. Small’s weights are open now too (since November 12), so “open vs closed” is no longer the difference — size and where it runs is.
Performance and Benchmarks
The Artificial Analysis Intelligence Index score — 20.1 — is an independent evaluation. Artificial Analysis says Mini matches Qwen3.8 27B (xhigh) on the index with about 5 times fewer active parameters, and that it sits on the Pareto frontier for intelligence versus active parameters. Every other score below is Thinking Machines’ own, from its announcement and model card, run with its own harnesses. Treat them as the lab’s best-case numbers, not independent results; nobody outside the lab can re-run most of them, though the open weights make that possible now.
| Benchmark | Inkling 2 Mini | Best rival in TML’s table |
|---|---|---|
| SWE-bench Verified | 79.2% | 77.8% (Qwen3.8-27B) |
| SWE-bench Pro v2 Hard | 77.9% | 73.8% (Qwen3.8-27B) |
| DeepSWE v1.1 | 48.2% | 42.2% (Qwen3.8-27B) |
| Terminal-Bench 2.1 | 71.6% | 73.0% (Qwen3.8-27B) |
| Vals Index v2.2 | 46.5% | 29.8% (Nemotron 3.5 Super VL) |
| Artificial Analysis Index v5.0 | 20.1 | 20.1 (Qwen3.8-27B, tied) |
| BrowseComp | 79.0% | 78.9% (Nemotron 3.5 Super VL) |
| DeepSearchQA | 85.3% | 79.7% (Qwen3.8-27B) |
| MCP Atlas | 82.7% | 77.3% (Qwen3.8-27B) |
| MMMU Pro | 74.9% | 76.3% (Qwen3.8-27B) |
| LongBench v2 | 66.9% | 62.1% (Nemotron 3.5 Super VL) |
| MRCR v2 (8-needle) | 46.4% | 38.0% (Qwen3.8-27B) |
Two more numbers the lab leads with. On energy efficiency, researchers at Stanford’s Hazy Research Lab and Scaling Intelligence Lab measured 0.703 intelligence per watt for Mini running on a DGX Spark at MXFP8 with low reasoning effort, against 0.430 for Qwen3.6-35B-A3B, 0.159 for Gemma-4-26B-A4B and 0.036 for Qwen3.5-27B. And on cost per task, Artificial Analysis puts a full Intelligence Index task at $0.59 and 9.0 minutes for Mini, against $3.53 and 38.2 minutes for Qwen3.8-27B.
The pattern in the table is consistent: Mini leads its size class on agentic coding, tool use and web research, and loses to the same rival — Qwen3.8-27B — on terminal work (71.6% vs 73.0%), visual college questions (74.9% vs 76.3% on MMMU Pro) and factuality-heavy tests. It also trails larger models on reasoning-intensive benchmarks such as CritPt v2 and HLE-Diamond (15.2%).
How to Use Inkling 2 Mini
1. Try it in the Tinker Playground
Create a Tinker account and open the Playground to chat with the model. This is inference-only — good for checking answer quality and how the reasoning-effort setting changes speed and depth.
2. Run it locally with Ollama on a Mac
Any Mac with at least 32GB of RAM can run the model through Ollama, or one NVIDIA DGX Spark. The model card also lists SGLang, vLLM, TokenSpeed, NVIDIA Dynamo and the Llama App, with quantized GGUF versions via Unsloth and llama.cpp. Expect looped-model support in local runtimes to be new — the model card says speed varies by runtime and hardware.
3. Call it through the Tinker API
Sign up on Tinker, create an API key in the console, and call the model as thinkingmachines/Inkling-2-Mini. Tinker offers OpenAI- and Anthropic-compatible endpoints, and its docs include a Cookbook with the tml-renderers package. Sampling is billed at $0.15 per million input tokens and $0.50 per million output tokens.
4. Download the weights from Hugging Face
The repository is thinkingmachines/Inkling-2-Mini — a single checkpoint of about 20GB under Apache 2.0. Serve it with vLLM (vllm serve thinkingmachines/Inkling-2-Mini) or SGLang, or load the GGUF builds for llama.cpp.
5. Fine-tune it on Tinker
Use the Tinker Cookbook to run supervised fine-tuning or reinforcement learning. Training costs $0.75 per million tokens at 64K context and $1.50 at 256K. RL fine-tuning is also supported on SkyRL, Miles and NVIDIA AutoModel.
6. Set guardrails before you let it act
The model card is blunt about agentic reliability: Mini may take destructive actions, such as deleting or overwriting files, without confirmation, and may not report the outcome of its work accurately. Run agent workloads in a sandbox, require confirmation before destructive or irreversible actions, and set limits on output tokens and agent turns — the model sometimes gets stuck in long reasoning loops when debugging code.
Best Uses
- Local coding agents: long coding jobs and debugging on a laptop, where a 20GB model fits and the Tinker price is $0.15/$0.50 per million tokens
- Persistent agents on local hardware: the Stanford energy-efficiency result (0.703 intelligence per watt) is the case for running several agents on one machine, as in the lab’s Thinkyville demo
- Tool use and web research: 82.7% on MCP Atlas and 79.0% on BrowseComp lead its size class
- Fine-tuning experiments: cheap training on Tinker ($0.75 per million tokens at 64K) for teams that want a custom agent
- Research on looped transformers: the variable-loop sibling model and the monitorability findings make it a useful artifact for interpretability work
- Long-context retrieval: long-context scores improve with more loop passes — 66.9% on LongBench v2 and 46.4% on MRCR v2
Limitations and Things to Know
- It is not the strongest small model for chat. The lab says so itself: 50.0% on MultiChallenge and 33.4% on ComplexConstraints v1.1, behind Qwen3.8-27B on both. If you want a polished chat companion, this is the wrong model.
- Knowledge is limited by size. The lab’s own words: looping does not let the weights store more facts. Its score on AA-Omniscience, a factuality measure, is in line with other models of the same size, and the model card says it is less capable than Inkling 2 Small across most evaluations, with the largest gaps on factual recall. It closes the gap by using search and tools efficiently.
- It trails larger models on hard reasoning. CritPt v2 and HLE-Diamond (15.2%) are both behind bigger models, and Terminal-Bench 4.0 is weak at 5.6%.
- It can be destructive without asking. The model card warns Mini may delete or overwrite files without confirmation and may not report outcomes accurately. Sandbox it and require confirmation for irreversible actions.
- It can get stuck reasoning. In internal testing the model sometimes fell into long reasoning loops or repeatedly re-checked its own work without making progress, particularly when debugging code. Set output-token and turn limits.
- English is its best language. Output quality can be lower outside English — in testing in Chinese the lab observed clipped phrasing and mixed languages.
- Setting effort to minimum does not fully disable reasoning. Because the middle layers run three times, compute per token is higher than the active-parameter count alone suggests.
- Local runtime support is new. The model card says support for looped models in local runtimes is new and speed varies by runtime and hardware — expect rough edges outside the supported setups.
- No serverless inference for Mini yet. Tinker’s serverless inference beta covers Inkling and Inkling-Small only.
- All benchmarks except the Artificial Analysis index are vendor-reported. Thinking Machines ran them itself. Independent replication is now possible because the weights are open, but no independent reproduction had been found at the time of writing.
The honest read: Mini is a small model with a big idea, and the idea mostly works — the looping buys real reasoning per token, the 20GB checkpoint runs on hardware people actually own, and the $0.15/$0.50 Tinker price makes it the cheapest way into this lab’s models. The trade is knowledge and polish: it knows less than its bigger sibling, chats worse than Qwen3.8-27B, and needs a sandbox before you let it touch files. If you run agents locally or want to study looped transformers, it is the most interesting small model of the month; if you want the strongest answers and can pay for them, Inkling 2 Small is still the better model.
Frequently Asked Questions
What is Inkling 2 Mini?
Thinking Machines Lab’s looped-transformer AI model, released November 20, 2026. A 26.4-billion-parameter Mixture-of-Experts model (3.4 billion active per token) that runs its middle 12 layers three times per token, reads text and images, and answers in text.
When was Inkling 2 Mini released?
November 20, 2026. The Hugging Face model card lists that date, and the lab’s announcement is “Introducing Inkling 2 Mini”.
Is Inkling 2 Mini the same as Inkling 2 Small?
No. They are different models in the same second generation. Inkling 2 Small (released November 5, 2026) is far bigger — 594 billion total parameters, 17 billion active — and stronger on every benchmark the lab reports. Mini is the small sibling: 26.4 billion total, 3.4 billion active, built to run on a laptop. Small’s weights are also open now (since November 12), so the difference is size and where each runs, not open versus closed.
How much does Inkling 2 Mini cost?
The weights are free to download under Apache 2.0. On Tinker, sampling costs $0.15 per million input tokens, $0.015 for cached input and $0.50 per million output tokens; fine-tuning costs $0.75 per million tokens at 64K context and $1.50 at 256K.
Can I run Inkling 2 Mini on my laptop?
Yes, if it has at least 32GB of memory — any Mac with 32GB or more via Ollama, or one NVIDIA DGX Spark. The checkpoint is about 20GB. Other GPUs need 32GB or more of VRAM.
What is a looped transformer?
A transformer that runs some of its layers more than once per token. Inkling 2 Mini has 24 layers; the middle 12 run three times with shared weights, giving 48 layer applications from 24 stored layers. The extra passes buy more reasoning per token without adding parameters.
How good is Inkling 2 Mini?
It scores 20.1 on the Artificial Analysis Intelligence Index (an independent evaluation, tied with Qwen3.8-27B) and 79.2% on SWE-bench Verified (the lab’s own score). It leads its size class on agentic coding, tool use and web research, but trails Qwen3.8-27B on terminal work and multi-turn chat.
What is the context window?
Up to 1 million tokens, according to the model card. On Tinker, sampling reaches 1M; training contexts are 64K and 256K.
Where can I download the weights?
From Hugging Face, repository thinkingmachines/Inkling-2-Mini, under Apache 2.0. It is a single checkpoint of about 20GB in NVFP4 and MXFP8 precisions.
What is Inkling 2 Mini not good at?
Multi-turn chat and instructions with many constraints (50.0% on MultiChallenge, 33.4% on ComplexConstraints v1.1), factual recall compared with larger models, and terminal-agent work (5.6% on Terminal-Bench 4.0). The model card also warns it may take destructive actions such as deleting files without confirmation, so run it in a sandbox.
Final Verdict
Inkling 2 Mini is the most interesting small model of the month because its headline feature is an idea, not a size: looping the middle layers buys real reasoning per token, and the 20GB checkpoint puts that reasoning on a laptop. The numbers back it up where it counts — 79.2% on SWE-bench Verified, 20.1 on the Artificial Analysis index, $0.59 per index task — and the open Apache 2.0 weights mean anyone can check the lab’s claims. The trade is honest and the lab states it: less knowledge than its bigger sibling, weaker chat, and an agent that needs a sandbox before it touches your files. If you run coding agents locally, want to study looped transformers, or need the cheapest way into Thinking Machines’ models, this is the one to try. If you want the strongest answers and can pay for them, Inkling 2 Small is still the better model — and its weights are open now too.
Editorial update: November 22, 2026. This article is based on Thinking Machines Lab’s November 20, 2026 announcement, the Hugging Face model card for Inkling 2 Mini, Tinker’s Models & Pricing documentation, and Artificial Analysis scores, checked November 22, 2026. Performance claims are Thinking Machines’ own unless marked otherwise, and have not been independently verified by faqsnow.