Inkling: Thinking Machines' open model is a deployment bet, not a benchmark sweep (2026)

Inkling is a real open-weights release, but its headline is not "the best new model." Thinking Machines Lab released a 975B-parameter sparse Mixture-of-Experts model on July 15 with 41B active parameters, native text, image, and audio input, and a 1M-token context window for the downloadable weights. The trade-off is immediate: the BF16 checkpoint needs at least 2 TB of aggregate VRAM, and the launch benchmark table mixes internal harnesses, self-reported comparison scores, and a high reasoning-effort setting. 1 2 3 4

The update in one screen

Item	What builders can verify	What it means in practice
Release	Thinking Machines released Inkling on July 15, 2026, with full weights available. 1	This is a downloadable base model, not only a hosted preview.
License	Apache 2.0, with a separate acceptable-use policy. 2	Developers can study, fine-tune, and integrate it, subject to the policy and their own deployment controls.
Model shape	975B total parameters, 41B active per token; sparse MoE. 2	The active footprint is much smaller than the checkpoint, but still far beyond a single-GPU experiment.
Inputs	Text, images, and audio. Output is text. 2	One open model can sit behind document, image, and audio workflows without separate modality-specific models.
Context	Up to 1M tokens in the open-weights model; Tinker access is capped at 256K. 1 3	Do not assume that a managed API exposes the same context limit as the local checkpoint.
Hardware	BF16 requires at least 2 TB aggregate VRAM; NVFP4 reduces that to at least 600 GB. 2	Self-hosting is a cluster project. Quantization changes the threshold, not the category.
Managed access	Tinker offers 64K and 256K context options. At launch, Artificial Analysis recorded $1.87 input / $0.374 cached / $4.68 output per 1M tokens at 64K, and $3.74 / $0.748 / $9.36 at 256K. 1 3	Verify current prices before budgeting. The release discount was time-limited.

The short version is a useful one: Inkling is more interesting as a model to customize than as a model to crown. Thinking Machines says as much in its announcement, calling Inkling a broad base for customization rather than the strongest overall model available. 1

What is actually in the checkpoint

Inkling is a 66-layer decoder-only Transformer. Each MoE layer has 256 routed experts and two shared experts; six routed experts plus the two shared experts are active for each token. The model uses hybrid attention, alternating sliding-window and global attention in a 5:1 pattern, with eight key-value heads. 1 2

The design also departs from the most familiar open-model recipe. Thinking Machines uses a learned relative-position bias instead of RoPE, plus short causal convolutions around the attention and MLP branches. The stated goal is better long-sequence behavior and cheaper local token mixing. Those are design claims, not results that should be treated as independently established. 1

The multimodal path is native rather than a text-only model with a separate captioning service attached. Images go through a hierarchical patch encoder, while audio is represented through discrete mel-spectrogram encoding. Both are projected into a shared space and processed by the decoder alongside text. Video has an input path, but the release notes say the team has not evaluated out-of-the-box video performance. 1 2

There are two other details that matter for builders:

Reasoning effort is controllable rather than a single fixed mode. Transformers exposes options from none through max, and the release evaluates Inkling at effort 0.99. This gives teams a way to trade output-token cost against task performance, although the best setting will be workload-specific. 1 5
The release includes multi-token prediction drafters for speculative decoding. Thinking Machines and Hugging Face describe them as a way to increase generation speed while preserving the same outputs, with some additional VRAM use. That is a serving feature to test, not a published throughput guarantee. 5

The benchmark picture is mixed by design

Thinking Machines reports Inkling at reasoning effort 0.99, with comparison scores generated around July 14. A selected slice of its table looks like this:

Evaluation	Inkling	Kimi K2.5	Nemotron 3 Ultra	GLM 5.2
SWE-bench Verified	77.6%	76.8%	70.7%	80.2%
SWE-bench Pro Public	54.3%	50.7%	46.4%	62.1%
Terminal Bench 2.1	63.8	51.3	56.4	82.7
HLE with tools	46.0%	50.2%	37.4%	48.2%
IFBench	79.8%	70.2%	81.4%	73.3%
MMMU Pro, standard 10	73.5%	75.0%	-	79.0%

These numbers do not produce a clean winner. Inkling is ahead of Kimi K2.5 on several coding and instruction-following rows, but behind it on HLE with tools and MMMU Pro. GLM 5.2 is ahead on several coding-agent measures, while Inkling leads on IFBench. The release also warns that SWE-bench uses a bash-only harness, Terminal Bench uses an internal harness, and some comparison values come from external reports or self-reported results. 1 2

Sebastian Raschka reaches the same conclusion from a different angle. He notes that Inkling beats GLM-5.2 on IFBench and SimpleQA Verified, but trails it on HLE without tools, SWE-bench Pro, and Terminal Bench. He also points out that Inkling activates 41B of 975B parameters, compared with Kimi K2.5's 32B of roughly 1T, so Inkling is less sparse and may not have raw decoding speed as its main advantage. 4

Artificial Analysis supplies a useful independent baseline. Its Intelligence Index gives Inkling a score of 41, three points above Nemotron 3 Ultra at 38, and reports 1,238 Elo on GDPval-AA v2 versus 1,190 for Kimi K2.6. It also measured about 25K output tokens per Intelligence Index task for Inkling, compared with 38K for Kimi K2.6. Those figures make a case for efficient agentic work, but they do not turn a mixed benchmark profile into universal superiority. 3

The clearest differentiator is audio. The release reports 56.6% on Audio MC, 77.2% on MMAU, and 91.4% on VoiceBench, while the compared open-weight models show no corresponding audio results in the table. That is evidence that Inkling covers a broader input surface, not proof that it will be the best audio model for a production workload. 1

What changed from Kimi K2.5

Kimi K2.5 is a sensible comparison because both are large open-weight MoE models aimed at general use. The differences are practical:

Dimension	Inkling	Kimi K2.5
Active parameters	41B	32B
Open-weight context cited by Artificial Analysis	1M tokens	256K tokens
Native audio input	Yes	No audio score shown in the release comparison
Fine-tuning path	Tinker, plus local weights and third-party tooling	Requires its own compatible training and serving stack
Deployment burden	2 TB BF16 or 600 GB NVFP4 aggregate VRAM	Lower active footprint, but a direct end-to-end hardware comparison is not established here

The table is deliberately asymmetric. The first three rows are documented model properties or release comparisons; the last row is a deployment implication, not a measured cost study. Raschka's observation is the useful constraint: 41B active parameters and conventional GQA mean Inkling should not be assumed to decode faster simply because it is sparse. 2 3 4

That makes Inkling's meaningful generation change less about a leaderboard jump and more about the combination of native audio, long local context, controllable reasoning, and a first-party fine-tuning path. For teams building a specialized assistant, that bundle may matter more than winning any one coding benchmark.

How to try it

There are three realistic entry points.

Use Tinker first. The official announcement links to an Inkling playground and exposes 64K and 256K context options for fine-tuning and managed access. At launch, the platform offered a limited-time 50% discount, so treat old prices and discounts as historical until the console confirms them. 1
Call an inference provider. The Hugging Face model page links to third-party API access, and the Hugging Face blog documents the thinkingmachines/Inkling:auto route through its router. Audio support there was still marked as work in progress in the release documentation. 6 5
Download the weights for controlled tests. The BF16 artifact is thinkingmachines/Inkling; the NVFP4 variant is thinkingmachines/Inkling-NVFP4. The model card lists Hugging Face, Transformers, SGLang, vLLM, TokenSpeed, and Unsloth as deployment paths. Hugging Face's release notes include day-zero Transformers support and example serving integrations. 7 6 5

For local deployment, budget around the checkpoint rather than the active count. The official model card puts BF16 at a minimum of 2 TB aggregate VRAM, with examples of 8 NVIDIA B300 GPUs or 16 H200 GPUs. NVFP4 lowers the stated minimum to 600 GB, with W4A4 on four B300 GPUs requiring SM100+ or W4A16 on eight H200 GPUs. Unsloth documents more aggressively quantized GGUF routes for llama.cpp, but those should be evaluated for quality and throughput on the exact workload before they are treated as production substitutes. 7 8

The limits that should change your test plan

First, the 1M-token number is a model capability, not a promise of uniform quality across a million-token prompt. Managed Tinker access is capped at 256K in the launch material, and neither the vendor documentation nor the independent sources provide a comparable long-context quality curve. Test retrieval accuracy, lost-in-the-middle behavior, latency, and memory use at the context lengths you will actually pay for.

Second, the benchmark table is a release snapshot. Some rows use internal harnesses, some comparison values are self-reported, and the model card says the scores were generated at a particular effort setting. Small gaps should not drive a routing decision. Raschka's review is a useful guardrail here: the release looks like a broad all-rounder, not a model that leads every category. 1 7 4

Third, the model card itself lists hallucination, uneven multilingual performance, degraded long multi-turn behavior, and occasional compliance with indirectly framed harmful prompts. It recommends application-level filtering, monitoring, rate limits, and human review for high-stakes use. Those are ordinary foundation-model warnings, but open weights make the downstream operator responsible for implementing them. 2

A sensible first evaluation is small and concrete: one long-document task, one image question, one audio transcription-and-reasoning task, one tool-use task, and one adversarial prompt set. Run each at two or three reasoning-effort settings. Record output tokens, latency, tool calls, failure recovery, and memory use. Compare the result against the model you already operate, not only the release table.

Verdict

Inkling is worth trying now if you need an open-weight multimodal base that can be fine-tuned, especially when audio input or long local context is part of the product. Tinker lowers the initial barrier, and the Apache 2.0 weights make deeper evaluation possible.

It is a poor default for a small team expecting one workstation to serve a frontier model. The hardware floor is too high, the 1M-token path is not the same as the managed API, and the available benchmark evidence does not show a clean win over Kimi K2.5, Nemotron 3 Ultra, or GLM 5.2. Start with a bounded provider or Tinker trial, then decide whether the customization benefit justifies a multi-GPU deployment.

Inkling: Thinking Machines' open model is a deployment bet, not a benchmark sweep