Thinking Machines Lab released the AI model Inkling 2 Mini on November 20, 2026. The model has 26.4 billion parameters and uses a distinctive architecture that runs its 12 middle layers three times, deepening inference-time processing without adding model weights. The weights are released under the Apache 2.0 license, and the model can run on Apple silicon Macs with 32GB or more of memory. In the company's benchmarks, it matches the similarly sized Qwen3.8-27B on overall score and outperforms it at code fixing, but falls behind in business automation, so performance varies by use case.
A distinctive architecture that runs 12 middle layers three times
Inkling 2 Mini's defining feature is its "looped layers," which reuse the same weights. The model processes the input through the first 6 layers, passes through the 12 middle layers three times, and then goes through the last 6 layers to generate the next token. The middle layers use the same weights each time, but the model is not simply repeating the same computation. On each pass, the middle layers refer to the output of the first 6 layers, and on the second and third passes, a learned gate adjusts how much of the previous pass's result is incorporated.
According to Thinking Machines Lab's technical write-up, the model stores weights for 24 layers but performs the equivalent of 48 layers of processing when generating a single token. The breakdown is 6 early layers, 12 middle layers run three times, and 6 final layers:
Normally, adding layers also increases the stored weights, but because this approach shares the middle-layer weights, it deepens processing without storing additional ones. Note, however, that the figure of 48 layers describes the depth of processing needed to generate one token; the model does not hold 48 layers of independent weights.
Inkling 2 Mini also uses a Mixture of Experts (MoE) design, which selects only the needed networks from among many expert networks. Each layer has 128 experts, and 8 are selected to process each token. The total parameter count is 26.4 billion, but the number of parameters active per token is held to 3.4 billion. Each additional pass through the 12 middle layers adds roughly 1 billion parameters' worth of computation, so in the standard three-pass configuration, the total computation including reuse comes to the equivalent of 5.4 billion parameters.
The development team also confirmed that performance depends on which layers are repeated. Comparing a configuration that loops the middle 12 layers with one that loops the final 12 layers, looping the middle layers produced the larger accuracy improvement in 27 of 28 evaluations.
In addition, comparing models with and without looping before the number of experts was reduced, the non-looped model required 7.5% less training compute. However, in an evaluation using 512,000 tokens of agent execution logs, it needed 140% more inference-time compute to reach the same loss. The result suggests that the extra computation from looping may improve inference efficiency.
To fit the released model's size, the company cut the number of experts per layer from 384 to 128 partway through training. It then ran additional training with 1 trillion tokens using a large internal model as a teacher, followed by supervised fine-tuning and 2,000 steps of reinforcement learning, for a total of 2.2 trillion tokens. The final performance reflects not only the looped architecture but also this training approach.
Beats Qwen at code fixing, but falls behind in business automation
Inkling 2 Mini scored 20.1 on Artificial Analysis's "AA Index v5.0," tying the similarly sized Qwen3.8-27B. Individual benchmarks, however, show different strengths. On DeepSWE, which evaluates code fixing, Inkling 2 Mini came out 6.0 points ahead, while on AutomationBench-AA, which evaluates business automation, Qwen3.8-27B led by 6.4 points.
The main evaluation results Thinking Machines Lab published on November 20 are as follows.
| Benchmark (what it evaluates) | Inkling 2 Mini | Qwen3.8-27B | Nemotron 3.5 Super VL |
|---|---|---|---|
| DeepSWE v1.1 (code fixing) | 48.2% | 42.2% | 24.7% |
| SWE-bench Pro v2 Hard (code fixing, 51 tasks) | 77.9% | 73.8% | 44.1% |
| AutomationBench-AA v1.0.6 (business automation) | 41.8% | 48.2% | — |
| BrowseComp (web search) | 79.0% | 61.6% | 78.9% |
| DeepSearchQA (search and research) | 85.3% | 79.7% | 77.7% |
| AA-Omniscience v1.1 (knowledge without external search) | −8.6 | −6.4 | −2.9 |
For the DeepSWE evaluation, "mini-swe-agent v2.4.6" was used as the code-operating agent. For BrowseComp and DeepSearchQA, a process that compresses earlier exchanges was applied. According to the company, evaluation settings differ by model. In the table, "—" indicates the model was not included in the comparison, and AA-Omniscience is scored as an index rather than as accuracy.
In code fixing, Inkling 2 Mini also scored higher than Nemotron 3.5 Super VL, which has 124.5 billion total parameters. Muse Glimmer scored 4.4% on DeepSWE and Gemma 4 31B scored 0.3%, a wide gap from Inkling 2 Mini's 48.2%.
On Terminal Bench, which evaluates terminal operation, however, the model did not show the same advantage as in code fixing. On Terminal Bench v4.0, Inkling 2 Mini and Qwen3.8-27B both scored 5.6%, and on v2.1, Inkling 2 Mini scored 71.6% against Qwen3.8-27B's 73.0%. The ability to rewrite software code and the ability to complete tasks by operating a terminal produced different results.
The same is true of the search-related benchmarks. On BrowseComp, Inkling 2 Mini scored 79.0%, well above Qwen3.8-27B's 61.6% but roughly on par with Nemotron 3.5 Super VL's 78.9%. On AA-Omniscience, which evaluates the model's internal knowledge without external search, Nemotron scored highest and Inkling 2 Mini did not reach Qwen's level. The ability to look up outside information and answer is different from the ability to answer from learned knowledge alone.
Complex instructions and long conversations also remain challenges. It scored 50.0% on MultiChallenge, which evaluates multi-turn dialogue, and 33.4% on ComplexConstraints v1.1, which measures the ability to satisfy multiple conditions at once; the latter is below Muse Glimmer's 35.6%. The developer itself lists handling complex instructions and multi-turn dialogue as weaknesses, and the model card notes that the model can repeat the same checks while debugging code.
Runs on Macs with 32GB or more of memory; demo used a 48GB MacBook Pro
Inkling 2 Mini is a multimodal model that accepts images and text as input and generates text. The distributed weights are about 20GB; in 20 of the 24 layers, expert weights are stored in 4-bit NVFP4 format, and in the last 4 layers in 8-bit MXFP8 format. The developer also used these low-precision formats for expert-layer computation during training.
The official model card lists Apple silicon Macs with 32GB or more of memory and a single NVIDIA DGX Spark as supported environments. On a Mac, the model can be run with Ollama, and for other GPUs, 32GB or more of video memory is recommended.
In the developer's own demo, a MacBook Pro with an M5 Pro and 48GB of memory was used. The model ran in airplane mode with no internet connection and, in a few minutes, built a playable flight simulator.
The stated maximum context length is 1 million tokens. However, in addition to the roughly 20GB of model weights, inference requires memory for intermediate data, the KV cache, and so on. The 32GB operating requirement and whether a 1-million-token input can be handled in the same environment therefore need to be considered separately.
The generation-speed graph the company published also shows a theoretical upper bound rather than values measured on real hardware. It was calculated assuming a memory bandwidth of 614GB/s, model weights in BF16 format, and one input processed at a time. It accounts for re-reading weights during the middle-layer loops, but because the actual model uses NVFP4 and MXFP8, the figure does not directly represent on-device generation speed.
An evaluation that takes power consumption into account is also presented. In a comparison by a Stanford University research team that Thinking Machines Lab cited, "intelligence per joule," which accounts for the energy per problem needed to achieve a given level of performance, was measured on a 128GB DGX Spark.
On this metric, Inkling 2 Mini scored 0.703 in an MXFP8 configuration with reduced inference-time compute. For comparison, Qwen3.6-35B-A3B in NVFP4 format scored 0.430, Gemma-4-26B-A4B in NVFP4 format scored 0.159, and Qwen3.5-27B in INT4 format scored 0.036. All were evaluated on the same DGX Spark, but note that the numerical format used differed by model.
Looping the middle layers cuts reasoning text by more than half
The released standard Inkling 2 Mini has a fixed configuration with three middle-layer loops, but the company also published a research model, "TML-d24-varloop-research," whose number of loops can be changed. It was trained with settings of 1 to 5 loops, centered on 3, so performance can be compared by changing only the number of loops in the same model.
Using GPQA Diamond, a set of difficult science questions, the research team examined the length of the reasoning text the model generates before answering. The comparison was limited to problems answered correctly under all settings from 1 to 5 loops, so differences in the number of output tokens needed to solve the same problems could be evaluated.
The results were as follows.
| Middle-layer loops | Average reasoning tokens |
|---|---|
| 1 loop | 3,703 |
| 3 loops | 1,731 |
| 5 loops | 1,661 |
Increasing from 1 loop to 3 shortened the average reasoning text by about 53%, from 3,703 tokens to 1,731. Increasing from 3 loops to 5, however, shortened it by only 70 tokens. Looping the middle layers shortens the text generated to reach the same correct answer, but beyond 3 loops the improvement is small.
In a test where the model answers without outputting reasoning text, performance gains also slowed around 3 loops. In part of "Think Fast," the time a human needs to solve a problem is used as a measure of difficulty, and the difficulty at which the model's accuracy reaches 50% is examined. With 1 loop, the model handled problems a human could solve in about 16 seconds; with 3 loops, it handled problems equivalent to 37 seconds. After that, performance was roughly flat even as loops increased.
In the research model, increasing the number of loops helped on multi-step reasoning and on tasks that extract information from long text. On knowledge questions without external search, however, changing the number of loops made almost no difference. Whether looping the middle layers helps appears to depend on the nature of the task.
Still, the more the middle layers are looped, the more computation each token requires, so shorter reasoning text does not necessarily mean the answer is finished sooner. How the reasoning-text reduction seen in this research model affects actual response speed will need to be measured on real hardware. For anyone considering use on Apple silicon Macs in particular, it will be important to evaluate accuracy together with time to completion for each kind of task, such as code fixing and search.
