Early-bird pricing (ends Dec 25), locked in while you stay subscribed: Go $10/mo (normally $20), Plus with Opus 5.5 just $30/mo (normally $50)Subscribe →

Inkling 2 Mini Review: 20GB Model, Real Laptop Speeds

Hosted charts promise 280 tokens per second, but early laptop runs land anywhere from 8 to 220 tok/s depending on hardware and runtime. Inkling 2 Mini is a strong option for offline coding agents, a 26.4B open-weights model in roughly 20GB, yet buyers should know its chat, factuality, and API gaps before downloading.

Who gets value from Inkling 2 Mini, and who should skip

Inkling 2 Mini fits one job well and several jobs poorly, so the workload decides before the benchmark table does. Offline coding assistance with tools and search is its home ground; chat-heavy or API-only use is not.

Your workloadVerdict on Mini
Offline coding agent on a 32GB+ Mac or DGX SparkStrong fit: best reported scores are here
Private long-context work (up to 1M tokens nominal)Worth testing: start at 32K context in practice
Multi-turn chat or strict instruction-followingSkip: Qwen3.8-27B measures better here
Hosted API consumption todaySkip: no serverless listing yet, sampling and fine-tuning rates only

The rest of this review shows the numbers behind that split: what looping changes, which benchmarks survive scrutiny, what local speed looks like in practice, and what the price tag buys.

What Inkling 2 Mini is, and how its loop works

Thinking Machines Lab released Inkling 2 Mini on November 20, 2026 as open weights under Apache 2.0. The weights live on Hugging Face as thinkingmachines/Inkling-2-Mini, accept text and image input, produce text, and list a 1-million-token maximum context.

SpecInkling 2 Mini
ReleaseNovember 20, 2026, Thinking Machines Lab
LicenseApache 2.0
Parameters26.4B total / 3.4B active per token / 5.4B effective with loops
Layers24 stored; middle 12 run 3x per token (6 + 3x12 + 6 = 48 applications)
MoE routing8 of 128 experts per token per layer
PrecisionNVFP4 for 20 layers, MXFP8 for final 4; ~20GB checkpoint (19.5GB + 0.64GB predictor)
Context / modalitiesUp to 1M tokens; text + image in, text out
Local targetsMac with 32GB+ memory via Ollama, or one NVIDIA DGX Spark per the model card

The 3.4B figure describes stored active parameters; counting three loop passes gives roughly 5.4B effective compute. Reused weights keep the file small but increase compute per token, as the Hugging Face technical walkthrough details.

Looping adds compute, not stored knowledge. The launch announcement frames Mini as weaker than larger Inkling models on factual recall because knowledge scales mostly with total parameters, which is why search and tools matter so much for this model.

Thinking Machines' official Inkling 2 Mini announcement page

Benchmarks that hold up, and the ones to discount

All scores below come from the lab's own harnesses via the Hugging Face model card: Mini wins on tool-driven coding and search, ties or trails on reasoning, vision, and chat discipline.

Inkling 2 Mini vs Qwen3.8-27B on six vendor-reported benchmarks

Mini leads DeepSWE v1.1 at 48.2% versus Qwen3.8-27B at 42.2%, SWE-Bench Verified at 79.2% versus 77.8%, BrowseComp at 79.0% versus 61.6%, and MCP Atlas at 82.7% versus 77.3%. Artificial Analysis scores both models at 20.1 on its Intelligence Index, with Mini finishing its index task in 9.0 minutes versus 38.2 for Qwen. ARC Prize reports 84.5% on ARC-AGI-1 and 49.3% on ARC-AGI-2 at the highest reasoning setting.

The other half, per the same model card, is where Mini falls behind: HLE-Diamond 15.2% vs 15.3%, MMMU Pro 74.9% vs 76.3%, Terminal-Bench v2.1 71.6% vs 73.0%. The factuality gap is wider, with AA-Omniscience non-hallucination at 63.4% vs Qwen's 71.4%. ComplexConstraints (33.4%) and MultiChallenge (50.0%) also trail Qwen.

Running it locally is not one number

The official Ollama listing and model card name a Mac with 32GB or a DGX Spark, but early looped-model support makes real speed vary widely. Hosted throughput (280 tok/s on Artificial Analysis) is a poor predictor of laptop throughput.

SetupReported speedSource
Hosted eval (Artificial Analysis)280 tok/sThird-party measurement
RTX 4090, patched vLLM + FP8/NVFP4 + drafter~190-220 tok/sReddit user, post-patch only (117 baseline)
M5 Max MacBook Pro~125 tok/s@alexocheema
M1 Max MacBook Pro 64GB, 4-bit quant~20 tok/sHacker News user gregsadetsky, via eesel's launch review
Early llama.cpp builds, misc hardware~5-10 tok/sr/LocalLLM thread

"Couldn't get it even to 5 t/s." — u/KURD_1_STAN, r/LocalLLM comparison thread

Runtime support and quantization explain much of the spread: current builds handle looped layers better than day-one builds, and quant choice moves the footprint (recommended 4-bit is ~17.6GB plus a 639MB vision projector, per Unsloth's guide via Crewmark) before long contexts add KV-cache pressure.

In one payment-matching test at equal latency, Qwen reached 98.2% accuracy with zero false matches versus Mini at 96.9% with five false matches:

"Tested Inkling 2 Mini vs Qwen3.8-27B on our real payment-matching workload... Qwen: 98.2% acc, 0 false matches... Inkling: 96.9%, 5 false matches... Qwen stays for this job." — @exebat3 (post)

Practical takeaway: start at 32K context, lower it on memory pressure, and confirm your runtime build supports looped layers before judging quality.

The price with no checkout button

Tinker rates as quoted on the Artificial Analysis model page run $0.15 per million input tokens, $0.015 cached, and $0.50 output, with fine-tuning at $0.75 (64K) and $1.50 (256K). Applied to measured token usage, that yields $0.59 per index task versus $3.53 for Qwen3.8-27B.

That $0.59 is an estimate, not a buyable hosted price. Mini appears in no serverless inference listing at review time, a check eesel's review documents against Tinker and OpenRouter. Mini also generated 161M output tokens in the index run against an 85.7M median, so verbosity eats part of the per-token discount. For self-hosting, compare hardware, electricity, and setup costs against a hosted Qwen or frontier API instead.

Two settings that decide whether it works

Reasoning effort runs from none (0.0) through minimal (0.1), low (0.2), medium (0.7), high (0.9, default), to xhigh/max (0.99). Minimum does not fully disable reasoning, per the model card.

Lower can win: in the r/LocalLLM Terminal-Bench discussion, one user's 13-task subset scored 10/13 at low effort while medium effort timed out repeatedly. Separately, a Hacker News tester cited in eesel's review burned 19,200 thinking tokens without tools and did not finish; enabling search produced a solution with the wrong hook name.

Cap output tokens and agent turns, sandbox file-system access, and require human review before production use. The model card warns of destructive actions without confirmation and stuck reasoning loops, especially when debugging code.

The trade-off to accept before you download

Mini gets more compute without a larger checkpoint by reusing its middle layers, and the lab ships a variable-loop research checkpoint for studying that behavior (walkthrough). The reported failure modes are concrete: debugging loops, a user-reported switch into Japanese mid-reply, and tool calls that need a leash. Download it for offline coding with guardrails; wait if you need careful chat or a one-click API.

FAQ

Can Inkling 2 Mini run on a laptop?

Yes, with the right build: a 32GB+ Apple-silicon Mac via Ollama or current llama.cpp, ideally 4-bit (~17.6GB plus projector). Expect ~20 tok/s on an older M1 Max and 100+ tok/s on M5 hardware; unpatched runtimes can crawl at single digits (see table above).

Is Inkling 2 Mini better than Qwen3.8-27B?

For coding agents yes, for chat no. See the chart above: Mini leads DeepSWE, SWE-Bench Verified, BrowseComp, and MCP Atlas; Qwen leads Terminal-Bench v2.1, MMMU Pro, factuality, and constrained instructions. All figures are vendor-reported via the model card.

Why do sources quote both 3.4B and 5.4B active parameters?

3.4B is stored active parameters; 5.4B adds three loop passes at ~1.0B each. Use 5.4B for compute, 3.4B for memory.

Can I call Inkling 2 Mini via a hosted API today?

No first-party serverless endpoint existed at review time. Tinker exposes sampling and fine-tuning rates but no Mini serverless listing, per eesel's check. Run Hugging Face weights locally or wait for hosted coverage.

How do I stop reasoning loops?

Try low (0.2) effort first, cap output tokens and agent turns, and sandbox tools, per the model card.

Related reading: Inkling 2 Small review and API pricing for the 594B sibling Mini answers; Best LLM for coding agents in 2026 to place Mini among agent options; llama.cpp v1.0 guide for the runtime Mini depends on locally.