A 32GB Mac is an ordinary machine. Twenty gigabytes of weights leave twelve for the context window, the runtime and the operating system. That is the entire budget, and it is enough for 26.4 billion parameters.
The model is Inkling 2 Mini, released on November 20 by Thinking Machines, the company founded by Mira Murati. The weights are open under Apache 2.0: downloadable, modifiable, runnable locally. It runs through Ollama on any Mac with 32GB of memory or more, and on Nvidia's DGX Spark. Smaller machines can use GGUF quantized builds from Unsloth and llama.cpp.
Three numbers for one model
Three figures describe its size, and they are not interchangeable.
Total parameters: 26.4 billion. That is every weight in the model, and it is what determines the memory footprint.
Active parameters: 3.4 billion. This is the mixture-of-experts figure. Each token routes through a subset of experts totaling 3.4 billion parameters.
Weight activations per token: 5.4 billion. Because the recurrent blocks run the same weights more than once, total weight activation per token is higher than the number of distinct parameters it touches.
3.4 and 5.4 do not conflict. One counts distinct weights used; the other counts weight calls. Divide 5.4 by 3.4 and you get about 1.59. That extra 59% is the cost of the loop.
24 layers that act like 48
The architecture is a recurrent transformer.
24 layers split into four blocks of six. The two middle blocks run three times for every token; the first and last blocks run once. Six plus 18 plus 18 plus 6 is 48 layers of computation per token, over 24 layers of stored weights.
The same weights are used twice over. This is not a larger model; it is a model used harder. Memory is sized for 24 layers, compute is sized for 48. Layers are the expensive thing to add, since each one costs weights, memory and communication. Recurrence avoids the addition by re-walking what already exists. The cost lands in time, not in memory.
In the Mini, the loop count is fixed.
Under a byte per parameter
20GB of weights across 26.4 billion parameters is about 0.76 bytes each, or roughly 6 bits.
Most weights are trained and deployed natively in NVFP4 at 4 bits, with the final 4 layers in MXFP8 at 8 bits, plus embeddings and runtime overhead pulling the average up. Native low-precision training removes the post-hoc compression step, and with it the compression loss.
Four bits is the first precondition for 32GB. The second is the mixture of experts. Only 3.4 billion parameters activate per token, so the full 26.4 billion never moves through the arithmetic at once. A dense model of the same total size would be far slower on the same memory and chip.
What 32GB actually buys
Twenty gigabytes of weights, 32GB of memory, twelve gigabytes left.
Twelve gigabytes has to hold the KV cache, the runtime and the OS. The spec sheet lists a 1M-token context. The machine has 12GB for everything that is not weights. So 32GB means the weights fit. It does not mean 1M tokens fit. Those two claims get merged into a laptop running a million-token context, and the merge is where the accuracy goes.
Below 32GB, the GGUF builds are a different path: a higher-precision model compressed after training, rather than one trained at 4 bits. The native version is closer to what was released. The quantized version is easier to fit.
The benchmarks, as reported
Two scores: 48.2% on DeepSWE v1.1 and 46.5% on Vals Index v2.2.
Thinking Machines says this leads open-weight models under 100 billion total parameters. The attribution is part of the number. These are vendor-reported results with no third-party reproduction. Benchmark name, version, prompt format, scoring script — change any one and the score moves.
The decode figure is also a ceiling: 614 GB/s at BF16 and batch size 1, computed from memory bandwidth divided by model size. Real throughput loses ground to scheduling and batching.
The switch on the inference side
A variable-loop research release shipped at the same time, and it shows what the recurrence buys.
Without chain of thought, time horizon goes from 16 seconds at one loop to 37 seconds at three, about 2.3 times on the same weights. On a serial reasoning benchmark, performance was still improving at 10 loops, though training used only 3. The switch was not exhausted by training.
That is the real argument for recurrence. Part of the capability sits outside the parameters, in how many times the layers run, and that setting can be changed at serving time. Making a model bigger requires retraining. Looping it more only requires more compute, billed on the inference side, after the checkpoint is frozen.
Chain of thought gets shorter and stays readable: fewer intermediate steps, still followable by a person. What is removed is redundancy, not transparency. But a long chain that fails shows which step broke; a short one often leaves only a wrong answer. The company said the chains got shorter, not by how much.
What the loop does not fix
Thinking Machines states one limitation plainly: on multi-turn chat and constrained instruction following, Inkling 2 Mini trails Qwen3.8 27B.
Those are the two most common uses: keep talking, and keep the output in the required format. Neither depends on thinking longer. Chat depends on remembering what was said. Instruction following depends on not drifting out of a schema. Recurrence helps with neither, and a benchmark lead elsewhere does not cover the gap.
A second trade is recorded alongside. The non-recurrent version saves 7.5% of training compute, but matching loss on 512k-token agentic trajectories costs 140% more inference compute. 7.5% is spent once, before release. 140% is spent on every call.
The 26.4 billion parameters cleared the 32GB line. The multi-turn line is still a gap.
*Disclaimer: This article is based on publicly available information and is for reference only. It does not constitute investment advice.*
