Inkling 2 Small: Thinking Machines' 594B MoE model explained

Inkling 2 Small is a mixture-of-experts model from Thinking Machines Lab with 594B total parameters and 17B active per token. It takes text and images as input, was announced on November 5, 2026, and is available now for fine-tuning and sampling on Tinker, the lab's training API. Thinking Machines says the full weights will follow under the Apache 2.0 license once external safety testing and red-teaming are finished.

That release order is the interesting part. Most open models arrive as a download first and a hosted endpoint later. Inkling 2 Small starts as something you train on through an API, and becomes a file you can run yourself afterwards. Here is what the model is, how it is built, and how the Tinker workflow fits around it.

What is Inkling 2 Small?

It is the first model in the second generation of Thinking Machines' Inkling family, and the lab positions it as a base for fine-tuning rather than mainly as a chat product. The headline facts:

On the Artificial Analysis Intelligence Index, an aggregate score built from many third-party evaluations, Thinking Machines reports a score of 31. Coverage of the launch puts its predecessor, Inkling Small, at 13 on the same index. The lab also lists 86.3% on SWE-Bench Pro v2 (Hard) and 72.1% on DeepSWE, both coding benchmarks where the model has to fix real issues in real repositories.

For context, here is how it sits next to the first-generation models:

So the "Small" label is relative. It is larger than Inkling Small and has fewer active parameters than the original Inkling, but Thinking Machines describes it as more capable than the whole first generation.

How is Inkling 2 Small built?

A mixture-of-experts (MoE) model splits its feed-forward layers into many smaller networks, called experts, and uses a router to send each token through only a few of them. Compute per token follows the active count, here 17B, while memory follows the total, here 594B, because every expert has to be loaded. The same trade-off shows up in Mistral Large 4's open weights, just at a different scale.

Three other design choices are worth knowing about:

• Native NVFP4 training. NVFP4 is NVIDIA's 4-bit floating-point format for Blackwell GPUs. Inkling 2 Small was pretrained in it directly, rather than trained at higher precision and quantised afterwards. Thinking Machines has said a detailed write-up of the recipe will follow.
• Image input. A 292M-parameter vision encoder turns image patches into embeddings that are interleaved with text tokens, so the model reads screenshots, charts and documents in the same sequence as the prompt. There is no audio input in this model.
• Long context. Later pretraining stages ran at 512K and then 1M tokens, and reinforcement learning used a 256K window with compaction, a technique where older parts of a long agent trajectory are summarised to make room for new ones.

How does controllable effort work?

Inkling 2 Small is a reasoning model with variable effort: you can tell it how long to think before answering. Low effort gives fast, short answers. High effort spends more tokens on reasoning, which helps with hard coding or multi-step tool use.

According to the announcement, the lab trained this in by sampling effort levels at random during reinforcement learning, conditioning the model on the chosen level and penalising length. The result is one set of weights that behaves differently depending on the setting, instead of separate fast and slow models.

The cost side is real. Third-party measurements report that the model uses noticeably more output tokens per task than its predecessor. If you run it in a loop, set effort per task instead of leaving it at maximum everywhere.

How do you fine-tune Inkling 2 Small on Tinker?

Tinker is a training API where you write the training loop in Python on your own machine and Thinking Machines runs the GPUs. Training uses LoRA (low-rank adaptation), which freezes the base weights and trains small extra matrices on top, so a fine-tune is cheap to store and swap.

The API is built from a handful of primitives:

• forward_backward runs a batch through the model and accumulates gradients for a loss function.
• optim_step applies the accumulated gradients with an optimiser such as Adam.
• sample generates completions, for evaluation or for reinforcement learning rollouts.
• save_state and save_weights_for_sampler checkpoint your run so you can resume or serve it.

A minimal supervised loop looks roughly like this. Copy the exact base model string from Tinker's model list, and build training_data from your own examples first.

import tinker

BASE_MODEL = "<Inkling 2 Small ID from the Tinker model list>"

service_client = tinker.ServiceClient()  # reads TINKER_API_KEY
training_client = await service_client.create_lora_training_client(
    base_model=BASE_MODEL, rank=32
)

for batch in training_data:
    fwd = training_client.forward_backward(batch, "cross_entropy")
    opt = training_client.optim_step(tinker.AdamParams(learning_rate=1e-4))
    await fwd
    await opt

checkpoint = await training_client.save_weights_for_sampler(name="my-run")
sampler = await service_client.create_sampling_client(model_path=checkpoint.path)

Every call returns a future, so you can queue several before waiting on them. Because you own the loop, the same primitives cover supervised fine-tuning, preference tuning and reinforcement learning.

Thinking Machines claims the new model adapts faster than its predecessors on the same data and algorithm. In one of its examples, Inkling 2 Small reached Inkling Small's final score on a financial-summarisation task in 75 training steps. Fine-tuned checkpoints are meant to become downloadable once the weights are released.

What are the known limitations?

The lab and early coverage list a few:

• Answers tend to be verbose, which adds token cost on top of the effort setting.
• In codebases with many available skills or tools, it does not always pick the best one.
• It is tuned more for agentic and technical work than for polished chat replies.
• Text and images only; no audio.

None of these are unusual for a model at this stage, but they shape where it fits. It looks strongest as a base you adapt to a narrow task, not as a drop-in general assistant.

Key takeaways

• Inkling 2 Small is a 594B-parameter MoE with 17B active, text and image input, and training up to 1M tokens of context.
• It launched on November 5, 2026 on Tinker, with Apache 2.0 weights planned after external safety testing.
• It was pretrained natively in 4-bit NVFP4 and supports variable reasoning effort.
• Tinker exposes training as a few Python primitives, so you control the loop while the lab runs the GPUs.
• Expect long outputs; set effort per task to keep costs predictable.

FAQ

Can you download Inkling 2 Small today?

Not yet. At launch it is available only through Tinker for fine-tuning and sampling. Thinking Machines plans to publish the weights under Apache 2.0 after safety testing and red-teaming are complete.

Does Inkling 2 Small support images?

Yes. It accepts text and images through a 292M-parameter vision encoder and returns text. It does not take audio input.

Do you need Tinker to use Inkling 2 Small?

For now, yes. Once the weights are released, you will be able to run and fine-tune it on your own hardware, subject to the memory needs of a 594B-parameter model.