🚀 Inkling — A 975 Billion Parameter OS Model

Open-source LLM just got a new member, Inkling from Thinking Machines!

Photo by jonakoh _ on Unsplash

The release of Inkling 975B from Thinking Machines marks a shift in how we approach large-scale model ownership. Most developers are used to a trade-off, where you use a massive, closed-weight API for reasoning or a smaller open source model for control.

For Non-Members: Read here!

Inkling attempts to bridge this by offering a 975 billion-parameter Mixture-of-Experts (MoE) architecture, where the full weights are available for local deployment and deep customization. It’s less about having a ‘giant’ on disk and more about having a massive knowledge base that you can actually modify.

But don’t let that huge number scare you off. While it has nearly a trillion parameters sitting on disk, it is incredibly efficient in how it actually thinks.

Let’s get into the details of Inkling.

What Is Inkling?

To start, we have to look at the scale. Inkling is a Mixture-of-Experts (MoE) Transformer. This means that for every single word (or token) the model processes, it doesn’t use all 975 billion parameters. Instead, it only activates 41 billion parameters. This gives you the knowledge and reasoning capacity of a massive model with the speed and cost profile of a much smaller one.

Here are the critical stats you need to know:

- Total Parameters: 975B

- Active Parameters: 41B

- Context Window: Up to 1 million tokens

- Training Data: 45 trillion tokens, including text, images, audio, and video

- Hardware: Trained on NVIDIA GB300 NVL72 systems

Thinking Machines Lab also teased Inkling-Small, a version with 276B total and only 12B active parameters, which actually matches the big model on several benchmarks thanks to a more refined training recipe.

Inkling’s Architecture

The team didn’t just follow the LLM’s standard playbook; they made some very specific technical choices to ensure Inkling could handle massive amounts of data and long-context reasoning without slowing to a crawl.

1. The Mixture-of-Experts (MoE) Strategy

Inkling’s MoE design is heavily inspired by DeepSeek-V3. Each MoE layer has 256 routed experts and 2 shared experts.

For every token, the model picks 6 routed experts to do the work. They use a sigmoid-based router that helps in balancing the load across all the experts, so no single one gets overwhelmed during training.

Deepseekv3

2. Attention and Positioning

Most models these days use something called Rotary Positional Embedding (RoPE), but Inkling went a different way. They used Relative Positional Embeddings because their tests showed it works better when you are trying to extrapolate to very long sequences, like that of a 1-million-token window.

They also interleaved sliding-window and global attention layers at a 5:1 ratio. This means for every five layers that look at local text nearby, one layer looks at the entire 1-million-token context. This keeps the memory usage (KV cache) manageable while still letting the model remember things from thousands of pages back.

3. Native Multimodality (No Encoders!)

This is one of the coolest technical bits of this release. Most models use separate encoders for vision and audio, then plug them into the brain, which is the LLM.

But Inkling is encoder-free.

• Images: They are split into 40x40-pixel patches and fed directly into the model via a lightweight embedding layer.
• Audio: Sound is turned into dMel spectrograms and processed just like text tokens.

This native approach allows Inkling to reason across text, images, and audio all at once. It can transcribe speech, follow spoken instructions, and even use a Python tool to zoom and crop an image it is looking at to understand it better.

Training: 45 Trillion Tokens and 30 Million Rollouts

To train a model that size takes more than just raw power. The team used a hybrid optimization strategy. They used an optimizer called Muon for the large matrix weights and Adam for everything else. They even tied the weight decay to the square of the learning rate to keep the model weights stable over months of training.

The Emergence of Telegraphic Reasoning

After the initial training, they put Inkling through large-scale Reinforcement Learning (RL) with over 30 million rollouts. During this process, they noticed something strange and fascinating: the model’s “Chain of Thought” (how it talks to itself before answering) started to change.

Early in training, the model would talk to itself in perfect, verbose English: “We need to understand the operator…”. By the end of RL, it became “telegraphic” and dropped all the fluff to save efficiency: “We need to determine the eigenvalue problem…”. It still got the right answer, but it learned to be more concise just to save on “thinking cost”.

Where does the performance stand?

Inkling wasn’t built to win a specific benchmark family. Instead, the team prioritized breadth across agentic, reasoning, and multimodal tasks.

On a spider chart of ten different evaluations, Inkling shows a high-cobalt area of coverage rather than a single spike. This matters because if you are fine-tuning for a specific workflow, you want a base that hasn’t been over-fitted to a narrow set of human-preferred chat patterns.

One area where Inkling really shines is Agentic Coding. It was trained to run inside coding harnesses and can handle 40 iterations of feedback to build complex things like multiplayer games. It currently ranks among the strongest open-weight models on the Design Arena Web Dev leaderboard.

Controllable Thinking Effort

One of the most practical features for developers is Controllable Thinking Effort. Usually, a model uses the same amount of power for a simple “Hello” as it does for a complex math problem. With Inkling, you can turn the effort up or down.

On a benchmark like Terminal Bench 2.1, Inkling can match the performance of other top-tier models (like Nemotron 3 Ultra) while using only one-third as many tokens. This is huge for real-world apps where paying for tokens and waiting for latency are the biggest headaches.

Epistemics: Engineering for Calibration.

A model that is confident when it is wrong is a liability in production.

Inkling was trained specifically for calibration, using RL against proper scoring rules to ensure it expresses the appropriate level of uncertainty. Instead of just guessing, the model is incentivized to say ‘I don’t know’ or provide a hedged answer when the data is conflicting or missing.

This is supported by an automated claims grader that uses agentic web search to verify factual assertions during the training loop.

• Calibration: It avoids overconfident results and hallucination. And is trained to say “I don’t know” or give a “hedged guess” when it isn’t sure.
• The Claims Grader: During training, they used an agentic web search to verify every single factual claim the model made, penalizing it if it got things wrong.
• Censorship: It is specifically trained to answer directly on topics that are often censored in other models.

The Self-Finetuning Loop

The most compelling demonstration of the Tinker platform is the self-finetuning loop. In this recursive workflow, Inkling acted as its own architect: it drafted a training plan, generated the synthetic data required to meet a specific objective (like avoiding the letter ‘e’), and then used the Tinker API to execute the post-training.

The entire pipeline, from generating the ‘lipogram’ objective to switching to the newly updated weights, was completed in 27 minutes. This moves the model from being a static file to an active participant in its own optimization.

Using a platform called Tinker, the model:

1. Wrote its own training plan and objective.
2. Generated its own synthetic data.
3. Ran the fine-tuning job.
4. Evaluated the result and switched its own weights to the new version.

In one demo, they asked it to become a lipogram model, i.e., a model that never uses the letter ‘e’. Prompting alone usually fails at this, but after the self-finetuning loop (which took about 27 minutes), the model successfully switched to a version of itself that could chat without ever using an ‘e’.

How to get access

Since this is an open-weights release, you can find the full weights on Hugging Face. They’ve even released a special version (NVFP4) optimized for the new NVIDIA Blackwell systems.

If you don’t want to host it yourself, it’s already available on APIs like TogetherAI, Fireworks, and Databricks.

Conclusion

Inkling 975B is a massive achievement for the open-source community. It’s not just about the size; it’s about the flexibility.

Between the native multimodality, the controllable thinking effort, and the ability to rapidly fine-tune it on the Tinker platform, it’s a model designed to be made your own.

Whether you’re building a voice-based AI assistant or a complex coding agent, Inkling provides a trillion-parameter foundation that you can actually control.

Digital Products

ML Interview Book: Crack Your Next ML Interview with Machine Learning Interview Playbook

Productivity Tool: ***Social Media Time Tracker: Take Back Your Time, a tool that annoys you when you log in to social media sites. Chrome Extension.***

Connect with the author

LinkedIn | YouTube | Threads | Instagram | Facebook