A generated title card reading 'Inkling 2 Mini', subtitled 'Same Intelligence Index score as Qwen3.8-27B, at a sixth of the cost per task', with four rounded cards reading Intelligence Index 20.1, cost per index task 0.59 dollars, output speed 280 tokens per second, and checkpoint 20GB Apache 2.0. The OrcaRouter logo sits bottom-right.
Guides & Insights

Inkling 2 Mini: Same 20 as Qwen3.8-27B, a Sixth the Cost

Author

jinhao.song

Date Published

Latest models · 20View all models →
Benchmarks: Artificial Analysis · updated daily
Back to all posts

Two models sit on the same rung of the Artificial Analysis Intelligence Index, both scored 20. One of them costs $3.53 to complete a single index task and takes 35 and a half minutes to do it. The other costs $0.59 and takes nine minutes. The cheaper one is Inkling 2 Mini, a 26.4B-parameter mixture-of-experts model Thinking Machines Lab published on 20 November 2026 under Apache 2.0, and the expensive one is Qwen3.8-27B — a dense model A​libaba shipped in August and which OrcaRouter serves at $0.33 in and $2.40 out per million tokens.

A tie on a composite index is not a tie on capability, and this piece is going to spend most of its length on where the two diverge. But the cost figure is the one that decides whether you put a model in a production path, and it is the number most launch coverage of Inkling 2 Mini will skip, because it is not in the launch post. It comes from the independent measurement, and it is six times better than the model it ties.

What actually shipped, and what did not

The announcement is dated 20 November. The Hugging Face repository was created on 17 November and last modified on the 20th, which is the shape of a checkpoint staged before a launch rather than a surprise drop. The card claims Apache 2.0 and the file listing carries the same tag — a real licence, not a promise of one, which is the difference between this release and Inkling 2 Small's, where the weights trailed the announcement by a week.

The artefact itself:

• Parameters — 26.4B total, 3.4B active, and 5.4B effective weight activations per token once looping is counted. Thinking Machines puts the gap at roughly 1.0B extra active parameters per loop pass.

• Footprint — about 20GB in mixed NVFP4 and MXFP8, small enough that the company ran it offline on a MacBook Pro and ships instructions for any Mac with 32GB of RAM or more.

• Modalities — text and images in, through a vision transformer projected into the same hidden space; text out only.

• Runtime support — SGLang, vLLM, NVIDIA Dynamo, TokenSpeed, Ollama, llama.cpp via Unsloth GGUFs. RL post-training on SkyRL, Miles and NVIDIA AutoModel.

• Hosted availability — Tinker, for inference and fine-tuning. That is the only endpoint. It is not on OrcaRouter and this piece will not pretend otherwise.

One precision point on price, because the independent page and the rate card look like they disagree and do not. Artificial Analysis lists $0.15 per million input and $0.50 per million output, with a 90% cache discount and a blended $0.0905. Those are Tinker's sampling rates — prefill $0.15, cached prefill $0.015, sample $0.50 — and Tinker's own model list still prices a 64K context tier and a 256K tier at the same $0.15/$0.50 for sampling, with training at $0.75 and $1.50 respectively. What Tinker does not list Mini under is the serverless inference beta, whose table covers Inkling 2 Small and the original Inkling but not this model. So the $0.15/$0.50 is what you pay to sample it on Tinker, and the "available via API through 1 provider" line on the analysis page is that, not a serverless endpoint with its own rate card.

Screenshot of the Thinking Machines announcement page titled 'Introducing Inkling 2 Mini', dated Nov 20, 2026, showing the Capabilities, Try on Tinker, Hugging Face and Model card links, section navigation for Architecture and training, Monitorability of looped transformers and Try Inkling 2 Mini today, and the opening paragraphs describing a looped transformer that runs the middle layers three times per token and leads open-weights models under 100B total parameters on DeepSWE v1.1 at 48.2% and Vals Index v2.2 at 46.5%.

Why the loop architecture is the whole point

Everything else about the model is conventional. The loop is not, and it explains both the cost figure and the model's weaknesses, so it is worth two minutes.

Inkling 2 Mini is a 24-layer decoder-only transformer with sparse mixture-of-experts feed-forward layers, organised into four blocks of six layers. The first block and the last block run once. The two middle blocks run three times with shared weights, so each token is pushed through 48 layer applications drawn from 24 stored layers. Between passes, a learned gate merges the previous pass's "message" into the next through attention residuals, so the repeat is not an identical computation — the model carries state forward.

The experts came from a pruning rather than from scratch. Training began at sparsity 48, picking 8 experts out of 384; the company then kept the 128 experts per layer that saw the most traffic and healed the damage on 1T distilled tokens, before SFT and RL over 2.2T tokens in 2,000 steps. It was trained end to end in 4-bit, with 20 layers in NVFP4 and 4 in MXFP8, which is why the shipped checkpoint is the trained precision and not a post-hoc quantisation of it.

Why any of that matters to a buyer: effective compute per stored parameter goes up, so a 26B checkpoint behaves like something larger while occupying laptop memory. Why it matters to an operator: support for looped architectures is roughly one day old. SGLang's support landed as PR #51926, opened the same day the model shipped, adding a dedicated model type, flags for loop passes and cache sharing, and NVFP4 grouped-GEMM paths that zero-pad 1152-wide expert matrices out to 1280 to fit the kernel, benchmarked on GB300, B300 and H200. The model card says it plainly in its own limitations: "looped-model runtime support is new, so speed varies." That is an honest warning and it is the one operational risk unique to this release.

Tied at 20, six times apart on cost

The Intelligence Index comparison is the reason this model is interesting, and it is also where a reader is most likely to be misled by the headline. Both models score 20 on version 5.0 of the index. On everything underneath that score, they are not the same model.

• Index — 20.1 for Inkling 2 Mini, 20 for Qwen3.8-27B in its xhigh effort setting. Effectively level.

• Cost per index task — $0.59 against $3.53. A factor of six.

• Wall-clock per index task — 9.0 minutes against 35.5 minutes.

• Output speed — 280 tokens per second against 51.

• Time to first token — 9.72 seconds for Mini; the Q​wen page does not lead with a first-token figure, and its 35-minute task time is the operative number.

• Context — 1M on the model card and on Artificial Analysis; 256K in Tinker's model list. More on that below.

• Licence — Apache 2.0 and downloadable at 20GB, against a vendor API at $0.50/$3.00 list.

The verbosity explains part of the six-times gap and is worth knowing because it predicts your invoice better than the rate card does. To complete the index run, Inkling 2 Mini emitted 161M output tokens against a peer median of 85.7M — roughly 1.9 times the output of a typical model in its class. Even so, at $0.50 per million output the arithmetic still lands at $0.59 per task. Qwen3.8-27B's cost comes from the other direction: a $3.00 output rate and a model that takes four times as long to finish.

There is a caveat that belongs next to those numbers rather than after them. The index score of 20 is close to the floor of what the leaderboard measures usefully, and models clustered between 18 and 20 are not reliably ordered by it — the leaderboard around Mini includes Nanbeige4.3-33B at 20, JT-4.1 Flash 236B A21B at 19, MiniMax-M3 at 19. A tie at 20 is a statement that both models clear the same bar, not that they fail in the same places.

A generated two-column scoreboard titled 'Inkling 2 Mini vs Qwen3.8-27B - the scoreboard'. The Inkling 2 Mini column reads Intelligence Index 20.1, active parameters 3.4B of 26.4B total with 5.4B effective, cost per index task 0.59 dollars, time per index task 9.0 minutes, output speed 280 tokens per second, and a claimed 1,000,000-token context. The Qwen3.8-27B column reads Intelligence Index 20, 27B dense with all parameters active, cost per index task 3.53 dollars, time per index task 35.5 minutes, output speed 51 tokens per second, and 262,144 native context extensible to one million. A footer states that index, cost, time and speed figures are measured by Artificial Analysis and context figures are vendor-reported.

Coding is where the vendor numbers get interesting

Thinking Machines is selling this as an agentic coding model that runs on a laptop, and the published table supports the first half of that claim more strongly than most small-model launches do. These are the company's own evaluations, unreproduced by anyone outside the lab at the time of writing, and they should be read as claims rather than as measurements.

• SWE-bench Verified — 79.2%, bash only.

• SWE-bench Pro v2, Hard — 77.9%.

• SWE-bench Multilingual — 73.7%.

• Vibe Code Bench v1.1 — 77.9%.

• Terminal Bench v2.1 — 71.6%, behind Qwen3.8-27B's 73.0.

• DeepSWE v1.1 — 48.2%; FrontierCode v2.0 — 15.1%; Terminal Bench v4.0 — 5.6%.

• BrowseComp — 79.0%; DeepSearchQA — 85.3%; MCP Atlas — 82.7%.

• MMMU Pro — 74.9%; OmniDocBench v1.6 — 92.8%; ScreenSpot Pro — 76.5%, or 87.7% with Python tooling allowed.

• GPQA-style science and hard reasoning — HLE-Diamond 15.2%, CritPt v2 31.4%, ARC-AGI 84.5% on v1 and 49.3% on v2.

The pattern inside that table is consistent with the architecture: the rows where Mini looks strong reward persistence and tool use over long horizons, and the rows where it looks weak are the ones demanding a single correct recall or a hard scientific inference. That is what a small active-parameter budget buys and what looping does not fix.

Two of the comparison rows the company printed against Qwen3.8-27B are losses, and they are the two to remember. MultiChallenge — 50.0% for Mini, behind the Q​wen model. ComplexConstraints v1.1 — 33.4%, also behind. These are instruction-following-under-constraints tests, which is exactly the skill that breaks a production agent that has been given a schema and a budget, and it is the first thing to test before trusting either benchmark headline.

What it is bad at, in the company's own words

The limitations section of the model card is unusually specific, which makes it more useful than the usual disclaimer. Quoting it is the fastest way to know whether this model fits your use case.

• It is weaker than Inkling 2 Small on factual recall and is described as prone to stating incorrect information with confidence. The independent omniscience measurement agrees: AA-Omniscience −8.6 with a 63.4% non-hallucination rate. Negative scores on that benchmark mean the model is worse than saying nothing.

• It can get stuck in long reasoning loops, especially while debugging code, and the card recommends token and turn limits.

• It may take destructive file actions without confirmation and may misreport what it did. For anyone pointing it at a repository, that is the sentence that decides whether you run it in a sandbox.

• Non-English output is weaker; the company's own Chinese-language testing found clipped phrasing and mixed languages.

• Minimum reasoning effort does not fully disable reasoning, so you cannot buy latency back by turning thinking off.

The safety evaluation is the part that will get quoted, and it cuts in an interesting direction. FORTRESS scored 89.5% adversarial and 96.4% benign, StrongREJECT 97.8%, internal misbehaviour 9.8%. The company's conclusion is that the model "does not give material uplift beyond what is already available from open-weights models," and it notes it found very little controllability over the chain of thought but no increase in monitorability loss from adding loop passes. Given that the artefact is a 20GB Apache 2.0 download, the safety framing is not a gate — it is a disclosure, and the mitigation it recommends is sandboxing agentic workloads, which is what you should be doing regardless.

The 1M window you may not actually get

Context length is the one specification where the sources genuinely disagree, and the disagreement is not cosmetic.

The Hugging Face card says the model "supports a context window of up to 1M tokens." Artificial Analysis records 1M. Tinker's model list describes Inkling 2 Mini as a 26.4B-total, 5.4B-active MoE with a 256K context, and its rate card prices a 64K tier and a 256K tier.

The most likely reading is that 1M is a capability of the architecture and 256K is what the hosted sampling path is configured and billed for — which is the same pattern Inkling 2 Small showed, where 1M was trained and evaluated but the servable tier was narrower. If your workload depends on the long window, do not take the card's number as an operational guarantee. The long-context evals in the vendor table are also mixed rather than triumphant: MRCR v2 at 46.4%, LongBench v2 at 66.9%, GraphWalks BFS at 256K at 69.7%. A model that advertises a million tokens and scores 46 on multi-round coreference is a model whose long window is real but not free.

Running it yourself, and what that changes

The interesting thing about a 20GB Apache 2.0 checkpoint with 3.4B active parameters is that the marginal cost of an experiment drops to nearly zero. On Tinker you pay $0.15 per million prefill and $0.50 per million sample. On your own hardware — a Mac with 32GB, or a DGX Spark, where the company reports 0.703 intelligence per watt — you pay for the machine and nothing else.

That is the case for self-hosting it, and there is a matching case for not. A brand-new looped architecture has one day of SGLang support, variable throughput depending on which runtime you pick, a documented tendency to loop while debugging, and a documented tendency to run destructive commands without asking. Betting a production path on that in week one is not a routing decision, it is a bet on a runtime.

This is the shape of problem a router is built for, and it is worth being concrete about what that means here rather than gesturing at it. Inkling 2 Mini is not on OrcaRouter, so there is nothing to route to it today. What is on OrcaRouter is the model it ties: Qwen3.8-27B, at $0.33 per million input and $2.40 per million output — cheaper than A​libaba's $0.50/$3.00 list, with the provider's list price passed through rather than marked up. The practical arrangement for the next few weeks is to call Qwen3.8-27B for anything production-shaped while you evaluate Mini on your own metal, and to use failover and the routing DSL to put Mini behind a fallback the day it reaches a hosted endpoint. That is how you get a look at an unproven architecture without making it the only thing standing between your users and an error page.

Screenshot of OrcaRouter's model page for Qwen3.8-27B, showing the model id qwen/qwen3.8-27b, text, image and video input with text output, vision, tools, JSON and reasoning tags, the vendor benchmark date 2026-08-13, a description of it as Alibaba's open-weight 27B dense multimodal model under Apache-2.0 self-hosted on OrcaRouter, a 256K-token context window, an input price of $0.33 and output price of $2.40 per 1M tokens, a p50 of 3.23 seconds and a p99 of 10.00 seconds, and a seven-day traffic figure of 166.6M tokens.

What to watch next

Three things will decide whether Inkling 2 Mini ends up mattering beyond a good benchmark table.

The first is independent reproduction. Every coding number in this piece is vendor-reported. Artificial Analysis has the index score, the cost, the speed and the verbosity — all measured — but not a coding index for this model, and until someone outside Thinking Machines runs SWE-bench Pro v2 or Terminal Bench on the released weights, the 77.9% is a claim about a checkpoint the company trained.

The second is runtime maturity. The gap between 280 tokens per second on the analysis page and whatever you get on your own hardware is currently a function of which engine you pick and how new its loop support is. A month of kernel work changes that number more than a month of anything else.

The third is whether anyone besides Tinker serves it. A single-hosted-endpoint model with open weights is a different product from one with three providers behind a common API, and the price competition that makes the $0.59 cost figure look durable only starts once there is someone to compete with.

For now the honest summary is narrower than the launch framing. Inkling 2 Mini is a 20GB download that matches a 27B dense model on a composite index at roughly a sixth of the cost per task and four times the speed, from a lab that shipped weights on day one instead of a week later. It is also a model that hallucinates with confidence, loops while debugging, and asks for a sandbox before you let it touch a filesystem. Both halves of that sentence are true, and the second half is the one that decides how you deploy it.