Thinking Machines' Inkling: A Trillion-Parameter Open Model That Sees and Hears
Mira Murati's Thinking Machines just shipped Inkling — a 975-billion-parameter, Apache-2.0 model that natively understands text, images and audio, handles a 1-million-token context, and fires only ~41B parameters per token. Here's what it is, how it benchmarks, what it takes to run, and the open-weights bet behind giving it away — with infographics you can skim.
On July 15, 2026, Mira Murati's Thinking Machines Lab shipped its first model — and it isn't a chatbot you log into. It's Inkling, a roughly one-trillion-parameter, open-weights, multimodal model you can download from Hugging Face, run on your own hardware, and fine-tune however you like. For a lab that stayed mostly quiet through its first year, it's a statement release.
Here's what Inkling actually is, what's clever about it, how it benchmarks — and the strategic bet behind giving it away.
TL;DR
Inkling is a 975B-parameter Mixture-of-Experts model with only ~41B active per token. It natively understands text, images and audio, handles a 1-million-token context, and was trained on 45 trillion tokens. It's Apache 2.0 — genuinely open-weights — and built to be fine-tuned, not just used. Running it needs datacenter hardware (~600 GB even at 4-bit), so most people will meet it through an API. See the full specs →
Who are Thinking Machines?
Thinking Machines Lab was founded in February 2025 by Mira Murati, OpenAI's former CTO, alongside a group of well-known researchers who left OpenAI and other frontier labs with her. It raised one of the largest seed rounds in tech history — about $2 billion at a ~$12 billion valuation, led by Andreessen Horowitz, with Nvidia, AMD, Cisco and Jane Street among the backers.
Before Inkling, the lab was known for two things. First, a steady stream of technical research on its "Connectionism" blog — work on reproducible inference and efficient fine-tuning rather than product launches. Second, Tinker, an API for fine-tuning open models that it launched in October 2025. Inkling is the piece that ties those threads together: a capable base model designed to be customized through Tinker rather than consumed as-is.
What Inkling is, in one picture
The headline number is 975 billion parameters — but that's not how much work Inkling does on any given token. It's a Mixture-of-Experts (MoE) model: the parameters are split across 256 "experts," and a router sends each token to just 6 of them, plus 2 shared experts that always run. So only about 41 billion parameters — roughly 4% — fire per token.
You get the knowledge capacity of a trillion-parameter model at something much closer to the inference cost of a 41B one. That sparsity is the trick behind every modern frontier open model — DeepSeek V4, Kimi K2, Qwen and others all use it — and Inkling pushes it further than most while stacking native multimodality on top.
Inside the architecture
A few design choices stand out beyond the raw size:
- Truly multimodal input. Inkling ingests text, images and audio natively — not through bolt-on adapters. A hierarchical MLP "patchifier" handles vision; audio is fed in as discretized mel-spectrogram tokens. Its training mix of 45 trillion tokens spanned text, images, audio and video.
- A 1-million-token context. To keep long context affordable, Inkling uses a hybrid attention scheme — roughly 5 local (sliding-window) layers for every 1 global layer — plus a relative attention mechanism instead of RoPE and a short 1-D convolution over hidden states.
- Adjustable reasoning effort. You can dial thinking from "none" up through minimal, low, medium, high and xhigh to "max", trading latency for depth on a per-request basis.
- Faster decoding built in. The release ships Multi-Token-Prediction (MTP) drafter layers for speculative decoding, so serving stacks like vLLM and SGLang can emit several tokens per step.
If the "1M context" and "MoE" jargon is new, our explainers on context windows and quantization unpack the mechanics.
How good is it?
Thinking Machines published a broad benchmark sweep pitting Inkling against the current frontier — Gemini 3.1 Pro, Claude Fable 5, GPT-5.6, DeepSeek V4, Kimi, GLM and Nemotron among them. It holds its own across reasoning, coding, vision and audio, and its multimodal breadth is unusual for an open model:
A fuller slice of the numbers, across the categories Thinking Machines reported:
| Category | Benchmark | Inkling |
|---|---|---|
| Reasoning | AIME 2026 | 97.1% |
| Reasoning | GPQA Diamond | 87.2% |
| Reasoning | HLE (with tools) | 46.0% |
| Coding | SWE-bench Verified | 77.6% |
| Coding | Terminal-Bench 2.1 | 63.8 |
| Vision | MMMU Pro (Standard 10) | 73.3% |
| Vision | CharXiv RQ (with Python) | 82.0% |
| Audio | MMAU | 77.2% |
| Audio | VoiceBench | 91.4% |
| Chat | Global-MMLU-Lite | 88.7% |
| Safety | StrongREJECT (refusal) | 98.6% |
Two caveats worth stating plainly. These are vendor-reported launch numbers, and independent replication takes time — treat them as "reported," not yet confirmed. And Inkling is explicitly not trying to top every leaderboard: the pitch is that a fine-tuned Inkling on your data beats a bigger generalist on your specific task.
Can you actually run it?
This is where reality bites for local-AI enthusiasts. Inkling is a datacenter model — there's no getting a 41B-active, 975B-total MoE onto a gaming GPU.
The three ways it ships:
- BF16 (full precision): ~2 TB of VRAM — a Hopper-or-later multi-GPU cluster. This is the reference checkpoint for research and fine-tuning.
- NVFP4 (official 4-bit): ~600 GB — fits a single high-memory 8-GPU server, and the intended way to serve it. Native FP4 wants Blackwell GPUs.
- 1-bit GGUF (community): an Unsloth build cuts VRAM ~95% to around 100 GB — but retains only ~74% top-1 accuracy, so treat it as experimental.
Support landed fast: Transformers 5.14+, vLLM, SGLang and llama.cpp all handle Inkling at launch, and it's available through Hugging Face Inference Providers with an OpenAI-compatible API. For nearly everyone, an API is the sane path — our cloud vs local AI comparison covers when self-hosting a model this big is actually worth it, and the Hardware Analyzer will tell you in seconds that your desktop can't (which, to be clear, it can't).
The real story: a model built to be changed
The most interesting thing about Inkling isn't a benchmark — it's the strategy. Most frontier labs ship a polished, closed model and rent you access to it. Thinking Machines did the opposite: it released the weights, under a permissive Apache 2.0 license, and framed the model as a starting point. The whole point of pairing Inkling with Tinker is that organizations take the open base, fine-tune it on their own data and domain, and run a specialist that a one-size-fits-all API can't match. In the company's own framing, it's built "for customization, not leaderboard dominance."
That's a real bet against the closed-API status quo — and it's the same logic driving a broader shift we've written about in why companies fine-tune open-source LLMs instead of calling an API. Inkling raises the ceiling on what an open base model can be: not a 7B you run on a laptop, but a trillion-parameter multimodal foundation you're free to reshape.
The bottom line
Inkling is the most ambitious open-weights release of 2026 so far: a 975B-parameter, natively multimodal, 1M-context model that a former OpenAI CTO's lab handed the world under Apache 2.0. You almost certainly can't run it on your own hardware — but you can download it, study it, fine-tune it and build on it, and that freedom is exactly the point.
It's also a signal. The gap between "what a closed frontier lab keeps behind an API" and "what anyone can download and modify" just narrowed again — and this time the model that narrowed it can see and hear.
Explore the specs and both precision builds on the Inkling model page → See how it stacks up against other open frontier models: DeepSeek V4 Pro → · Kimi K2 → Browse the full Model Library → or check your rig with the Hardware Analyzer →