Thinking Machines' Inkling Is Not the Best Model, On Purpose

A 975B open-weights model whose own launch post says it isn't the strongest thing available, and the bet hiding inside that sentence.

Read enough model launches and you learn the genre. Somebody is best at something. There is a chart with a bar that goes higher than the other bars, and if the bar doesn't go higher, the benchmark gets narrower until it does.

Then Thinking Machines released Inkling on July 15 and wrote this in the announcement: "Inkling is not the strongest overall model available today, open or closed."

That sentence is doing more work than the 975 billion parameters behind it. A lab founded by OpenAI's former CTO, funded at a valuation that assumes frontier ambitions, shipped its first production model and led with a disclaimer. Not humility for its own sake. A thesis. The claim underneath is that for the work you actually need done, a model you can reshape beats a model you can only talk to.

I think that claim is right in a narrower band than the launch implies, and I think the part nobody priced is what fine-tuning hands back to you the moment you accept the offer.

What actually shipped

Inkling is a Mixture-of-Experts transformer with 975B total parameters and 41B active per token, pretrained on 45 trillion tokens of text, images, audio, and video, released under Apache 2.0 with the weights on Hugging Face. The open weights run a 1M-token context window. It reasons natively over text, images, and audio using an encoder-free design, with audio fed in as dMel spectrograms and images as 40x40 patches through a four-layer hMLP, all processed alongside text tokens rather than bolted on through a separate vision tower.

It debuted at 41 on the Artificial Analysis Intelligence Index, three points above Nemotron 3 Ultra at 38 and well past gpt-oss-120b at 24. That makes it the strongest open-weights model any US lab has released.

The more interesting number is the one about cost. Inkling averages 25K output tokens per Intelligence Index task where GLM-5.2 burns 43K, Kimi K2.6 burns 38K, and DeepSeek v4 Pro burns 37K. On Terminal Bench 2.1, Thinking Machines reports it matching Nemotron 3 Ultra at roughly a third of the tokens.

That efficiency comes from a dial. Inkling was trained with a controllable thinking effort setting, done by varying the system message and the per-token cost across rollouts during reinforcement learning until the model learned to spend more or less depending on what it was told. You set effort from roughly 0.2 to 0.99 and trade accuracy against tokens on a curve instead of picking between a fast model and a smart one.

There is a detail in the training write-up I keep thinking about. Over 30 million RL rollouts, the model's chain of thought compressed on its own. It started writing "We need determine" instead of "We need to understand," dropping articles and connectives while still reaching the same answer. Nobody rewarded that directly. Efficiency pressure alone produced a private dialect.

The bet

Here is the argument Thinking Machines is making, stated plainly: picking a base model is a qualitative judgment, most real problems aren't solved well by even the best generalist, and the gap gets closed by fine-tuning on knowledge your organization has and the lab doesn't. So they built a broad, balanced, deliberately unspecialized model and pointed it at Tinker, their fine-tuning platform, where you shape it into whatever you needed in the first place.

To demonstrate, they had Inkling fine-tune itself. Running inside the OpenCode harness, the model wrote its own training objective, generated synthetic data and an eval, called the Tinker API to post-train itself into a lipogram model that never uses the letter "e," then loaded the new weights back into the harness. A closed loop, done as a party trick, making a serious point about how short the distance from idea to modified weights has become.

Where I think the bet holds: narrow, repeatable, high-volume work with a clear grading signal. Classification against your taxonomy. Extraction from your document formats. Judgment calls your senior people make the same way every time and can label a few thousand examples of. In that band, a mid-tier model tuned on your data routinely beats a frontier model reading your prompt, and it costs a fraction to run.

Where I think it falls apart: everything else. Open-ended reasoning, novel problems, anything where the task shape changes month to month. Thinking Machines' own benchmark table shows it. GLM-5.2 beats Inkling on Humanity's Last Exam text-only (40.1% to 29.7%), SWE-Bench Pro Public (62.1% to 54.3%), and Terminal Bench 2.1 (82.7% to 63.8%). Kimi K2.6 beats it on several more. Inkling leads US open weights and trails Chinese open weights, and the launch post publishes the table that says so.

Putting this into practice

The lowest-friction first step is not a fine-tuning run. It's building the thing you'll grade the fine-tuning run against.

Write the eval before you touch the model. Fifty to two hundred examples of the task, with the answer you want, drawn from real inputs rather than ones you invented. If you can't write that set, you don't have a fine-tuning problem yet, you have a specification problem. This is the step everyone skips and the reason most fine-tuning projects end in a shrug.

Get a feel for the base first. Thinking Machines added an Inkling Playground to the Tinker console with agentic web search built in, free for a limited time. Run your hardest twenty prompts through it at high effort. If the base model is nowhere close, fine-tuning is usually the wrong lever, because tuning teaches format and style far more reliably than it teaches knowledge the model never had.

Then run a small tune and compare honestly. Tinker offers Inkling at 64K and 256K context, with the cookbook updated for it and three new recipes covering the audio capabilities. Compare against two baselines, not one: the untuned Inkling on your eval, and whatever hosted frontier model you're using today with a good prompt. The second baseline is the one people leave out, and it's the one that decides whether the project was worth it.

Sweep the effort dial as a separate exercise. Run your eval at 0.2, 0.5, and 0.99. Most teams find a knee where accuracy flattens and tokens keep climbing. That knee is money.

What this costs you that the announcement doesn't say

Inkling-Small is not released. Coverage this week described the 12B-active sibling as shipping alongside the flagship. The launch post says otherwise: it's a preview, and Thinking Machines is "currently finishing the testing of Inkling-Small and will release its full weights once that work is complete." If your plan depended on the small one, your plan is waiting.

Apache 2.0 is real, and 975B is still 975B. The license genuinely permits commercial use, modification, and redistribution, and Thinking Machines did more than most to keep the weights portable: they worked with partners to land inference support in SGLang, vLLM, llama.cpp, and Hugging Face transformers, and published an NVFP4 checkpoint alongside the original. That's meaningful work toward an exit. It doesn't change the fact that almost nobody serves a 975B model themselves, so in practice you fine-tune on Tinker and serve through Together, Fireworks, Modal, Databricks, or Baseten. The weights are portable. Your workflow is a business relationship. Those are different things, and the launch language blurs them.

The intro pricing is intro pricing. Inkling is on Tinker at a 50% discount for a limited time. Whatever unit economics you compute this month are not the ones you'll operate on.

Fine-tuning erodes the safety work the model came with. This is the cost that gets waved past, and it isn't speculative. Qi et al. showed that guardrails on an aligned model can be stripped with roughly ten adversarial examples for under a dollar, and that fine-tuning on entirely benign, ordinary datasets degrades safety alignment without anyone intending it. Thinking Machines is candid here: they say they're "continuing to study safety behavior and capability uplift in customizable models, including how safety behavior is impacted by fine-tuning on Tinker." Read that as written. The FORTRESS and StrongREJECT numbers in the launch post describe the checkpoint they shipped, not the checkpoint you'll create. Once you tune, the safety evaluation is your job, and almost nobody budgets for it.

The benchmarks come with asterisks the lab supplies. Inkling's SWE-Bench Verified score used a bash-only harness and its Terminal Bench score used an internal harness, both compared against self-reported numbers from other labs. The forecasting results ran on a different checkpoint than the released one, as did some Humanity's Last Exam figures. None of that is misconduct, and disclosing it puts Thinking Machines ahead of several competitors. It does mean cross-lab comparisons here are softer than the table's clean rows suggest.

The part worth keeping

Strip away the parameter count and Inkling is an argument about where value sits. If the best generalist model is a commodity you rent, then the durable thing you own is a model shaped around knowledge your competitors can't read off your website. That argument is sound, and I think more teams should take it seriously than currently do.

Just take it seriously with the bill attached. Fine-tuning moves the eval work, the safety testing, the regression suite, and the serving decision from a vendor's roadmap onto your sprint board. That's the trade. It's often worth making. It is never free, and a launch post that admits the model isn't the best is still a launch post.

Go build the eval set. You'll learn more in an afternoon of writing down what "correct" means for your task than in a week of reading benchmark tables, and you'll need it either way.

Sources: Thinking Machines Lab, "Inkling: Our open-weights model"; Artificial Analysis; Inkling on Hugging Face; Qi et al., "Fine-tuning Aligned Language Models Compromises Safety, Even When Users Do Not Intend To!"; tinker-cookbook.