Inkling 2 Small Keeps Pace in Coding on 17B Active Parameters — Until You Look at the Variance

Two lines on Thinking Machines' launch chart meet at the same number. Inkling 2 Small solves 54.25 of 69 PMPP-Hard tasks on a single attempt and 64 across four. Claude Opus 5.5 solves 60 on a single attempt and 64 across four. Released on 5 November 2026, Inkling 2 Small is a mixture-of-experts model with 594B total parameters and 17B active, and that chart is the cleanest statement of what the architecture buys and what it does not: the ceiling of a frontier model on hard engineering work, without the per-attempt reliability of one.

The claim going around is narrower and more flattering — that in coding benchmarks it easily keeps pace with significantly larger models. That claim is testable against the vendor's own table, row by row, and it survives in some places, fails in others, and fails most interestingly against a model far smaller than itself. This piece does the row-by-row reading, then asks the question the table cannot answer: what the pace costs per task once the model is actually on your bill.

Six coding rows, read without the gloss

Everything below is from the evaluation table Thinking Machines published with the announcement. It is a vendor-run harness — the company says so, and says the coding rows use hidden unit tests and programmatic checks. Nothing here has been independently reproduced, which matters because the same table prints an Artificial Analysis Intelligence Index of 30.6 for Inkling 2 Small while Artificial Analysis' own live page prints 31. That is a rounding difference, not a dispute, but it tells you the table is a snapshot taken by the lab rather than a live board.

Against Kimi K3, the largest open-weights model in the comparison, the pace claim holds to a draw:

• FrontierCode v2.0 — Inkling 2 Small 25.4% vs Kimi K3 17.3%.

• DeepSWE v1.1 — 72.1% vs 68.5%.

• SWE-bench Pro v2 (Hard) — 86.3% vs 88.2%.

• Vibe Code Bench v1.1 — 81.6% vs 85.0%.

• PostTrainBench v1.2 — 31.9% vs 31.5%.

• Terminal Bench Science v0.1 — 5.7% vs 8.1%.

Three rows each. A model running 17B parameters per token ties a model that is an order of magnitude larger on the compute it burns, and does it at the two ends of the coding spectrum that usually separate: a from-scratch patch benchmark in FrontierCode and a repository-scale agentic one in DeepSWE. DeepSWE is the one to weigh, because it is the row where a model has to hold a plan together across many tool calls rather than produce one good diff.

Against DeepSeek V4.1 Flash 1017 the picture reverses, and this is the comparison that matters commercially rather than architecturally, because DeepSeek's flash tier is cheap. Inkling 2 Small is behind on four of the five rows both models ran — FrontierCode 25.4% to 28.5%, DeepSWE 72.1% to 77.0%, Vibe Code Bench 81.6% to 87.7%, Terminal Bench Science 5.7% to 12.9% — and ahead only on PostTrainBench, 31.9% to 30.5%. DeepSeek has no SWE-bench Pro entry, which is unlucky for Thinking Machines, since 86.3% is Inkling 2 Small's best coding number and it would have been the most persuasive single row to win.

The smaller model is the one it does not keep pace with

The comparison the launch material does not lead with is Claude Haiku 5.5, and it is the one that should give a buyer pause. Haiku is the small, cheap tier in Anthropic's line — nothing like a 594B model — and it wins three of the five coding rows the two share: FrontierCode 34.9% to 25.4%, Vibe Code Bench 90.4% to 81.6%, and Terminal Bench Science 20.0% to 5.7%, where the gap is more than threefold.

Inkling 2 Small takes the other two decisively: DeepSWE 72.1% to 59.9% and SWE-bench Pro 86.3% to 52.9%. Read together, the pattern is not about size at all. Haiku wins the rows that score a single produced artefact — a diff, a UI, a terminal session driven to completion. Inkling 2 Small wins the rows where the model has to keep working on a problem over many steps and improve its own answer. Against Gemini 3.8 Flash it is closer still: Inkling takes FrontierCode, SWE-bench Pro and Vibe Code Bench, loses DeepSWE narrowly at 72.1% to 73.8%, and loses Terminal Bench Science badly at 5.7% to 10.0%.

One detail from the announcement is worth filing away for anyone who reads leaderboards. Thinking Machines says it tested early checkpoints of Inkling 2 Small on OpenCode under the name Fledge-Alpha. Any Fledge-Alpha score you saw on a coding board before launch was this model, under a pseudonym, and it was not the finished one.

What four attempts buy, and what 18.5 minutes costs

PMPP-Hard is 69 tasks, four independent attempts, a ten-hour budget, scored as mean tasks solved. Inkling 2 Small's 54.25 is good but not remarkable — it sits behind GPT-6 Astra at 63, Kimi K3.1 Pro at 60.5 and Opus 5.5 at 60, and ahead of Kimi K3 at 55.75, DeepSeek V4.1 Flash at 55.25, GLM 5.3 at 52.5 and Mistral Large 4 at 50.25.

Its Pass@4 of 64 is where the number stops being ordinary. That figure ties Opus 5.5's 64 and beats Astra's 63 and Kimi K3.1 Pro's 63. Give it four shots and it reaches the same ceiling as the best models in the chart; give it one and it is nearly six tasks behind. If your workflow already samples several attempts and picks a winner by running the tests, the gap that matters is small. If it samples once and ships, the gap is the whole story.

The same asymmetry shows up in the kernel-autoresearch chart, and there it does not favour Inkling 2 Small. Best kernel speedup against the baseline: Claude Opus 5.5 18.80×, GPT-6 Astra 10.26×, Inkling 2 Small 6.02×, DeepSeek V4.1 Flash 5.66×, GLM 5.3 5.03×, Mistral Large 4 3.43×. Roughly a third of the frontier's speedup on the same task, which is a long way from keeping pace.

Then there is the wall clock. Every published evaluation was run at effort 0.99 — the setting Thinking Machines calls xhigh — at temperature 1.0. Artificial Analysis, testing the live endpoint rather than the development harness, measures 18.5 minutes per Intelligence Index task against a peer median of 7.0, and 154M output tokens against a median of 89.8M. Cost per index task is $1.18, ranking 27th of 29 models on that board. Output speed is 135 tokens per second with 34.15 seconds to first answer token, against an 11.57-second median. The model is not slow per token. It is slow because it thinks for a long time and writes a great deal while doing it.

Where the 17B active number actually pays off

Mixture-of-experts models are billed on active parameters, and that is the whole commercial case for this architecture. Inkling 2 Small prices at $0.30 per million input tokens and $1.00 per million output, with cached input discounted 90% to $0.03 — a blended $0.18 per million at a 7:2:1 cache-hit-to-input-to-output ratio, per Artificial Analysis. The median model on that board charges $0.24 in and $0.87 out, so Inkling 2 Small is priced like a mid-tier model, not like a 594B one.

The training mix explains the emphasis. Coding was 38.5% of reinforcement-learning rollouts and 65% of tokens — the single largest block, and more than two-thirds of everything the model generated during RL. Vision was 13.9% of rollouts but 3% of tokens. Whatever else this model is, it was post-trained to write and fix code at length.

So the honest arithmetic is per successful attempt, not per token. Inkling 2 Small at $1.18 per index task and four attempts to reach its ceiling is a different purchase from a model at twice the price that gets there in one. Neither configuration is wrong; they are different contracts with your latency budget.

What you can call today, and what you cannot

Inkling 2 Small is available through Tinker for inference and fine-tuning, with closed weights and no second provider. Thinking Machines says it intends to publish the full weights under Apache 2.0 "next week," after external safety testing and red-teaming, and that has not happened as of 6 November 2026. The serverless endpoint is served at 256K context, narrower than the 1M window the model was trained to handle.

It is not on OrcaRouter, and this piece will not pretend otherwise. What is on OrcaRouter is most of the comparison set this article just walked through — Kimi K3, DeepSeek V4.1 Flash 1017, GLM-5.3 Flash, Gemini 3.8 Flash, MiMo V2.6 Pro — reachable with one key across more than 200 models, with provider list price passed through unchanged and no markup added. That matters for exactly the use this article implies: if you want to find out whether a 17B-active MoE is good enough for your repository, the cheapest experiment is to run your own eval against the models on either side of it, on one bill, rather than signing four contracts.

Automatic failover is the other half of that. A benchmark table says nothing about whether a long agentic run survives a provider hiccup at minute fourteen, and the models that look closest on DeepSWE are the ones you would actually be swapping between.

Three things would change this reading. An independent rerun of FrontierCode or DeepSWE, because these numbers are the lab's own and the SWE-bench Pro row is doing a lot of persuasive work. The weight release, because Apache 2.0 would make the 594B model self-hostable and put the $1.18-per-task figure under your control. And any published tier below xhigh, because every number in this piece was produced at maximum effort — if a lower setting gets most of the accuracy at a fraction of the 154M tokens, the cost case improves and nobody has shown that yet.

The comparison set on one key

The models Inkling 2 Small is measured against in the rows above are, with two exceptions, models you can call from a single endpoint today. The two exceptions are Inkling 2 Small itself, which is Tinker-only, and Claude Haiku 5.5, which is not in the OrcaRouter catalogue. The rest of the table is: Kimi K3, the open-weights model Inkling 2 Small draws with; DeepSeek V4.1 Flash 1017, the cheap model it trails on four of five rows; GLM-5.3 Flash, the small model it beats comfortably; and Gemini 3.8 Flash, the mid-size model it splits with.

That set is the one worth running, because the interesting question for a team is not whether a 17B-active mixture-of-experts model is impressive in the abstract — the table above already answers that — but whether it beats the model already in production on the specific repository, test suite or kernel you care about. That is a question only your own eval answers, and it is much cheaper to answer across four models on one key than across four vendors.

What the launch establishes is narrower than the reaction to it suggests. A 594B model with 17B active parameters now holds a draw against the largest open-weights model in coding, wins the two rows that reward sustained work, and loses to a small closed model on the three that score a single artefact. That is a real result and it is not a frontier result. The cost of finding out which side of the line your workload sits on is $0.30 and $1.00 per million tokens, 18.5 minutes per hard task, and a willingness to sample more than once.