Inkling isn’t chasing “strongest” — it is redefining what a good model is.
Thinking Machines Lab (TML) released its first in-house model, Inkling, early this morning: 975B total parameters, 41B active, Apache 2.0 open weights.
By the industry’s habitual script, a new player’s first move should be leaderboard-hunting: plant a few SOTA flags, harvest attention, sign deals, land customers. TML did the opposite. The first paragraph of the official blog reads: “Inkling is not the strongest model available today, open or closed.”
Is that humility? Not entirely. The benchmark it targets is not “whose score is higher” but: who lets enterprises run cheaper in real scenarios, modify more smoothly, and deploy more freely. That repositioning may deserve more attention than any leaderboard climb.
When “Strongest” Stops Being the Only Standard
The past two years of open-model competition were, at bottom, a benchmark arms race. You have watched countless launches: 90% of the time on score leadership, 10% on “and we open-sourced it.” Scores were everything because the score narrative is simplest — my model is X points higher, therefore better.
But enterprises buying models never cared about that score. They care about three things: what does one inference cost? Can the model understand images and speech? Can we fine-tune it on our own data? None of the three is answerable by a benchmark number.
TML’s founders Mira Murati and Luna Wang both came from OpenAI and spent nearly a year on the enterprise frontline, serving hundreds of customers through the Tinker platform. That experience taught them: open source’s competitive dimension is rotating from raw capability to customizability. Inkling is not positioned as a “high-score model” but as a “base enterprises will want to modify” — trading the SOTA narrative for balance across capability breadth, inference cost, native multimodality, and fine-tunability.
Token Economics: RL Teaches the Model to Read the Room
Inkling’s deepest technical innovation hides in the concept of controllable thinking effort. Picture assigning a model two jobs: write “hello world,” and debug a distributed-systems deadlock. Conventional models spend identical compute on both — either always deep-reasoning or always shortcutting. You get one gear.
Inkling lets you dial reasoning intensity between 0 and 1: give a simple task 0.2 and it answers fast; give a complex one 0.99 and it unfurls a chain of thought like the most premium reasoning model.
More remarkable: the capability was not bolted on by hard-truncating chains of thought — it grew into the model’s genes through reinforcement learning. TML invested over 30 million RL rollouts in post-training with an elegant mechanism: modified system messages plus per-task per-token costs, letting the model learn for itself which problems deserve more digging, which tasks can stop, whether another reasoning paragraph buys enough benefit.
The result: on Terminal Bench 2.1, Inkling matches NVIDIA’s Nemotron 3 Ultra while generating one-third the tokens. The RL pressure even produced spontaneous compression — late in training the model began omitting articles, connectives, and repetition, its reasoning approaching a shorthand language. TML never rewarded that style; pure token-cost pressure drove the model to find shorter reasoning paths. And a model that knows how to throttle itself also tends to absorb fine-tuning knowledge more efficiently.
The Cost-Capability Curve: Why Enterprises Want a Dial, Not a Fixed Score
Traditional model selection forces a dilemma: pick the high-performance model and simple queries get expensive; pick the lightweight model and complex problems fail. You deploy two models, two APIs, two monitoring stacks — then write glue code to route requests. Inkling offers a continuous cost-capability curve: the horizontal axis is inference cost in tokens, the vertical axis is task performance, and Inkling slides anywhere along the curve while a competitor like Nemotron occupies a single fixed operating point.
The frame extends further. The same-day preview of Inkling-Small (276B total, 12B active) — under 30% of the large model’s active parameters, yet matching or beating it on some tests — carries a precise positioning: coding groundwork, grading other models, generating synthetic data. High-frequency batch scenarios: modest per-call ceilings, acute cost and latency sensitivity. Large models handle deep reasoning; small models handle high-frequency volume — two cost gears.
It also explains why TML shipped tml-renderer. When inference interleaves tool calls and multimodal input, data sampling and post-training get fragile; tml-renderer unifies the format conversion of chat messages, tool calls, images, and audio so that inference sampling and supervised fine-tuning obey one rule set. That is infrastructure built by people who actually feel the engineering pain — not stacking parameters but paving the road.
What the Curve Explains Across the Industry
Apply the cost-capability curve industry-wide and several patterns resolve: DeepSeek’s success is not merely cheaper training — its MoE architecture also invests different compute in different problems, with the “read the room” happening at the architecture layer (routing to experts) where Inkling’s happens at the inference layer (tuning thought depth). Same destination, different roads: cut cost while holding capability. Anthropic’s thinking-budget control for Claude Opus 4.5 is the same logic surfaced in a product UI — letting users dial how long the model thinks. And the seemingly contradictory trend of 1T-parameter flagships coexisting with lightweight models (Gemma 4’s 31B, Inkling-Small’s 12B) is no split — it is the two ends of one curve, because enterprises want deep and light reasoning inside a single stack.
Push one step further: if the curve becomes the industry’s selection frame, model vendors’ core competitiveness changes too. Yesterday’s race was “who scores two more HLE questions”; tomorrow’s is “whose curve is steeper” — who gains more capability per unit of added compute. The metric of model progress migrates from final score to the curve’s derivative.
The New Open-Source Race: From Open Weights to Open Pipeline
Inkling’s Apache 2.0 license is a real signal — enterprises and developers can use, modify, and redistribute the weights without hesitation. But TML went one layer further and opened the entire supporting infrastructure: Tinker natively supports Inkling fine-tuning, with an updated Cookbook, three audio-customization examples, and the tml-renderer. Developers can call Inkling directly on Together AI, Fireworks, and Modal, or self-host through SGLang, vLLM, llama.cpp, and Transformers. Full weights (BF16 plus NVFP4 quantized), fine-tuning tools, deployment paths — all open.
An observation worth keeping: the next phase of open-model competition may not be “who shipped the bigger parameter count” but “who built the more complete customization and deployment loop.” Open source stops being an event and becomes the admission ticket to a service.
Where to Start
If you lead enterprise AI: do not measure Inkling by benchmark scores. Fine-tune it on your own data and watch token consumption and response speed inside your real workflows. Its value is not “how much better than Nemotron” — it is reaching your performance threshold at lower cost. If you are a developer: watch Inkling-Small — pair it as a coding assistant and code reviewer with Tinker for personal fine-tuning; 12B active parameters run on consumer GPUs, which means a private coding agent on your own machine. If you are a model vendor: the cost-capability curve deserves serious study. Open differentiation is moving from “how high the peak” to “how steep the curve” and “how open the pipeline” — mind the lowest cost, not just the highest score.
Inkling topped no leaderboard. But it touched the more essential question: should the standard for judging a model change? That takes more courage than topping any list.
References: Thinking Machines Lab blog: Introducing Inkling · 36Kr: Inkling, America’s non-chasing open-source king · The Tinker platform
