At 30,000 Feet with No Wi-Fi: Coding a 3D Flight Simulator on the Fly
High in the cruising altitude of a commercial airliner, cabin doors sealed and smartphones switched offline, a researcher from Thinking Machines Lab lowered his economy seat tray table. Without an internet connection, he prompted a MacBook Pro to run local code generation. Within minutes, a playable 3D flight simulator complete with aerodynamic physics was running smoothly on screen.
This demonstration marked the November 20, 2026 debut of Inkling 2 Mini, an open-weight model released under the permissive Apache 2.0 license with no commercial restrictions. It delivers a stark counterpoint to industry orthodoxy: architecting complex software no longer strictly demands expensive cloud clusters.
For years, mainstream AI development has relied on sheer physical scale. Tech giants routinely procure tens of thousands of specialized GPUs, burning enormous amounts of electricity in supercomputing data centers. Inkling 2 Mini charts a different course by compressing its memory footprint to around 20GB. Heavyweight reasoning workloads once tethered to server racks now execute reliably on a consumer laptop.
24 Physical Layers Yield 48-Layer Depth: Reusing the Same Set of Weights
The model achieves its high density by fundamentally restructuring the network execution flow. Traditional Transformer architectures operate like a strictly unidirectional conveyor belt: for every generated token, activations pass through each layer exactly once. Inkling 2 Mini breaks this linear sequence with a Recurrent Transformer architecture, routing activations through selected middle layers multiple times.
The model contains 24 physical transformer layers. During token generation, layers 1 through 5 handle initial feature extraction. Subsequently, the intermediate block—spanning layers 6 through 17 (12 layers in total)—is invoked three consecutive times. Finally, the terminal layers synthesize and project the output. In terms of computational depth, this execution path is functionally equivalent to a 48-layer network.
Figure: Architecture schematic: initial layers run once, the middle block repeats three times, terminal layers run once. Source: Thinking Machines Lab
All three recurrent passes reuse the exact same physical weights. The model’s total parameter footprint remains at 26.4B, with initial active parameters at 3.4B. Through three recurrent loops across the intermediate block, the effective active compute per token climbs to 5.4B parameters. The additional computational load manifests as silicon processing time rather than requiring more RAM.
This architectural shift trades compute runtime for memory capacity. Previously, achieving 48 layers of reasoning depth on edge hardware required workstation-grade unified memory or high-end VRAM. Inkling 2 Mini trades time for space, squeezing double the logical derivation depth out of an identical parameter footprint.
Fitting Compute into 20GB RAM: Native Low Precision Without Post-Hoc Truncation
Designing a recurrent architecture is only half the battle; executing fluidly on personal hardware requires overcoming precision hurdles. Typically, open-source models are pre-trained in 16-bit floating point (FP16/BF16) and subsequently quantized down to 4-bit or 8-bit representations. This post-training quantization often truncates sensitive weights, precipitating errors during complex multi-step code derivations.
Inkling 2 Mini avoids post-hoc degradation by adopting native low-precision formats directly during pre-training. The first 20 layers are trained natively in Nvidia’s NVFP4 4-bit floating-point format, while the final 4 layers leverage the microscaling MXFP8 format. Because it is natively low-precision out of the box, no lossy post-conversion is necessary. The total memory overhead for weights is tightly bounded at approximately 20GB.
Figure: Official benchmark chart: decoding speed vs. task success rate. Source: Thinking Machines Lab
This architecture posts impressive numbers across rigorous software engineering and reasoning evaluations. On the challenging DeepSWE v1.1 benchmark for real-world software engineering, the model recorded a 48.2% resolve rate. On the Vals Index v2.2, which evaluates advanced logic reasoning, it achieved 46.5%. Both metrics represent first-place finishes among all open-weight models under 100B parameters.
The open-source community moved quickly to build on these results. Developers developed dedicated quantization compilers that compress the model down to 5.4GB while maintaining lower perplexity than traditional Q4_K_M formats. Running on a Ryzen 395 system with a Vulkan backend, local inference reaches 27 tokens per second; even an older M1 Pro sustains a usable 10 tokens per second. Fully self-contained edge development is now a practical reality.
Concealing Thought in Hidden States: Saving Tokens While Obscuring Safety Oversight
Behind this leap in inference efficiency lies a subtle paradigm shift in reasoning computation. Models like OpenAI o1 rely on explicit chain-of-thought prompting, emitting thousands of human-readable tokens so observers can track their step-by-step logic. Inkling 2 Mini compresses sequential reasoning entirely into internal hidden states, performing deductions without having to generate intermediate text tokens.
Official lab benchmarks highlight this dynamic. Without generating explicit reasoning tokens, the compute time devoted to a single step stretched from 16 seconds on a single pass to 37 seconds across three recurrent cycles. When tackling serial logic puzzles, performance continued to scale upward even when loops were extended to 10 passes. Layer recurrence allows a single emitted token to embody significantly denser reasoning.
Implicit reasoning eliminates the latency of generating voluminous text and drastically cuts token costs. However, it introduces acute challenges for safety oversight. Because deductions occur entirely within high-dimensional vector spaces, external guardrails cannot intercept anomalous or harmful thoughts at the text token layer. While research teams report no elevated malicious tendencies, traditional text-level filtering tools have lost their direct visibility window.
Internal evaluations also highlight clear operational boundaries. When tasked with complex, multi-turn dialogues packed with intricate constraints, the model’s score drops to 50.0% on MultiChallenge and 33.4% on ComplexConstraints. Without external prompt intervention, it occasionally falls into verification deadlocks—spinning compute cycles endlessly without making headway. In multilingual evaluations, its Chinese outputs also exhibited occasional unnatural phrasing and mid-sentence code switching.
Physical Limits of Parameters Remain: Small Models Pioneer New Tactics
Recurrent architectures have definite structural limits. Looping through network layers can amplify the depth of sequential reasoning, but it cannot synthesize new world knowledge out of thin air. Factual knowledge benchmarks show that the model’s factual recall matches standard models of its parameter tier. Parametric memory remains strictly bounded by physical weight volume.
To prevent the model from becoming trapped in self-referential loops during protracted derivations, the lab recommends concrete engineering safeguards. Deployments should enforce hard limits on maximum generation tokens and dialogue turns. These boundaries prevent runaway compute consumption while installing an operational fail-safe. Careful engineering compensates for the architecture’s inherent edge cases.
The real breakthrough of Inkling 2 Mini is demonstrating a viable alternative to brute-force hardware scaling. As developers confront steep hardware bottlenecks and ballooning cloud costs, recurrent layer execution offers an ingenious tactical breakout. How to inspect and interpret hidden states before critical decisions take shape will be the defining puzzle for edge intelligence moving forward.
Reference Links:
- Thinking Machines Lab Official Technical Report
- Hacker News Community Technical Discussion
- DeepSWE Evaluation Benchmark Leaderboard