Inkling (975B): What Open-Weights Mixture-of-Experts Really Means—and How to Fine-Tune It

You open a new model card and the numbers look almost suspiciously big: 975B parameters, Mixture-of-Experts (MoE), and a context window that reaches up to 1M tokens. For a second, it feels like a stunt—until you notice the more practical promise hiding under the headline: the weights are available so teams can tinker, not just call an API.

That’s the bet behind Thinking Machines Lab’s open-weights release, Inkling: a multimodal LLM (text, images, audio) built as an MoE transformer, released for download on Hugging Face and for fine-tuning on its Tinker platform. (thinkingmachines.ai)

Below, we’ll walk through what these specs actually mean in engineering terms, why MoE changes the economics, and what a beginner can do to start fine-tuning without getting lost in infrastructure fog.

The headline numbers: 975B total, 41B active (and why you should care)

Inkling is described as a Mixture-of-Experts transformer with 975B total parameters and 41B active. (thinkingmachines.ai)

At first glance, “975B” sounds like the model would be absurdly expensive to run. The trick is what “active” means.

Total vs. active parameters

• Total parameters are all the learned weights stored in the model.
• Active parameters are the subset used for a particular token during inference.

In an MoE model, the network contains many “experts” (specialized sub-networks). For each token, a router (a learned decision module) chooses which experts should process that token. That way, you can scale total model size without activating everything every time.

Inkling’s model card gives the concrete routing shape: it’s a 66-layer decoder-only transformer whose MoE feed-forward backbone routes each token to 6 of 256 experts, plus 2 shared experts active on every token. (thinkingmachines.ai)

So when people say “41B active,” they’re communicating the compute footprint per token rather than the total stored capacity.

What does “41B active” even mean in practice? It means your GPU budget is closer to what a much smaller dense model would cost, even though the model contains a far larger overall parameter set.

Multimodal by construction: text, image, and audio inputs

Inkling isn’t positioned as a text-only model that “also” accepts images or audio. It’s described as natively multimodal: images are encoded with a hierarchical patch encoder, audio uses discrete token encoding, and all modalities are projected into a shared hidden space before the decoder processes them jointly. (thinkingmachines.ai)

That shared-space detail matters: it’s one reason multimodal models can behave like generalists. Instead of running separate systems and stitching results together, the model learns cross-modal patterns while still using a single decoder.

The model card spells out practical input formats too:
- Text: UTF-8 encoded text
- Image: pixel-based inputs, recommended between 40px and 4096px per dimension
- Audio: WAV at 16kHz, with recommended length within about 20 minutes (thinkingmachines.ai)

In other words, multimodality here isn’t vague marketing. It’s tied to real preprocessing constraints.

Context window up to 1M tokens: what that unlocks (and what it costs)

Inkling supports a context window of up to 1M tokens. (thinkingmachines.ai)

A context window is the maximum amount of text (or tokenized multimodal content) the model can consider at once. More context is useful for things like:
- feeding long documents and asking questions across distant sections,
- doing multi-step coding where earlier files and requirements stay in view,
- long audio transcripts that need to preserve speaker-level details.

But longer context increases compute and memory use. Even with MoE reducing per-token activation costs, the attention mechanism still has to “look around” the sequence.

A nice practical detail: Inkling is also offered on Tinker with context length options of 64K and 256K tokens. (thinkingmachines.ai)

So most teams can start smaller (and cheaper) while still benefiting from the general architecture’s long-context design.

The training scale story: 45 trillion tokens across modalities

Inkling was pretrained on 45 trillion tokens spanning text, images, audio, and video. (thinkingmachines.ai)

“Tokens” are the basic units a model reads—text is split into subword pieces; images and audio are converted into sequences of discrete representations so they can enter the same transformer machinery.

At a beginner level, the key takeaway is less about exact dataset composition and more about coverage: a model trained over mixed content types is more likely to handle instructions that jump between modalities without breaking narrative flow.

Controllable thinking effort and calibrated confidence

One of the more interesting engineering directions in the release is the idea of controllable thinking effort: you can vary how much computation (often described as “how many tokens” the model generates while reasoning) a run consumes, trading speed/latency against performance. (thinkingmachines.ai)

The announcement describes training the model to learn this behavior by changing the system message and adjusting a per-token cost during effort sweeps. (thinkingmachines.ai)

Separately, Inkling emphasizes forecasting and confidence calibration—the ability to express uncertainty rather than sounding confidently wrong. The announcement frames this as crucial for real-world prediction tasks where information is missing or conflicting. (thinkingmachines.ai)

For builders, the practical implication is that “better output” isn’t only about higher benchmark scores; it’s also about how the model behaves when the problem is underdetermined.

Open weights, Apache-2.0: downloading is allowed—and that changes the game

On Hugging Face, Inkling’s license is listed as Apache-2.0, and the repo publishes the model files for download. (huggingface.co)

Open-weights releases are different from API-only releases because they let teams:
- run inference in their own infrastructure,
- fine-tune on private data,
- evaluate behavior with their own harnesses,
- keep long-term control over the system.

For companies with compliance requirements, that matters as much as raw capability.

Running Inkling on your own hardware: BF16 vs. quantized NVFP4

If you’re imagining “download the weights and run it on a single workstation,” the model card is blunt: Inkling’s checkpoints are set up for serious GPU clusters.

The model card lists two checkpoint formats:
- BF16: requires at least 2 TB aggregated VRAM (example configurations: 8× NVIDIA B300 or 16× NVIDIA H200)
- NVFP4: a quantized alternative reducing requirement to at least 600 GB aggregated VRAM, with suggested modes like W4A4 on 4× B300 (with SM100+ noted) or W4A16 on 8× H200 (thinkingmachines.ai)

It also names common inference deployment frameworks (SGLang, vLLM, TokenSpeed, Unsloth, or Hugging Face tooling). (thinkingmachines.ai)

This is the part where many beginners feel discouraged—until you realize the release also targets fine-tuning via Tinker, which shifts the heavy lifting to Tinker’s training infrastructure.

Fine-tuning on Tinker: LoRA in plain language

Tinker is presented as a customization platform where Inkling is available for fine-tuning “today,” and Tinker’s docs describe LoRA Fine-Tuning as a model-agnostic approach. (thinkingmachines.ai)

LoRA stands for Low-Rank Adaptation. Instead of updating all the huge original weights during fine-tuning, LoRA adds small trainable matrices that approximate how the model should change for your task.

The benefit for teams is practical:
- less training data and compute than full fine-tuning,
- easier iteration cycles,
- adapters that can be swapped per use case.

Tinker’s documentation frames this as LoRA training “from 1B to 1T+ parameters,” including dense and MoE architectures, and supports both text and vision fine-tuning workflows. (tinker-docs.thinkingmachines.ai)

Since Inkling is a multimodal MoE, that combination is exactly the kind of architecture Tinker positions itself to support.

Putting it together: what “open-weights Inkling” enables

Inkling’s release isn’t just “a large model is downloadable.” It’s a specific engineering bundle:
- MoE routing that keeps active compute manageable compared to the full parameter count (thinkingmachines.ai)
- multimodal encoding so you can build agents that handle text + image + audio in one model (thinkingmachines.ai)
- long-context capability for workflows that span large materials (thinkingmachines.ai)
- controllable reasoning effort and an emphasis on calibrated confidence (thinkingmachines.ai)
- open-weights availability under Apache-2.0 and fine-tuning via Tinker with LoRA (huggingface.co)

So the real story is about control: you can adapt a frontier-ish generalist foundation model toward domain-specific needs without having to negotiate every new feature through an external API timeline.

Inkling leaves an unmistakable footprint: it treats open-weights as a starting point for customization, not an endpoint. Once you understand how MoE changes the economics of large models, how context length affects real workflows, and how LoRA fine-tuning lets teams specialize without re-training everything, the headline numbers stop feeling like magic and start feeling like engineering choices.