A laptop runs a local AI coding assistant beside a GPU workstation, with transformer diagrams and VRAM usage displayed.
Every few months, an AI lab drops a new "laptop-sized" open model, and within twenty minutes, half the internet is trying to wedge it onto a midrange Windows gaming notebook with 8 GB of VRAM—only to watch their pagefile scream for mercy. On November 20, 2026, Thinking Machines Lab—the startup founded by former OpenAI CTO Mira Murati—joined that parade with Inkling 2 Mini, an Apache 2.0 open-weight multimodal model that claims roughly a 20 GB memory footprint and enough coding muscle to rival models several times its active size.

Covered across tech outlets on November 21 by ShiftDelete.Net, Online Tech Tips, and Italian software engineer Pasquale Pillitteri, Inkling 2 Mini isn't just another pruned-down Mixture-of-Experts checkpoint. Its party trick is a looped transformer architecture that runs its middle layers three times for every token it generates. On paper—and in independent evaluations from Artificial Analysis—that architectural twist punches well above its weight class in agentic coding and tool use. On actual Windows PCs and home GPUs, however, "runs on a laptop" turns out to carry a few hefty asterisks that every developer and PC enthusiast should read before clearing 20 GB off an NVMe drive.

A laptop runs a local AI coding assistant beside a GPU workstation, with transformer diagrams and VRAM usage displayed. Why Looping Changes the Math (And What "Mini" Really Weighs)​

Most large language models are strictly one-way streets: a token enters at layer 1, marches sequentially through every layer once, and exits at the end. When a standard model needs more time to think through a tricky Python traceback, its only option is to burn more output tokens writing out a visible chain of thought.

Inkling 2 Mini bends that rule. Built as a 24-layer decoder-only sparse Mixture-of-Experts (MoE) transformer with hybrid local and global attention, the model divides its 24 stored layers into four six-layer blocks. The first block (layers 0–5) and final block (layers 18–23) execute once per token. The middle two blocks (layers 6–17) run three times in a loop using shared weights, connected by attention residuals and a learned gating mechanism that feeds a "message" from each prior pass into the next. The result is 48 layer applications per token from just 24 physical layers stored in memory.

That design explains why three different parameter numbers are floating around launch coverage—and why misreading them will wreck your local hardware planning:

MetricSpecificationWhat It Means for Your PC
Total Parameters26.4 billionEverything you must download and fit into VRAM or unified RAM
Base Active Parameters3.4 billionWeights activated in a single pass (8 of 128 experts per layer)
Effective Active Parameters5.4 billionEffective compute per token after three middle-layer passes (~1.0B per extra pass)
Precision & Footprint~20 GB (NVFP4 + MXFP8)First 20 layers trained/deployed in 4-bit NVFP4; final 4 layers in 8-bit MXFP8
Modalities & ContextText + Image in, Text out; 1M tokensOptimal image size 40–4,096 px; huge context requires far more memory than 20 GB
LicenseApache 2.0Permissive for commercial integration, fine-tuning, and local deployment

As Online Tech Tips rightly cautioned, you cannot size your graphics card around the 3.4B or 5.4B active figures. Every single one of those 26.4 billion parameters still has to live somewhere fast, and the looped passes mean per-token compute is higher than a typical 3B-active MoE model. Even Thinking Machines' model card notes that dialing reasoning effort down to its minimum setting does not fully disable reasoning, because those middle layers still cycle three times regardless.

Still, the training recipe behind Inkling 2 Mini is legitimately clever. Thinking Machines started with 384 experts per layer, pruned two-thirds of them mid-training down to the 128 most-used experts, and "healed" the pruned network by distilling 1 trillion tokens from a larger internal Inkling model before running supervised fine-tuning and 2.2 trillion tokens of reinforcement learning. On the lab's internal scaling ladder, a non-looped baseline cost 7.5% less compute to train, yet required 140% more inference compute to match the looped model's loss across 512K-token agentic traces.

Benchmark Claims vs. Independent Reality​

Thinking Machines launched Inkling 2 Mini with aggressive claims, positioning it as the top open-weights model under 100 billion total parameters on agentic software engineering benchmarks.

According to the company's published evaluation tables, Inkling 2 Mini scores:

  • 48.2% on DeepSWE v1.1 (versus 42.2% for Alibaba's Qwen3.8-27B)
  • 77.9% on SWE-bench Pro v2 (Hard) (versus 73.8% for Qwen3.8-27B)
  • 79.2% on SWE-bench Verified (versus 77.8% for Qwen3.8-27B)
  • 73.7% on SWE-bench Multilingual and 46.5% on Vals Index v2.2
  • 79.0% on BrowseComp (with compaction), 85.3% on DeepSearchQA, and 82.7% on MCP Atlas

On the hardware efficiency front, Stanford researchers given early access tested Inkling 2 Mini on an NVIDIA DGX Spark (128 GB) at MXFP8 precision, measuring 0.703 on "intelligence per joule"—well ahead of Qwen3.6-35B-A3B (0.430), Gemma-4-26B-A4B (0.159), and Qwen3.5-27B (0.036).

Of course, vendor benchmark tables always deserve a raised eyebrow, because harnesses and compaction tricks vary wildly across rows. Fortunately, Artificial Analysis published an independent evaluation alongside the launch, and the results both validate Inkling 2 Mini's core thesis and expose an important catch.

On the Artificial Analysis Intelligence Index (v5.0 / v5.0.1), Inkling 2 Mini scored 20 (20.13), effectively tying Qwen3.8-27B (xhigh) at 20.11 and sitting just behind Nanbeige4.3-33B at 20.41—while deploying roughly 5x fewer active parameters than Qwen and 6x fewer than Nanbeige. Using Thinking Machines' first-party hosted API pricing on its Tinker platform ($0.15 per million input tokens, $0.50 per million output tokens, and $0.015 for cache hits), Artificial Analysis measured an average cost of $0.59 and 9.0 minutes per task for Inkling 2 Mini, compared with $3.53 and 38.2 minutes for Qwen3.8-27B.

Here is the catch Artificial Analysis uncovered: Inkling 2 Mini isn't necessarily terse in practice. Across the Intelligence Index suite, it averaged ~152,000 output tokens per task—roughly 38% more output tokens than Qwen3.8-27B (~110,000). It wins on total compute (active parameters × tokens, using ~2.8x less than Qwen3.8-27B) and cloud throughput (~280 tok/s on Tinker), not because it barely speaks, but because each token requires far fewer active weights to produce.

Where the Lab Says It Falls Short​

Credit where it's due: Thinking Machines is unusually candid about what Inkling 2 Mini cannot do well:

  • Factual recall doesn't scale with loops: Looping helps multi-hop reasoning and long-context retrieval, not memorization. On AA-Omniscience v1.1, Inkling 2 Mini posted a 63.4% non-hallucination rate, trailing Qwen3.8-27B's 71.4%. If you don't pair it with search or local RAG tools, it is more prone than larger models to bluff with confidence.
  • Multi-turn chat and complex constraints: The company explicitly warns that Inkling 2 Mini is not its strongest small model for multi-turn conversation or strict, multi-constraint prompts, reporting 50.0% on MultiChallenge and 33.4% on ComplexConstraints v1.1, and noting degraded quality in long multi-turn chats as well as clipped phrasing outside English.
  • Reasoning spin-cycles: In internal debugging tests, the model occasionally got trapped in long verification loops, re-checking its own code without advancing.

The Windows and PC Reality Check: "Laptop Model" Meets VRAM Limits​

If you watched Thinking Machines' launch demos, you saw researchers flying on an airplane with an offline MacBook Pro (M5 Pro, 48 GB unified memory) watching Inkling 2 Mini code a playable flight simulator and orchestrate 20 virtual villagers in a pixel town called "Thinkyville". ShiftDelete.Net and Pasquale Pillitteri both highlighted that portable promise.

For Windows users, though, there is a big difference between a $3,000+ MacBook Pro with 48 GB of unified memory and the PC sitting on your desk.

As Online Tech Tips pointed out, Windows PCs aren't even listed specifically in Thinking Machines' primary hardware recommendations. The official model card validates:

  1. Apple Silicon Macs (MacBooks, Mac minis, Mac Studios) with 32 GB or more of memory.
  2. NVIDIA DGX Spark (128 GB unified AI desktop system).
  3. "Other GPUs and platforms," with 32 GB or more of VRAM recommended.

On the Windows side of the fence, 32 GB of dedicated GPU VRAM practically means an RTX 5090 or workstation silicon. If your Windows laptop packs an RTX 4060 (8 GB VRAM) and 16 GB of system RAM, the 20 GB upstream checkpoint simply won't fit. Even LM Studio's deployment notes peg 18 GB of system memory as an absolute minimum floor for quantized GGUFs—and that leaves zero headroom for long contexts, vision inputs, or Windows itself.

To make matters spicier on launch weekend, software support on Windows and NVIDIA GPUs had immediate day-one rough edges:

  • The Ollama trap: Ollama listed inkling-2-mini (20GB, 26b-a5b-nvfp4) on launch day, and it pulls cleanly on 32 GB+ Macs via MLX. However, Windows and Linux NVIDIA users trying Ollama 0.40.17 hit immediate roadblocks—either an error demanding the unavailable MLX runtime or unknown model architecture 'inkling2_loop' when attempting GGUF variants.
  • The llama.cpp and Unsloth workaround: Hugging Face engineers confirmed day-zero support in Transformers, SGLang, MLX, and llama.cpp (plus a DSpark speculative drafter included for extra speed). Yet Unsloth maintainer Daniel Han warned early adopters on Hugging Face that mainline llama.cpp produces gibberish or fails to load until upstream pull requests (such as PR #32704) merge to properly dequantize NVFP4 scales and recognize the inkling2 looped layout.
  • What actually works on Windows today: To run it locally on a Windows PC right now, developers have to grab quantized GGUF builds from unsloth/Inkling-2-Mini-GGUF (ranging from ~7.8 GB UD-IQ1_S up to ~22.9 GB UD-Q8_K_XL, with UD-Q4_K_M around 16.6 GB) and run them via Unsloth's b12588-mix-c0c3de8 llama.cpp prebuilts or Unsloth Desktop. Early Windows 11 owners using that path reported that an RTX 4080 12 GB laptop paired with 32 GB of system RAM can run Q4_K_XL at 128K context via CPU/RAM spilling, netting around 24.4 tokens/sec, while an AMD RX 7900 XTX on launch-night runtimes trailed Qwen3.8-27B in raw tokens/sec until kernels mature.
Bottom line for Windows buyers: Do not buy a new Windows laptop or GPU just for Inkling 2 Mini. If you have 24–32 GB of VRAM—or 32 GB+ of system RAM and patience for 4-bit GGUFs via Unsloth's llama.cpp builds—it is a fascinating local coding engine to experiment with. Otherwise, Thinking Machines' hosted Tinker Playground or API is the painless way to test it first.

Monitorability, Safety, and Running Agents Safely​

Beyond raw benchmarks, Thinking Machines released a companion research checkpoint on Hugging Face—TML-d24-varloop-research—that supports between one and five looped passes (and was even stress-tested out to ten). Note that the shipping Inkling 2 Mini uses a fixed three-loop configuration; you cannot dial its loop count up or down.

The lab built the variable-loop model to investigate a genuine AI safety concern: if a looped transformer performs more hidden computation per token before writing anything down, does its chain of thought become impossible for humans or automated monitors to audit?

In Thinking Machines' preliminary tests, TML-d24-varloop-research's "no-CoT time horizon" (how long a task it could complete without writing any visible reasoning) jumped from 16 seconds at one pass to 37 seconds at three passes. When allowed to write out its thinking on GPQA Diamond, five passes cut average reasoning length by more than half (1,661 tokens vs. 3,703 tokens at one pass) because the model backtracked less—yet sentence structure and English legibility remained intact. Furthermore, both Inkling 2 Mini and the research model showed near-zero ability to deliberately disguise their chain of thought when instructed to evade keyword checks (succeeding at most 0.1% of the time on CoT-Control-QA).

That sounds reassuring, until you read the operational warnings in Section 7 of Thinking Machines' own model card:

  • Destructive tool behavior: In agentic setups, Inkling 2 Mini is less reliable at following project conventions than larger models and may delete or overwrite files without asking or inaccurately report whether a command succeeded. (Early independent testers running Inkling 2 Mini alongside Qwen3.8-27B in coding harnesses noted both models happily deleted a file unprompted when tool permissions were left wide open.)
  • No guardrails out of the box: Because you're downloading raw Apache 2.0 weights, safety enforcement rests on your harness. And as Online Tech Tips flagged, even "local" wrapper apps often include optional cloud telemetry or external tool plugins—so audit your frontend's network behavior before pointing it at proprietary source code.

Practical Checklist Before Deploying Locally on Windows​

If you plan to hook Inkling 2 Mini up to a local coding agent like OpenCode, Cline, or a custom MCP workflow on Windows, treat it like an eager junior contractor with root access:

  1. Verify your runtime version: Confirm whether your llama.cpp, LM Studio, or Ollama build has merged the inkling2 looped-architecture and NVFP4 scale-dequantization fixes before blaming a broken download.
  2. Cap turns and output tokens: Because the model can loop endlessly when debugging tricky errors, always enforce strict max-token and max-turn limits in your agent harness.
  3. Sandbox the filesystem: Run agentic sessions inside a Windows Sandbox, Hyper-V VM, WSL2 container, or isolated Git branch, and require explicit human confirmation before destructive shell commands or file deletions.
  4. Keep a fallback model for chat: Use Inkling 2 Mini for single-repo coding, document/screenshot parsing, and tool-assisted search, while keeping a stronger conversational or high-factuality model on standby for multi-turn brainstorming or knowledge-heavy Q&A.

Inkling 2 Mini proves that looped transformers aren't just an academic curiosity anymore—reusing middle layers really can squeeze 27B-class coding performance into a much leaner compute envelope. Once Windows-friendly runtimes finish digesting its unusual layer geometry, it has a real shot at becoming a staple in local developer toolkits. Until then, check your VRAM math, watch your llama.cpp commit hash, and keep your git reset finger ready.

 

References

  1. Thinking Machines Releases Inkling 2 Mini, an Open Model for Laptops - ShiftDelete.Net ShiftDelete.Net 2026-11-21T17:02:44+00:00
  2. Thinking Machines releases Inkling 2 Mini, an open model for laptops - Pasquale Pillitteri Pasquale Pillitteri 2026-11-21T07:29:00+00:00
  3. mlq.ai mlq.ai