What Inkling-Small is
Inkling-Small is an open-weights multimodal model released by Thinking Machines Lab on July 30, 2026. It takes text, images, and audio as input and produces text as output.
The official description is remarkably compact: an efficient open-weights model that reaches comparable performance to its parent Inkling at a quarter of the size. That single line is the whole positioning.
How it relates to the parent model Inkling
Start with how the two models sit against each other. Inkling is the larger model, released on July 15, 2026. Inkling-Small arrived two weeks later as the compact version.
Inkling and Inkling-Small compared (per the official model cards)
| Item | Inkling | Inkling-Small |
|---|---|---|
| Release date | July 15, 2026 | July 30, 2026 |
| License | Apache 2.0 | Apache 2.0 |
| Layers | 66 | 42 |
| Parameters | 975B total / 41B active | 276B total / 12B active |
| Context window | Up to 1M tokens | Up to 1M tokens |
| Audio input guidance | Within 20 min | Under 2 min |
| Numerics | BF16 / MXFP8 / NVFP4 | BF16 / MXFP8 / NVFP4 |
Both are built on the same design. They use a Mixture-of-Experts (MoE) arrangement, and even the routing is identical: each token goes to 6 of 256 experts, plus 2 shared experts that are always active. Attention is a hybrid of local and global layers, images come in through a hierarchical patch encoder, audio through discrete token encoding, and everything is projected into one shared internal space and processed together. What differs is the layer count, the scale, and the intended length of audio input.
A 42-layer decoder-only transformer with a sparse Mixture-of-Experts (MoE) feed-forward backbone: each token is routed to 6 of 256 experts, plus 2 shared experts active on every token. Attention is a hybrid of local and global layers. The model is natively multimodal — images are encoded via a hierarchical patch encoder, and audio via discrete token encoding — with all modalities projected into a shared hidden space and processed jointly by the decoder. / Parameters / 276B total, 12B active / License / Apache 2.0 — From the description of the architecture, parameter count, and license
Date of release / July 15, 2026 / License / Apache 2.0 / A 66-layer decoder-only transformer with a sparse Mixture-of-Experts (MoE) feed-forward backbone: each token is routed to 6 of 256 experts, plus 2 shared experts active on every token. / Parameters / 975B total, 41B active / Numerics support / BF16, MXFP8 and NVFP4 / Audio: WAV format, sampled at 16kHz. For optimal performance, audio length should be within 20 mins. / Inkling supports a context window of up to 1M tokens. — From the parent model Inkling's release date, license, architecture, parameter count, and audio input guidance
Measured in active parameters, the gap is smaller still
When you compare MoE models, active parameters track reality better than total parameters. Active parameters are the ones actually used in computation for a single token. In an MoE model only a slice of the total fires each time, so that number is what governs compute and response speed.
Inkling runs 41B active; Inkling-Small runs 12B. That puts the compute used per pass at under a third. When the official write-up says "a quarter of its size," this is where the weight of the claim sits.
Today, we are releasing Inkling-Small, an efficient open-weights model that achieves comparable performance to Inkling at a quarter of its size. / Inkling-Small is a Mixture-of-Experts transformer with 276B total parameters, 12B active, trained on NVIDIA GB300 NVL72 systems. Like Inkling, it features native reasoning over audio and images, variable thinking effort, a context window of up to 1M tokens, and well-rounded performance across a range of benchmarks. — From the description of the model's positioning, scale, and the traits it shares with the parent model
Why the smaller model wins in places
This is the most interesting part of the release. The compact version beats its parent on some benchmarks — and the official write-up explains why.
Starting training later is what did it
The answer is plain: Inkling-Small began training after its parent, which left room to improve the training process.
Three specifics are named. First, changes to the pre-training data mix and the machine learning recipe. Second, post-training applied to an early checkpoint called Inkling-Small (preview), partly using on-policy distillation with Inkling as the teacher. Third, starting from that checkpoint, two more weeks of scaling agentic coding reinforcement learning.
Distillation means training a smaller model on a larger model's outputs as the reference. The parent ran first, so its way of running could be taught to the child.
Inkling-Small began training after its larger counterpart, which let us improve its training process. For example, we made changes to Inkling-Small's pre-training data mix and machine learning recipe. Additionally, we post-trained an earlier checkpoint, Inkling-Small (preview), in part using on-policy distillation with Inkling as the teacher. Starting from that checkpoint, we continued scaling agentic coding RL for two weeks. — From the description of what starting later allowed them to improve in the training process
But it did not win across the board
Skip this part and you will misread the release. The official write-up separates where it won from where it lost.
It came out ahead on reasoning and agentic coding benchmarks. On the other side, Inkling keeps an advantage on knowledge coverage and factuality, stated explicitly. This is not a case of a small model wholly replacing a large one.
There are concrete figures by area. On Humanity's Last Exam, Inkling-Small scores 31.6% against Inkling's 29.7%. That advantage holds at every thinking budget, with its test-time compute curves sitting above Inkling's throughout. On SWEBench-Verified it clears 80%.
With these improvements, Inkling-Small surpassed Inkling on reasoning and agentic coding benchmarks. Inkling maintains an advantage on knowledge coverage and factuality. / On Humanity's Last Exam it scores 31.6%, ahead of Inkling's 29.7%, and the advantage holds at every thinking budget: Inkling-Small's test-time compute curves sit above Inkling's throughout. On SWEBench-Verified it exceeds 80%. — From the description of where it won, where it lost, and the specific scores
You can dial how much it thinks
There is one more trait that looks useful in practice: variable thinking effort, a control over how much reasoning the model spends.
The official performance comparison charts are drawn by sweeping reasoning effort from minimal to xhigh and tracing the resulting performance-cost curve. In other words, the balance between cost and performance is yours to set per use case. Work you want done cheaply and quickly and work you want thought through can run on the same model.
Pricing is published as well. Output pricing is $4.05 per million tokens for Inkling and $1.20 for Inkling-Small — under a third.
Sweeping reasoning effort from minimal to xhigh traces the performance-cost curve (dollar output price per sample) for Inkling-Small and Inkling on Terminal-Bench 2.1, HLE (no tool), and IFBench. / Inkling output pricing is $4.05 / 1M tokens and Inkling-Small output pricing is $1.20 / 1M tokens; for comparison-model pricing, we use the model provider's official pricing when possible. — From the description of variable reasoning effort and the output pricing of both models
What it takes to actually run it
With the weights published, you can run it in your own environment. The requirements are not light, though.
Quantization drops the GPU requirement sharply
Two checkpoints are distributed.
The two checkpoints and the hardware they need (per the official model card)
That is more than a threefold difference. The quantized NVFP4 checkpoint fitting on a single B300 changes the realism of self-hosting considerably. Note that W4A4 mode additionally requires SM100+ architecture.
Running it means assembling inference server config files and request bodies. Checking the structure as you go keeps you from getting stuck.
The BF16 checkpoint requires a GPU cluster with at least 600 GB of aggregated VRAM. This can be met with either of the following configurations: 4x NVIDIA B300 GPUs / 8x NVIDIA H200 GPUs / The NVFP4 checkpoint offers a quantized alternative that reduces the aggregated VRAM requirement to at least 180 GB. This checkpoint can be run as: W4A4 on 1x NVIDIA B300 GPU (note: W4A4 mode additionally requires SM100+ architecture) / W4A16 on 2x NVIDIA H200 GPUs / Running the model directly on GPU hardware requires an inference deployment framework–either SGLang, vLLM, TokenSpeed, Unsloth, or Hugging Face, along with all of their respective dependency libraries. — From the hardware requirements for the two checkpoints and the inference frameworks needed
What you can feed it, and under what conditions
Multimodal does not mean anything goes in unconditionally. The official model card spells out the input conditions.
Images can be any pixel-based format, with each dimension between 40px and 4096px recommended for best performance. Audio should be WAV at 16kHz sampling, with length ideally under 2 minutes. This is where the parent model differs: Inkling is specified as within 20 minutes. If you are working with long audio, the parent is the better fit — a clean division of labor.
Image: Any pixel-based image input. For optimal performance, each image dimension should be between 40px to 4096px. / Audio: WAV format, sampled at 16kHz. For optimal performance, audio length should ideally be under 2 mins. / Inkling-Small supports a context window of up to 1M tokens. — From the input conditions for images and audio, and the context window
Three ways to get it
The weights are downloadable from Hugging Face, with the NVFP4 version distributed in a separate repository.
Beyond self-hosting, you can use the model through the company's own fine-tuning platform, Tinker, which provides API access. Tinker Playground offers text, image, and audio chat. Third-party inference providers offer API access as well. Having a path that does not start with procuring GPUs is a practical advantage when you are just beginning to evaluate.
The weights are available for download through Hugging Face here and here for NVFP4. Developers can also access the model using the Tinker fine-tuning platform, which provides API access. / The model is also available via API access through third party inference providers. — From the description of distribution channels and means of API access
We are releasing the full weights of Inkling-Small. We're also making it available for fine-tuning on Tinker, and for text, image, and audio chat on Tinker Playground. — From the description of the weight release and availability on Tinker and Tinker Playground
Comparing it against models on the same footing
The competitive setting Inkling-Small sits in is also readable from the official material.
Who else is on the chart
The other companies' models plotted in the official performance comparisons include DeepSeek V4-Flash, Gemini 3.5 Flash-Lite, and GPT 5.6 Luna. On the GDPval-AA v2 evaluation, Inkling-Small sits at 1269 against Inkling's 1238.
Among open-weights releases, Kimi K3 and GLM-5.2 occupy the same ground. What is happening in this area is not a race to add scale, but a race to deliver the same performance in something smaller. The "comparable at a quarter the size" framing sits squarely in that current.
Spider chart comparing Inkling-Small, Inkling, DeepSeek V4 Flash, Gemini 3.5 Flash-Lite, and GPT 5.6 Luna on ten evaluations scored from zero to one hundred. / GDPval-AA v2 · Inkling-Small: 1269, 23k output tokens/task / GDPval-AA v2 · Inkling: 1238, 28.6k output tokens/task — From the models listed as comparison points and their GDPval-AA v2 scores
The Apache 2.0 choice
The license is easy to overlook. Both Inkling-Small and its parent Inkling are published under Apache 2.0.
That is a permissive license, usable broadly including commercially. The official material states that the weights are released to support research, fine-tuning, and integration into third-party products. Benchmark numbers move with measurement conditions; license terms do not. Being able to try the model on your own problem and judge for yourself is the more dependable advantage.
It is released with open weights to support research, fine-tuning and integration into third-party products by downstream developers. — From the stated purpose of releasing the weights
Conclusion: the compact model's value is in having trained later
The eye-catching line about Inkling-Small is "comparable at a quarter the size," but what is underneath is more interesting. The compact model beat its parent on reasoning and agentic coding because starting later let the training process improve — and because the parent could serve as its teacher through distillation. Rather than trimming scale and arriving at the same place, it collected the advantages of going second.
Just as important is the official statement that the parent keeps the advantage on knowledge coverage and factuality. Choosing between them by use case is the intended premise. Long audio points to the parent; cost, speed, reasoning, and coding point to the compact one — a split the official material lays out directly.
On the practical side, the drop to a single GPU with the quantized checkpoint is what matters. The weights are Apache 2.0, and one B300 will run them. That makes running it on your own problem faster than staring at benchmark numbers. Reaching for Tinker before procuring GPUs is a viable way in, too. When you get to assembling configs and requests, getting the structure right before sending cuts down on accidents.
