Inkling, up close

On July 15, 2026, Thinking Machines Lab — Mira Murati's lab — shipped its first foundation model. Inkling is a 975B-parameter (41B active) open-weights, natively multimodal Mixture-of-Experts, released under Apache 2.0. I spent a while pulling it apart: reading the model card and serving recipe line by line, and cross-checking every marketing claim against independent leaderboards. This is the write-up.

The honest one-liner first, because it reframes everything else: Inkling is one of the strongest open-weights models available today, and it is not a frontier model — and Thinking Machines says so themselves. Their own announcement: "Inkling is not the strongest overall model available today, open or closed." So the interesting story here isn't the leaderboard. It's the architecture choices, the real-time system Inkling was quietly built to serve, and the business bet underneath it all.

What it is, in one screen

• 975B total / 41B active sparse MoE · 66-layer decoder-only transformer
• Natively multimodal — text, image, and audio in; text out
• 1M-token context · trained on 45 trillion multimodal tokens
• Apache 2.0, weights on Hugging Face (BF16 + a quantized NVFP4 checkpoint)
• A controllable reasoning_effort dial, agentic tool-use, and first-class fine-tuning via their Tinker platform
• A preview sibling, Inkling-Small (276B / 12B active)

The architecture: two bets worth noticing

Strip away the headline number and most of Inkling is the 2024–2026 open-weights playbook, assembled with taste and scaled up. The MoE core is close to a DeepSeek-V3 recipe — a sigmoid router with auxiliary-loss-free load balancing, fine-grained routed experts plus always-on shared experts. The 5:1 sliding-window-to-global attention split is the same ratio Gemma 3 uses. The Muon+Adam optimizer split is exactly how Kimi K2 trains. None of that is a departure; it's good engineering converging on what works.

Two choices genuinely cut against the grain of a 2026 frontier model:

1. It drops RoPE. Rotary embeddings are near-universal — Llama, Qwen, Gemini, DeepSeek, Mistral all use them, and most long-context work is about extending RoPE, not replacing it. Inkling instead adds a learned, per-head relative-position term straight into the pre-softmax logits.¹1 Which is why its attention block carries a fourth "qkvr" projection, on top of the usual query/key/value. Relative-bias schemes are known to extrapolate more gracefully, so it's defensible — but it's a minority position, and a notable one at this scale.

2. It puts short convolutions inside a dense-attention MoE. Four small depthwise convolutions per layer, wired into both the attention and MoE residual paths, borrowed from the sub-quadratic/hybrid-recurrent lineage.²2 Primer, Griffin, Mamba — the short-conv and gating lineage these depthwise convs come from. Those tricks usually live in linear-attention models, not a softmax-attention frontier MoE.

I'll resist over-selling it, though. When I adversarially checked "these are meaningful departures from standard practice," the verdict was overstated: the Muon+Adam split is simply how Muon is used, and the encoder-free multimodal stack (discretized-mel audio, raw image patches) reuses named prior art. Only the RoPE drop is really unusual — and even that is a revival of a pre-RoPE idea. This is excellent systems taste, not a clean-sheet architecture.

Where it actually lands

Every headline number is reported at effort=0.99.³3 Inkling's maximum test-time-compute ceiling — so the default-effort scores you'd actually see in production sit lower than everything in the table below. Against the actual July-2026 frontier:

Read honestly, this trails the closed frontier across the board — which is exactly what the lab told you. The right frame is to judge Inkling against other open-weights models, and there it wins or ties on several axes. Its genuinely weak spots are HLE (roughly half the leader) and SimpleQA factuality. It also trails the open Chinese coders — GLM 5.2 and Kimi K2.6/K2.7 — on agentic coding like Terminal Bench. And one number to treat with suspicion: VoiceBench 91.4% sits above any score on the public leaderboard, so I'd file it as vendor-reported until reproduced.

Judge it as an open-weights model and it's arguably the strongest US release on calibration, factuality, safety, and audio. Judge it as a frontier model and it loses to GPT-5.6, Gemini 3.1, and Claude across the board.

What's genuinely differentiated

Three things hold up under scrutiny, and none of them are on the leaderboard's front page:

• Calibration & factuality. A positive Artificial-Analysis Omniscience score (+2.1) — best among US open models, though the leading Chinese open models (Kimi K2.6, GLM 5.2) score higher. They RL-trained explicitly for calibrated confidence, over 30M+ rollouts. (More on this in the open-weights roundup.)
• Safety among open models. Best-in-open on FORTRESS adversarial (78%) and StrongREJECT (98.6%), paired with a deliberately contrarian "answer directly on sensitive topics" stance.
• Audio, and the system behind it. This is the part most coverage missed.

Inkling is the brain of a two-model system

Inkling was built to be the asynchronous background reasoner in Thinking Machines' "interaction models" architecture. A small, always-resident full-duplex model (TML-Interaction-Small, 276B/12B) handles the live voice-and-video conversation in 200ms micro-turns — listening while it talks, no separate voice-activity-detection harness. When a turn needs real reasoning, it hands the whole conversation to Inkling, keeps talking, and splices Inkling's streamed results back in at a natural pause.

The tell is one benchmark row: the small model alone scores 75.7 on BigBench Audio, but with Inkling as its background agent it jumps to 96.5 — matching GPT-realtime-2 at max effort, while still answering at 0.4-second latency. That's the whole thesis: reasoning-model intelligence at non-thinking-model latency, by splitting the two jobs across two models that share context.

(A correction to a lot of the launch coverage, including my own first read: Inkling itself outputs text only. The native speech — discretized-mel in, flow-matching decoder out — lives in the interaction model, which is still a closed research preview. Inkling is the open, downloadable half.)

The strategy underneath

Why open-weight a 975B model at all? Because the model isn't the product — Tinker is. Thinking Machines sells the fine-tuning-and-customization layer; Inkling is the strong open base that makes that layer worth paying for. It's a deliberate inversion of the closed-API playbook, and the reception framed it as "America's DeepSeek" — the first competitive non-Chinese open-weights model since Llama 3.

Two caveats keep it honest. "Open" is not "free": the BF16 checkpoint needs ~2 TB of VRAM, and even the NVFP4 quantization needs ~600 GB — a datacenter, not a workstation. And on Tinker its per-token pricing lands above the open-model median. The realistic access path for most people is a hosted endpoint (Together, Fireworks, Modal, Databricks, Baseten) or the smaller sibling.

How I'd fine-tune it

Tinker is worth understanding because it's not "upload data, click train." It's a low-level LoRA training API: you write an ordinary Python loop on a CPU-only box, and Tinker runs your exact forward_backward / optim_step / sample on its GPU cluster, handling sharding and failure recovery. Both Inkling and Inkling-Small are fine-tunable (64K and 256K context options), and it supports SFT, RL (GRPO/PPO), DPO, and distillation.

A worked example that plays to Inkling's actual strengths — a financial-document assistant that cites its sources and abstains when unsupported (mirroring the Bridgewater case the lab showcased):

# SFT: teach the format. Effort must match what you serve at.
train = svc.create_lora_training_client(
    base_model="thinkingmachines/Inkling:peft:262144",  # 256K ctx for long filings
    rank=32,
)
renderer = renderers.get_renderer("inkling", train.get_tokenizer())

for step, batch in enumerate(loader):
    data = [renderer.build_supervised_example(ex.messages, effort=0.9) for ex in batch]
    train.forward_backward(data, loss_fn="cross_entropy").result()
    train.optim_step(tinker.AdamParams(lr=1e-4))

# Then RL a calibration reward with the sampling primitives, and export:
#   save_weights_for_sampler -> weights.download -> weights.build_hf_model -> publish_to_hf_hub
# Serve the merged model under vLLM:  vllm serve ./merged --tool-call-parser inkling

Order of magnitude: a solid SFT-only domain adapter is low hundreds of dollars; add a calibration-RL pass and you're in the low thousands. You're not buying raw capability here — you're buying Inkling's calibration prior, long context, and effort dial, then specializing it cheaply. Which is exactly the bet the whole product is built on.

---