Inkling: Mira Murati's Lab Ships the Top U.S. Open-Weight Model

Thinking Machines Lab — the startup founded by former OpenAI CTO Mira Murati — just shipped its first model, Inkling, and it's open-weight. Inkling is a 975-billion-parameter multimodal mixture-of-experts model that debuts at 41 on the Artificial Analysis Intelligence Index, making it the strongest open-weights release from a U.S. lab. The weights are on Hugging Face today. The Runyard question, as always: what does a near-trillion-parameter open model actually mean for people running AI on their own hardware?

Inkling is a decoder-only, multimodal mixture-of-experts model with 975 billion total parameters and roughly 41 billion active per token. It was trained on 45 trillion tokens spanning text, images, audio, and video, so it reasons natively across all four modalities — though for now it outputs text only, including code, styled artifacts, and structured data. It ships with a 1-million-token context window in the downloadable weights (256K via the company's Tinker API) and was explicitly designed to give calibrated answers and flag uncertainty rather than confidently guess.

Thinking Machines is refreshingly honest about positioning: Inkling is "not the strongest overall model available today, open or closed." It's built as a well-rounded, customizable foundation for enterprises to fine-tune on their own data via Tinker, not a leaderboard-topper. Even so, it clears a meaningful bar — on the Artificial Analysis Intelligence Index it scores 41, ahead of the previous leading U.S. open model, Nvidia's Nemotron 3 Ultra (38), and well above Gemma 4 31B (29) and gpt-oss-120b (24).

There's also a nice efficiency claim with teeth: Thinking Machines says Inkling reaches comparable coding performance while using about a third as many tokens as Nemotron 3 Ultra. Fewer output tokens means lower latency and, if you're renting inference, lower cost — the same reason token efficiency keeps showing up as a headline metric this year. It's also a reminder that raw parameter count is a poor proxy for real-world cost: a model that thinks in a third of the tokens can be cheaper to run than a smaller one that rambles, whether you're paying an API or your own electricity bill.

One more design detail matters for anyone who cares about running models: Inkling is natively multimodal on the input side, trained jointly on text, images, audio, and video rather than bolting a vision encoder onto a text model after the fact. That joint training is expensive and hard to replicate, which is a real argument for open weights — you get a frontier-grade multimodal backbone to fine-tune without paying to train one, even if you only ever run it in the cloud.

Directly? Almost certainly not — and Thinking Machines doesn't pretend otherwise. The full BF16 checkpoint needs a GPU cluster with at least 2 TB of aggregated VRAM. The model also ships in a well-calibrated NVFP4 variant, which drops the requirement to around 600 GB of aggregated VRAM — still roughly eight 80 GB data-center GPUs, not a desktop. If you're new to why parameter count translates so directly into memory, our explainer on [how local LLM inference actually works](/blog/how-local-llm-inference-actually-works) covers why loading the weights, not the math, is the wall you hit first.

What is genuinely interesting for local inference is how Inkling was packaged. Shipping a native NVFP4 checkpoint — 4-bit floating point — rather than making the community reverse-engineer a quant is a sign of where open releases are heading: quantization-aware, inference-ready weights out of the box. Inkling also includes speculative MTP (multi-token prediction) layers for faster decoding, the same class of trick that speeds up other frontier models. Neither makes it fit on your GPU, but both make the eventual hosted and community quants cheaper and quicker to serve.

So the practical read for a home lab is the same as with any near-trillion-parameter release: rent it when you need its ceiling, and run a smaller open model for daily work. If you want something in the same open-weight lineage you can actually load, Gemma 4 31B — which appears right on that Intelligence Index chart — runs comfortably on consumer hardware; we walk through it in [Run Gemma 4 Locally for Free](/blog/run-gemma-4-locally-free-google-ai). To see exactly which models and quants fit your card, check [how much VRAM you actually need](/blog/how-much-vram-to-run-local-llms).

# Inkling's open weights are on Hugging Face. The NVFP4 variant is the
# lighter one (~600GB aggregated VRAM) — still a multi-GPU / cluster job:
pip install -U huggingface_hub
huggingface-cli download thinkingmachines/Inkling \
  --include "*nvfp4*" --local-dir ./inkling-nvfp4

# Realistic local path: run a model that fits your GPU today.
# Gemma 4 31B (on the same benchmark chart) via Ollama:
ollama pull gemma4:27b            # Q4_K_M, ~fits 24GB VRAM
ollama run gemma4:27b

# Or gpt-oss-120b with expert offload to CPU RAM in llama.cpp:
llama-cli -m gpt-oss-120b-Q4_K_M.gguf -ngl 99 -c 8192 \
  -ot "\.ffn_.*_exps\.=CPU" -p "Explain NVFP4 in two sentences."

For the last two years the strongest open-weight models have overwhelmingly come from Chinese labs — DeepSeek, Qwen, GLM, Moonshot's Kimi line — while U.S. frontier labs kept their best weights closed. Inkling is notable precisely because it flips that pattern: a well-funded American lab, led by one of the people who built ChatGPT, choosing to publish weights rather than hide them behind an API. That changes the supply of open models developers can legally fine-tune, audit, and self-host, and it puts competitive pressure on other Western labs to do the same.

For the local-AI community the second-order effects are the interesting part. Public weights mean independent quantizers can produce GGUF, EXL2, and AWQ builds; hosting providers can compete on price; and researchers can study Inkling's routing and calibration behavior directly. Even a model you can't fit on your desk raises the ceiling for everyone, because the techniques baked into it — native NVFP4, speculative MTP layers, joint multimodal training — get copied into the smaller models that do run at home. If you're choosing a coding model to actually install this week, our roundup of the [best local LLMs for coding in 2026](/blog/best-local-llms-for-coding-2026) is the practical companion to this news.

Inkling wasn't the only major open release in a busy week. A few others worth tracking if you run models locally:

• ▸Moonshot AI shipped Kimi K3, a 2.8-trillion-parameter open-weight MoE that topped the Frontend Code Arena at 1,679 and scored 88.3% on Terminal-Bench 2.1; full weights land July 27. We break down the local-inference reality in our [Kimi K3 guide](/blog/kimi-k3-largest-open-weight-model-run-locally).
• ▸DeepSeek is set to push a stable DeepSeek V4 release on July 24, and DeepSeek-V4-Flash is already runnable via Unsloth (unsloth>=2026.7.2) with Thinking toggles. (Source: Unsloth docs, unsloth.ai/docs/new/changelog)
• ▸Unsloth's Qwen3.6-27B dynamic GGUFs now run and fine-tune in about 23 GB of RAM, one of the strongest mid-sized models you can keep on a desktop. (Source: huggingface.co/unsloth/Qwen3.6-27B-GGUF)
• ▸Unsloth Studio added post-training export to NVFP4, FP8, and imatrix GGUFs plus a built-in llama-swap API mode and 3-5x faster MoE training. (Source: Unsloth changelog, unsloth.ai/docs/new/changelog)

Inkling is a milestone for open, multimodal AI — but the model that ships your work is the one that fits your box. Drop your GPU into the [Runyard VRAM Calculator](/tools/vram-calculator) to see which quant of Gemma 4, Qwen3.6, or gpt-oss your hardware can actually load, with context length and expected speed included. Weighing open-weight options head to head? [Runyard Compare](/compare) lines them up, and [Model Radar](/) surfaces the best model your machine can run today. Celebrate the near-trillion-parameter headlines; ship with the model that runs on your desk.