Quick Answer: Inkling 2 Mini is an open-weights Mixture-of-Experts model from Thinking Machines with 26.4B total parameters. It runs its middle layers three times per token, which lets it reason through hard tasks with fewer generated tokens. Its memory footprint is about 20GB, so it can run offline on consumer laptops. It leads comparable open-weights models on DeepSWE v1.1 (48.2%), but it trails Qwen3.8-27B on several other benchmarks.

Most model launches compete on size. Inkling 2 Mini competes on how many times the model thinks before it speaks. As Thinking Machines describes it, the model is small enough to run on a laptop, yet it posts scores that put it near the top of its weight class on agentic coding. The architecture behind that claim is unusual, and it changes how you should judge the model.

How a Looped Transformer Actually Works

Inkling 2 Mini is a looped transformer. Instead of passing each token through every layer once, it runs the middle layers three times for every token. The result is more computation per token without a larger parameter count.

That sounds like a trade-off you'd expect to pay for in speed. The source reports the opposite for the tasks it targets. Because the model reasons inside the forward pass, it can reach the right answer with fewer tokens, and that matters most on work like agentic coding, where reasoning quality drives the result.

The common assumption is that better reasoning requires more visible reasoning: longer chains of thought, more scratch work, more tokens. Looping challenges that. The model does extra work internally, so it doesn't have to write as much down. Here's the catch, though. Hidden computation is harder to inspect, which brings us to monitorability.

The architecture figures in the source are worth reading carefully. Inkling 2 Mini has 26.4B total parameters and 3.4B active per token. Once looping is counted, the source puts effective weight activations per token at 5.4B. Those are different measurements, so don't treat the 3.4B figure as the whole compute story.

Where Inkling 2 Mini Wins and Where It Doesn't

The benchmark table is the strongest part of the announcement, and also the part that needs the most caution. The lab notes that evaluation setups vary by model, so treat these as directional comparisons rather than controlled head-to-head results.

Inkling 2 Mini leads the open-weights models under 100B parameters on DeepSWE v1.1 and several agentic coding tests. It is not the best on everything. Qwen3.8-27B wins Terminal Bench v2.1 and sits just behind on MCP Atlas.

BenchmarkInkling 2 MiniQwen3.8-27BGemma 4 31B
DeepSWE v1.1 (mini-swe-agent)48.2%42.2%0.3%
SWEBench Verified (bash only)79.2%77.8%46.1%
Terminal Bench v2.171.6%73.0%43.4%
BrowseComp (with compaction)79.0%61.6%37.0%
MCP Atlas (public)82.7%77.3%54.2%

The pattern is consistent. Inkling 2 Mini is strongest on long-horizon agentic work and on tasks that combine search with tool use. It's competitive on pure terminal tasks but doesn't dominate them.

Nemotron 3.5 Super VL also appears in the source table, but at 124.5B total parameters it sits outside the under-100B comparison class. Read its scores as context, not as a direct rival.

Most people stop at the headline number. Don't. The useful question is which workload you run. If your work is long agentic coding or search-heavy research, the table favors Inkling 2 Mini. If it's terminal-heavy automation, the margin flips toward Qwen3.8-27B.

Why Looping Changes What Monitoring Means

This is where the architecture gets interesting for anyone who relies on reading a model's chain of thought (CoT). Thinking Machines argues that looping lets a model reason longer without writing its reasoning down, and that this matters for oversight.

To test the effect, the team built a research-specific variable-loop variant and released it alongside Inkling 2 Mini. Its no-CoT time horizon rose from 16 seconds at one pass to 37 seconds at three. Its performance on a serial-reasoning benchmark kept improving out to ten loops, which is twice the depth it was trained with.

Here's the part that matters most for monitoring. As loops increased, the chain of thought got shorter, but the source says it stayed legible. The team also reported no upward trend on tests of agentic sabotage as loops were added.

These results come from a single research variant and a limited set of evaluations, so they don't settle the monitorability question. They do show that adding loops doesn't have to make a model's visible reasoning opaque. If you're building oversight tooling, that's a finding worth testing against your own models.

Running It on Your Own Hardware

The practical headline is memory. Most of Inkling 2 Mini's weights were trained and deployed natively in NVFP4, with the last four layers in MXFP8. The total footprint is about 20GB, which is within reach of a high-memory laptop or a desktop AI machine.

The team demonstrated this on a flight. Researchers ran the model offline on a MacBook Pro (M5 Pro, 48GB) in airplane mode and used it to build a playable flight simulator in a few minutes. The demo video shows real time, with most of the recording sped up 15×, so expect the build to be much slower on your own setup.

Here's the caveat that most speed claims skip. The source's decoding-speed chart is a theoretical ceiling at 614 GB/s memory bandwidth, with BF16 weights and batch size one, including repeated reads across loops. Real throughput depends on your runtime, quantization path, and hardware. Use the chart to compare models against each other, not to predict tokens per second on your machine.

Reasoning Scales, Knowledge Doesn't

Looping improves reasoning. It does not add facts. Thinking Machines says knowledge is mostly a function of total parameter count, and the team's variable-loop experiments support that split.

On long-context benchmarks such as GraphWalks BFS and MRCR v2, performance improved with more passes. On knowledge-heavy tests such as AA-Omniscience, SimpleQA Verified, and WorldVQA, it didn't. Inkling 2 Mini's AA-Omniscience score is in line with other models of its size, not a standout.

So how does it handle questions it can't answer from memory? The source says it compensates with search and tools. It leads open-weights models of similar size on BrowseComp, DeepSearchQA, and MCP Atlas. This is the honest version of the story: if your product depends on the model knowing things, pair it with retrieval. If it depends on finding and acting on information, the architecture fits better.

Choosing Between Inkling 2 Mini and a Dense Model

The real decision is trade-off, not raw score. Inkling 2 Mini gives you more reasoning per token and a small memory footprint. You pay for that with a model whose factual recall is limited by its parameter count, and with hidden computation that's harder to audit directly.

A dense model like Qwen3.8-27B may be the better default if your work is terminal-heavy or if you rely on fast, legible chains of thought. Inkling 2 Mini is the stronger pick when you need long agentic runs, search-heavy research, or a model you can run privately on your own machine.

Here's a useful test before you commit. Run both models on five tasks from your own workload, then compare pass rate, tokens generated, and wall-clock time. Benchmarks won't tell you that.

Frequently Asked Questions

What is Inkling 2 Mini?

Inkling 2 Mini is an open-weights Mixture-of-Experts model from Thinking Machines with 26.4B total parameters. It runs its middle layers three times per token, which is a looped transformer design. The model is built for agentic coding, search, and tool use, and it's small enough to run on a consumer laptop with about 20GB of memory.

How do I run Inkling 2 Mini locally?

Download the open weights and run them on a machine with roughly 20GB of available memory. The weights are deployed natively in NVFP4, with the last four layers in MXFP8. The source also notes the model is available on Tinker for inference and customization, which is an alternative if your hardware is limited.

Why does looping help a model reason better?

Looping gives the model more computation per token by running the middle layers repeatedly, so it can work through a problem internally. That can reduce the number of tokens needed to reach an answer. Thinking Machines' variable-loop tests showed the chain of thought got shorter as loops increased, while staying readable.

Is Inkling 2 Mini better than Qwen3.8-27B?

It depends on the task. Inkling 2 Mini leads on DeepSWE v1.1 (48.2% vs 42.2%), SWEBench Verified, and BrowseComp. Qwen3.8-27B scores higher on Terminal Bench v2.1 (73.0% vs 71.6%) and MCP Atlas. Run both on your own tasks before choosing.

Inkling 2 Mini shows that a model's reasoning depth doesn't have to come from more parameters or more visible tokens. Download the weights, run one agentic coding task you already know the answer to, and note the pass rate and tokens used. Then pass this to someone who needs a private model for long agentic work on a laptop.