Inkling 2 Mini Lands on Ollama: How a 5.4B Model Achieves Deep Reasoning

Inkling 2 Mini achieves deep reasoning with small parameters via three middle-layer loops, now available for local running on Ollama.
ThinkyMachines' Inkling 2 Mini is now on Ollama and requires the 0.40.17 pre-release. Its core design cycles each token through the middle layers three times, using "recurrent depth" to gain stronger reasoning with only 5.4B activated parameters while keeping memory usage controllable for local deployment. Official scenarios include coding, agent workflows like computer use, visual design, and finance, with a real-time 2048 demo showcasing interactivity. It runs via two commands on a Mac with 32GB+ memory. The extra computation from looping may raise per-token latency, and complex agent performance still awaits community testing.
ThinkyMachines' Inkling 2 Mini is now available on Ollama. According to the official tweet, users need to upgrade Ollama to the 0.40.17 pre-release version to try it. This model focuses on "small size, deep reasoning" and can run locally on a Mac with 32GB of memory. In the official demo, it can even make real-time decisions while playing the game 2048.

Core Design: Repeating Middle Layers, Trading Loops for Depth
The most striking design of Inkling 2 Mini is that each token cycles through its middle layers three times. This "recurrent depth" strategy lets the model repeatedly process the same set of intermediate representations during inference, thereby achieving deeper reasoning capability with only 5.4B activated parameters.
Traditional approaches often trade stacked parameters for capability, while Inkling 2 Mini's choice is more like compensating for limited parameter scale with repeated computation steps within a fixed compute budget. For local deployment scenarios, this means controllable memory usage while retaining the reasoning depth needed to handle complex tasks.
Activated parameters refer to the number of parameters that actually participate in computation during a single forward inference pass, not the total number of model weights. For Mixture-of-Experts (MoE) architectures, the total parameter count can be far larger than the activated parameter count: each token is routed to only some expert networks, so only the selected experts participate in computation. Activated parameters directly determine the floating-point operations (FLOPs) per inference and the memory/VRAM bandwidth pressure, making them a key metric for inference cost. 5.4B activated parameters means each computation involves roughly 5.4 billion weights, comparable to the computational overhead of a 7B-class dense model, but if its total parameter count is larger, the model capacity can still be substantial. Understanding this distinction helps determine whether "small size" refers to storage footprint, peak VRAM usage, or per-token computation — the three are not equivalent.
Recurrent depth is a computation strategy that lets a model reuse the same set of layers (usually middle layers) multiple times during inference, an idea traceable to work such as the Universal Transformer. Unlike a standard Transformer, where each layer executes only once, a recurrent-depth model iteratively applies the same weights to the same set of hidden states, thereby increasing the effective computational depth without increasing parameter count. This is essentially "trading time for space": the parameter count is fixed, but the number of serial computation steps increases. The cost is that per-token latency grows linearly with the number of loops, and training requires handling the unrolled computation graph (truncated backpropagation can be used to control memory). This design is common in scenarios requiring multi-step reasoning, algorithmic tasks, or iterative refinement.
Built for Real Tasks: Coding, Agents, and Visual Reasoning
Officially, Inkling 2 Mini's applicable scenarios are grouped into several categories: coding, agent workflows (such as computer use), design tasks with strong visual reasoning, and financial scenarios. What these tasks have in common is the need for multi-step judgment and contextual understanding, which aligns precisely with the model's "recurrent reasoning" design orientation.
One detail worth noting is agent scenarios like computer use — the model needs to make real-time decisions in a dynamic interface. The 2048 demo in the tweet is a direct showcase of this capability: the model does not output an answer all at once, but continuously judges direction at each step of operation, ultimately completing the game.
Computer use refers to a class of agent capabilities that let a model directly operate a computer's graphical interface: the model receives screenshots or accessibility trees and outputs actions such as mouse clicks, keyboard input, and scrolling, thereby completing tasks in real software. Unlike calling APIs, computer use requires the model to have visual understanding, interface element localization, state tracking, and error recovery capabilities, and each action changes the environment, forming a closed-loop decision process. Such tasks are latency-sensitive and also place high demands on the model's planning stability — a single misclick can lead to an irreversible state. For this reason, evaluating computer use typically uses multi-step task success rates rather than single-step accuracy. It is also one of the directions in "agent workflows" that is closest to real-world use while most testing reasoning depth.
Local Running: One Command and Pi Integration
After integrating with Ollama, calling Inkling 2 Mini is very straightforward. The official guidance provides two commands:
ollama run inkling-2-mini: run the model entirely locally in Ollama.ollama launch pi --model inkling-2-mini: load the model in the Pi environment.
Regarding hardware requirements, the official statement explicitly says it can run on a Mac with more than 32GB of memory, allowing many individual developers and small teams to experiment with reasoning-oriented models without cloud GPUs. Note that the current version still requires the pre-release version of Ollama for support, and users of the stable release may need to wait for a subsequent update.
Ollama is an open-source tool for running and distributing local large models. Through a unified command-line interface, it pulls model weights, manages quantized versions, and performs inference locally on CPU/GPU. It includes built-in backends for different hardware (such as Metal on macOS) and packages models in quantized form so users can run them without writing inference code by hand. Because Ollama's model library versions and runtime versions have compatibility constraints, new architecture models often require newer runtime support, which is why this article mentions the need to upgrade to the 0.40.17 pre-release version. A pre-release version means the interface and formats may still change, so production use should be carefully evaluated.
The Significance of the Small-Model Deep-Reasoning Path
The release of Inkling 2 Mini reflects a trend: model vendors are starting to focus on "parameter efficiency" rather than simply competing on scale. By trading middle-layer loops for reasoning depth, a model with 5.4B activated parameters can cover logic-heavy tasks such as coding, agents, vision, and finance.
Of course, the extra computational overhead brought by "looping three times" also means per-token latency may increase, which is a trade-off that needs consideration for real-time interactive scenarios. The 2048 demo proves feasibility, but how it performs on more complex agent tasks still awaits community testing. For local deployment enthusiasts, this model offers a new option worth trying.
One-line Summary
Inkling 2 Mini achieves deep reasoning with small parameters through three middle-layer loops, and is now available for local running on Ollama.
Paragraph Summary
ThinkyMachines' Inkling 2 Mini is now on Ollama and requires the 0.40.17 pre-release version. Its core design is that each token loops through the middle layers three times, using "recurrent depth" to gain stronger reasoning capability with only 5.4B activated parameters while keeping memory usage controllable for local deployment. Official target scenarios include coding, agent workflows such as computer use, visual design tasks, and financial applications, with a demo of real-time decision-making in 2048 showcasing interactive capability. Integration is via two commands, and it can run locally on a Mac with more than 32GB of memory. The article also notes that the extra computational overhead from looping may increase per-token latency, and the actual performance on complex agent tasks still awaits community testing.
Related articles

Inkling 2 Mini Released: A New Contender in Small Models?
Thinking Machines releases the small model Inkling 2 Mini, sparking heated discussion in the Hacker News community. This article analyzes the release, community reaction, and the small model trend.

Will GTA VI Be the Last "Purely Human" AAA Blockbuster?
What does calling GTA 6 "the last game of its kind" really mean? This article interprets the video's view: it refers to a historic work built by thousands of people without AI, with the full force of an entire company—not the end of big-budget games—using the Ocarina of Time remake as a counterexample of low cost and high quality.

Fighting AI Code Slop: Formal Verification Is Becoming the New Weapon
AI-generated code creates low-quality "slop." Formal verification, powered by AI and Lean, is moving toward automation, lowering the proof barrier and offering mathematical guarantees of correctness. This article analyzes its value, adoption path, and challenges.