Inkling AI Model Review: Thinking Machines’ First Open-Weights Model, Tested and Explained

This Inkling AI model review takes a close look at the debut release from Thinking Machines Lab, the startup led by former OpenAI CTO Mira Murati. Inkling is an open-weights, multimodal Mixture-of-Experts (MoE) model with a 1-million-token context window and a controllable “thinking effort” dial. It is fast, cheap to self-host, and built for customization rather than leaderboard dominance. Below, we separate the vendor’s self-reported benchmarks from independent measurement, walk through the architecture, show you how to run it, and explain exactly who should (and shouldn’t) adopt it.

As of: 2026-07-16 — one day after launch. This is a research-driven review; no hands-on long-term testing exists yet for any model this new, and we flag every unverified figure below.

A note for builders: if you want to try Inkling alongside other models, OrcaRouter fronts API-available models with a single OpenAI-compatible endpoint, so you can compare and switch without new integrations.

- TL;DR verdict: Inkling is a genuinely capable, efficient open model that shines for fine-tuning and cost-sensitive deployment, but it is not a frontier leader and its maker says so openly. If you want a customizable, royalty-free base with a huge context window, it is one of the most interesting launches of 2026. If you want the single strongest model available, look elsewhere.

- What it is: An open-weights (Apache 2.0) MoE reasoning model. Who it’s for: Practitioners who want to fine-tune and self-host rather than pay for a closed frontier API.

Key takeaways

Maker & date: Thinking Machines Lab; released July 15, 2026 as the lab’s first model.

Architecture: Sparse MoE, 975B total / 41B active parameters, 66 layers, up to 1M-token context in the weights (256K via hosted APIs).

License: Apache 2.0 — full weights on Hugging Face, free for commercial use and self-hosting.

Honest positioning: The company states outright that it “is not the strongest model available today, closed or open.”

Independent score: 41/100 on the Artificial Analysis Intelligence Index — #10 of 97 models, and ahead of several open peers (see reconciliation below).

Cost: Weights are royalty-free to self-host; hosted access starts around $1.87 / 1M input tokens.

Caveat: Almost all headline benchmarks are vendor self-reported and not independently audited.

Who’s behind Inkling

- Founder box. Inkling is the first model from Thinking Machines Lab (thinkingmachines.ai), founded by Mira Murati, formerly Chief Technology Officer at OpenAI. The lab operated in relative stealth before this launch and has taken an open-weights stance that contrasts with the closed-flagship approach of Murati’s former employer. Thinking Machines does not monetize the model itself — revenue flows through its Tinker fine-tuning platform and third-party hosting partners. That business model is central to understanding Inkling: the weights are a free on-ramp, and the company earns when you customize or scale.

What is Inkling?

Inkling is an open-weights, multimodal, Mixture-of-Experts large language and reasoning model, announced by Thinking Machines Lab on July 15, 2026 and released under the permissive Apache 2.0 license with full weights on Hugging Face.

What makes this launch notable is the framing. Rather than claiming a frontier crown, Thinking Machines describes Inkling as a versatile, efficient, customizable open model. In an unusually candid admission for a launch day, the company states that Inkling “is not the strongest model available today, closed or open.” That honesty sets the tone for this entire review: Inkling is a tool designed to be adapted, self-hosted, and fine-tuned, not a benchmark trophy.

Coverage from Fortune and TechCrunch echoed this reading. TechCrunch argued Inkling does not threaten OpenAI, Anthropic, or Google at the frontier tier, but instead pressures the mid-layer of open-weight hosting providers and fine-tuning platforms. Forbes framed Murati’s open-weights strategy as closer to the Chinese open-model playbook (DeepSeek, Qwen, Kimi) than to closed US flagships — a US-versus-China open-weights narrative that runs through much of the launch commentary.

Architecture and specs

Under the hood, Inkling is a sparse Mixture-of-Experts transformer. Only a fraction of its parameters activate per token, which is what keeps inference efficient despite the large total parameter count. The details are documented in the official model card and Hugging Face blog.

Total parameters: 975B

Active parameters: 41B (sparse MoE)

Layers: 66-layer decoder-only transformer

Experts: 256 routed + 2 shared; 6 of 256 routed per token (the 2 shared always active)

Routing: Sigmoid / aux-loss-free

Attention: Hybrid, 5:1 sliding-window (local) to global; 8 KV heads

Position encoding: Learned relative position embeddings (not RoPE)

Multimodality: Encoder-free — audio as dMel spectrograms, images as 40×40 patches, fed directly

Extras: Short convolutions (SConv); MTP layers for speculative decoding

Numerics: BF16, MXFP8, NVFP4 (NVFP4 checkpoint for NVIDIA Blackwell)

Context window: Up to 1,000,000 tokens in the weights (256K on hosted APIs)

Smaller variant: Inkling-Small, 276B total / 12B active (preview, weights not yet released)

A few design choices set Inkling apart from a vanilla MoE:

Expert layout. With 256 routed experts plus 2 shared experts, and 6 routed experts firing per token, the shared pair acts as an always-on “expert sink” that captures common computation while the routed experts specialize. Aux-loss-free sigmoid routing avoids the load-balancing penalty term used by many MoE designs.

Relative position embeddings, not RoPE. Most modern long-context models lean on rotary embeddings; Inkling instead uses learned relative position embeddings, an unusual choice at this scale.

Encoder-free multimodality. Rather than bolting on separate vision/audio encoders, Inkling ingests 40×40 image patches and dMel audio spectrograms directly into the transformer stack. This simplifies the pipeline and is part of why the model is described as natively multimodal.

MTP for speculative decoding. Multi-token-prediction (MTP) layers act as a built-in drafter, accelerating generation without a separate draft model.

Editor note — add visual: A labeled block diagram of one Inkling layer — sliding-window vs global attention (5:1), the 256+2 expert router with 6 active experts highlighted, SConv, and the MTP drafter head.

Training and the “thinking effort” dial

Inkling was pretrained on 45 trillion multimodal tokens spanning text, images, audio, and video, using a hybrid optimizer (Muon for large matrix weights, Adam for the rest) on NVIDIA GB300 NVL72 systems. Post-training used large-scale asynchronous reinforcement learning scaled past 30M+ rollouts across two long continuous runs, bootstrapped from initial supervised fine-tuning on synthetic data.

A distinctive feature is a controllable reasoning-effort parameter, demonstrated swept from roughly 0.2 to 0.99, where higher values mean more reasoning and more cost. This lets operators trade latency and spend against depth of thought. All the benchmark figures below were run at Effort = 0.99.

Controllable thinking effort: an operational guide

In deployment, the effort control is exposed as a reasoning_effort enum with the levels none / minimal / low / medium / high / xhigh / max. There is no single “right” setting — it is a live lever for the latency-cost-quality trade-off. Use the table below as a starting map (relative guidance; benchmark-grade quality was measured at the top of the range):

none / minimal. Relative latency & token cost: Lowest; Best for: Classification, extraction, formatting, routing, retrieval glue

low. Relative latency & token cost: Low; Best for: Short Q&A, simple summarization, high-volume batch jobs

medium. Relative latency & token cost: Moderate; Best for: General chat, drafting, most agent tool-calls

high. Relative latency & token cost: Higher; Best for: Multi-step reasoning, code generation, analysis

xhigh / max. Relative latency & token cost: Highest; Best for: Hard math, competition-style reasoning, benchmark parity (Effort=0.99)

Can you run it locally? Hardware and VRAM

Because Inkling is a 975B-parameter model, “local” realistically means a multi-GPU server, not a laptop. Approximate requirements (per the launch coverage and community tooling):

BF16 (full). Approx. aggregated VRAM: ~2 TB; Example configurations: 8× NVIDIA B300, or 16× H200

NVFP4 (quantized). Approx. aggregated VRAM: ~600 GB; Example configurations: 4× NVIDIA B300, or 8× H200

GGUF (community). Approx. aggregated VRAM: Varies by quant; Example configurations: Unsloth GGUF builds exist for smaller/quantized footprints

The NVFP4 checkpoint — shipped specifically for NVIDIA Blackwell — cuts the memory bill by roughly two-thirds versus BF16, which is the difference between an 8-GPU and a 4-GPU B300 node. For most teams this still points toward a hosted provider or a rented GPU node rather than owned hardware. Unsloth GGUF quantizations extend reach further down the hardware ladder for experimentation, at some quality cost.

Deployment quickstart

Inkling exposes an OpenAI-compatible API, so most existing client code works as a drop-in with a changed base URL and model name. The three common serving paths:

vLLM — single-command server (defaults to port 8000):

vllm serve thinkingmachines/Inkling --port 8000
# then call the OpenAI-compatible endpoint at http://localhost:8000/v1

SGLang — shard across 8 GPUs (defaults to port 30000):

python -m sglang.launch_server \
  --model-path thinkingmachines/Inkling \
  --tp 8 --port 30000

Hugging Face transformers — load via the multimodal auto class:

from transformers import AutoModelForMultimodalLM, AutoProcessor

model = AutoModelForMultimodalLM.from_pretrained("thinkingmachines/Inkling")
processor = AutoProcessor.from_pretrained("thinkingmachines/Inkling")
# pass reasoning_effort in {none, minimal, low, medium, high, xhigh, max}

Because the endpoint is OpenAI-compatible, migrating an existing app is usually a matter of pointing your SDK at the new base URL and setting reasoning_effort to taste. Additional runtimes at launch include TokenSpeed and Unsloth.

Where to run it: inference-provider availability

If you would rather not manage GPUs, several partners host Inkling. “Run Inkling on X” options at launch:

Tinker (Thinking Machines). Role: Fine-tuning; Notes: 64K and 256K context options; 50% limited-time launch discount (paid)

Together AI. Role: Hosted inference; Notes: OpenAI-compatible endpoints

Fireworks. Role: Hosted inference; Notes: —

Modal. Role: Hosted inference / serverless GPU; Notes: —

Databricks. Role: Hosted inference; Notes: via Unity AI Gateway

Baseten. Role: Hosted inference; Notes: —

Benchmarks: vendor claims vs. independent measurement

This is the most important section of any honest Inkling review 2026, because the numbers come from two very different places.

Disclosure: With the sole exception of the Artificial Analysis Index, every Inkling benchmark below is vendor self-reported at launch (Effort = 0.99, temperature 1.0) and has not been independently audited. Competitor numbers are sourced from third parties (MarkTechPost, Artificial Analysis) or were re-run by Thinking Machines, and are likewise not independently audited here. Some figures carry harness or subset qualifiers. Treat them all as directional, not gospel.

Vendor self-reported scores

According to Thinking Machines’ own launch materials:

AIME 2026 (math): 97.1%

GPQA Diamond (science reasoning): 87.2%

SWE-bench Verified (coding, bash-only harness): 77.6%

SWE-bench Pro (Public): 54.3%

MMMU Pro (multimodal): 73.3%

VoiceBench (audio): 91.4%

MMAU (audio): 77.2%

IFBench (instruction following): 79.8%

Terminal Bench 2.1 (agentic terminal): 63.8

FORTRESS Adversarial: 78.0%

SimpleQA Verified: 43.9%

On paper these look strong, especially the math and science reasoning figures. But the company benchmarked Inkling against near-future competitor versions (GPT 5.6 Sol, Claude Fable 5, Gemini 3.1 Pro, DeepSeek V4 Pro, Kimi K2.5/K2.6, GLM 5.2, Nemotron 3 Ultra) using scores it generated itself. Those competitor numbers may not match the rivals’ own reported figures, so head-to-head comparisons should be read with caution.

Multi-model head-to-head (open-weights rivals)

The cleanest side-by-side of Inkling against other open-weight models comes from MarkTechPost’s comparison table (reproduced below, attributed to MarkTechPost). It is useful precisely because it puts the rivals in one frame:

HLE. Inkling: 29.7%; Nemotron 3 Ultra: 26.6%; Kimi K2.6: 35.9%; GLM 5.2: 40.1%; DeepSeek V4 Pro: 35.9%

AIME 2026. Inkling: 97.1%; Nemotron 3 Ultra: 94.2%; Kimi K2.6: 96.4%; GLM 5.2: 99.2%; DeepSeek V4 Pro: 96.7%

SWE-bench Verified. Inkling: 77.6%; Nemotron 3 Ultra: 70.7%; Kimi K2.6: 80.2%; GLM 5.2: 80.0%; DeepSeek V4 Pro: 80.6%

Terminal Bench 2.1. Inkling: 63.8%; Nemotron 3 Ultra: 56.4%; Kimi K2.6: 71.3%; GLM 5.2: 82.7%; DeepSeek V4 Pro: 64%

FORTRESS (adversarial). Inkling: 78.0%; Nemotron 3 Ultra: 77.6%; Kimi K2.6: 65.6%; GLM 5.2: 71.3%; DeepSeek V4 Pro: 36.0%

Source: MarkTechPost. Not independently audited.

The pattern is clear and consistent with Thinking Machines’ own modesty. Inkling leads on FORTRESS (adversarial safety) and beats Nemotron 3 Ultra across the board, but it trails GLM 5.2, Kimi K2.6, and DeepSeek V4 Pro on HLE, SWE-bench Verified, and especially Terminal Bench 2.1 (63.8% vs GLM 5.2’s 82.7%). If agentic coding and terminal tasks are your priority, the leading Chinese open models are ahead today.

Independent measurement (Artificial Analysis)

For a more neutral read, Artificial Analysis evaluated Inkling on 2026-07-15 and placed it at 41/100 on its Intelligence Index, ranked #10 of 97 models. Two points on how to read that rank fairly:

It is a strong open-model showing, not an overall #1. Per Artificial Analysis, Inkling’s index of 41 sits ahead of Nemotron 3 Ultra (38), Gemma 4 31B (29), and gpt-oss-120b (24) — so among open-weights peers it is competitive-to-leading. But #10 of 97 means nine models rank higher overall, consistent with the “capable, not frontier” framing.

Efficiency is where it stands out. Artificial Analysis notes strong token efficiency — roughly 25K tokens to complete its evaluation set versus 37–43K for comparison models — and a GDPval-AA v2 Elo of 1238, ahead of Kimi (1190) and DeepSeek V4 Flash (1189), plus a small edge (+2) on AA-Omniscience.

Output speed measured 72.7 tokens/sec with a time-to-first-token of 1.75s. In short: a respectable top-ten placement, and a genuinely efficient one — but we deliberately avoid overstating it as a leaderboard win.

Multimodal and long-context capabilities

Inkling accepts text (UTF-8), images (40px to 4096px via a hierarchical patch encoder), and audio (16kHz WAV, up to roughly 20 minutes, using discrete token encoding). Output is text only — there is no image or audio generation, so plan for an understanding model, not a generation one. Video was used during pretraining but is not a supported or evaluated input at launch, so do not plan around it yet.

The headline capability is the 1-million-token context window in the released weights, which opens the door to whole-repository code analysis, long-document synthesis, and extended multi-turn agent sessions without aggressive chunking. Note the practical nuance: hosted APIs expose up to 256K tokens, so the full 1M is a self-host feature today. Combined with the sliding-window attention design and speculative decoding, the long-context story remains one of Inkling’s most practical selling points.

Pricing, tiers, and total cost of ownership

Inkling is genuinely open. Full weights (a BF16 checkpoint plus an NVFP4 checkpoint) are on Hugging Face under Apache 2.0, so self-hosting is royalty-free — you pay only for compute. Thinking Machines does not monetize the model itself; revenue flows through Tinker and third-party hosts.

Hosted per-token pricing (per Artificial Analysis), by context tier:

64K. Input / 1M: $1.87; Cached input / 1M: $0.374; Output / 1M: $4.68

256K. Input / 1M: $3.74; Cached input / 1M: $0.748; Output / 1M: $9.36

Reflects a limited-time 50% launch discount; exact Tinker per-token figures live in the docs and will change.

Self-host vs API — how to think about TCO. The economics turn on volume and utilization:

API (Tinker / partners): zero fixed cost, pay per token, near-instant to start. Best at low or spiky volume, or while prototyping.

Self-host (rented or owned GPUs): you pay for a 4–8 GPU node whether or not it’s busy, but marginal token cost approaches raw electricity. Because Inkling activates only 41B parameters and is token-efficient (~25K vs 37–43K per the Artificial Analysis set), throughput per GPU-hour is favorable, and heavy, steady workloads can land materially cheaper than per-token API pricing once a node is well utilized. Commentary around the launch framed self-hosting open weights as roughly 40–60% cheaper than comparable closed-API usage at scale — a directional claim, not an audited figure.

Editor note — add visual: A break-even chart — monthly token volume (x) vs total cost (y) with three lines: closed frontier API, Inkling hosted API, and Inkling self-hosted on a rented GPU node — showing the crossover point where self-hosting wins.

Safety, alignment, and censorship

Safety is one of Inkling’s stronger and more differentiated stories. On the FORTRESS adversarial benchmark it scores 78.0% — the best among open-weight models in MarkTechPost’s comparison, ahead of GLM 5.2 (71.3%), Kimi K2.6 (65.6%), and far ahead of DeepSeek V4 Pro (36.0%). Thinking Machines also emphasizes calibrated uncertainty in the model’s outputs.

VentureBeat’s coverage highlighted a related property: resistance to censorship. Combined with a permissive Apache 2.0 license, this positions Inkling as an open model that teams can align to their own policies rather than inheriting an opaque, vendor-imposed content regime — a meaningful consideration for regulated or region-specific deployments. As always with a launch-day model, no independent red-team or third-party safety audit had surfaced at the time of writing, so treat the FORTRESS lead as vendor/third-party-sourced rather than externally certified.

Should you fine-tune Inkling?

Fine-tuning is arguably Inkling’s reason to exist. A quick decision framework:

Fine-tune (via Tinker or your own pipeline) if: you have proprietary data, a narrow domain, or a task where a smaller specialized model beats a generalist; you need to own the weights; or you want to bake in a specific tone, format, or policy. The 64K/256K Tinker context options and launch discount lower the barrier.

Just use the base model (self-host or API) if: your task is general-purpose, your volume is low, or you haven’t yet validated that fine-tuning moves your metric. Prompt engineering plus the reasoning_effort dial often gets you far enough.

Look elsewhere if: you need frontier-grade agentic coding today (GLM 5.2 and Kimi K2.6 lead on those benchmarks) or you require independently audited quality guarantees.

Pros and cons

Pros

Fully open weights under Apache 2.0, royalty-free to self-host and free for commercial use.

Efficient sparse MoE (only 41B active) plus strong token efficiency keeps inference cost and speed competitive.

Massive 1M-token context in the weights (256K via API).

Genuine multimodality (text, image, audio input).

Controllable reasoning_effort dial (none → max) for live cost/quality trade-offs.

Best-in-class open-weight adversarial safety (FORTRESS 78.0%, per MarkTechPost) and “resistance to censorship.”

Strong independent standing — top 10 of 97 on the Artificial Analysis Index, ahead of Nemotron 3 Ultra, Gemma 4 31B, and gpt-oss-120b.

Cons

Explicitly not a frontier model, by the maker’s own admission.

Trails leading open rivals (GLM 5.2, Kimi K2.6, DeepSeek V4 Pro) on agentic and coding benchmarks (Terminal Bench 2.1, SWE-bench Verified, HLE).

Most benchmarks are vendor self-reported and not independently audited.

Text-only output; no image/audio generation; no video input at launch; Inkling-Small still in preview.

Real “local” use needs a multi-GPU node (~600GB VRAM even quantized).

No substantive independent critical or safety/red-team review had surfaced at launch.

Who should use Inkling?

Inkling is a strong fit if you are a practitioner or team that wants to own and customize your model rather than rent a closed API. Ideal use cases include:

Fine-tuning teams building domain-specific models via Tinker or their own pipeline.

Cost-sensitive, high-volume deployments where royalty-free self-hosting beats per-token frontier pricing.

Long-context workloads such as repo-wide code assistance, document analysis, and long agent sessions.

Multimodal applications needing combined text, image, and audio understanding.

Policy-sensitive deployments wanting a strong-safety, censorship-resistant open base to align themselves.

It is a poor fit if you need the absolute strongest reasoning or agentic coding performance, need video input or generative output, or require independently audited benchmarks before deployment.

Verdict and final rating

Let’s address the elephant directly: Inkling is not the strongest model available today, and Thinking Machines says exactly that. Read cynically, that is a low bar. Read fairly, it is the whole point — Inkling is optimized for a different objective than topping a leaderboard. It is efficient (41B active, ~25K-token task budgets), openly licensed (Apache 2.0), safe by open-weight standards (FORTRESS 78%), and built to be fine-tuned and self-hosted. That combination makes it one of the more thoughtful open-model launches of 2026, even as it trails GLM 5.2 and Kimi K2.6 on the hardest agentic and coding benchmarks.

The remaining asterisks are the largely self-reported benchmarks and the absence of any independent critical review this early. But for its intended audience — builders who value ownership, customization, cost control, and a huge context window over frontier bragging rights — Inkling delivers.

Rating: 4 out of 5 for its target audience of builders and fine-tuners; lower if you are shopping strictly for frontier capability.

FAQ

What is Inkling and who made it? Inkling is the first model from Thinking Machines Lab, the AI startup led by Mira Murati (former OpenAI CTO). It launched on July 15, 2026 as an open-weights, multimodal Mixture-of-Experts reasoning model.

Is Inkling the best AI model? No, and the company doesn’t claim it is — it states Inkling “is not the strongest model available today, closed or open.” Independent measurement (Artificial Analysis) ranks it #10 of 97 overall, though it leads several open peers.

How many parameters does Inkling have, and what’s the context window? 975B total with 41B active (sparse MoE), across 66 layers. The context window is up to 1,000,000 tokens in the released weights, and up to 256K on hosted APIs.

Is Inkling open source, and what’s the license? The weights are released under Apache 2.0, which permits commercial use and self-hosting. It is “open weights” — full model weights are on Hugging Face.

Is Inkling free to use? The weights are free and royalty-free to self-host. Fine-tuning on Tinker and hosted inference through providers like Together AI, Fireworks, Modal, Databricks, or Baseten are paid services. Hosted access starts around $1.87 / 1M input tokens (a limited-time launch discount).

How do I run or download Inkling, and what hardware do I need? Download the weights from Hugging Face and serve them with vLLM, SGLang, or Hugging Face transformers via an OpenAI-compatible API. Expect roughly ~2TB of aggregated VRAM for BF16 (8× B300 / 16× H200) or ~600GB for the NVFP4 quantized checkpoint (4× B300 / 8× H200). Community Unsloth GGUF builds lower the bar for experimentation.

How do I fine-tune Inkling? Use Thinking Machines’ Tinker platform, which offers 64K and 256K context options and a limited-time 50% launch discount, or fine-tune the open weights in your own pipeline.

What is controllable thinking effort? A reasoning_effort setting (none / minimal / low / medium / high / xhigh / max) that trades latency and token cost against reasoning depth. Low effort suits classification and extraction; max effort suits hard math and matches the benchmark configuration (Effort=0.99).

How does Inkling compare to Kimi, GLM, DeepSeek, and Nemotron? Per MarkTechPost’s comparison, Inkling leads on FORTRESS (safety) and beats Nemotron 3 Ultra broadly, but trails GLM 5.2, Kimi K2.6, and DeepSeek V4 Pro on Terminal Bench 2.1, SWE-bench Verified, and HLE. It’s competitive but not the strongest open model on agentic coding.

Can Inkling process images, audio, and video? It accepts text, images (40px–4096px), and audio (16kHz WAV, up to ~20 minutes) as input. Output is text only — no image or audio generation. Video was used in pretraining but is not a supported input at launch.

Are Inkling’s benchmark scores reliable? Treat them cautiously. Aside from the independent Artificial Analysis Intelligence Index, the headline numbers are vendor self-reported at launch and not independently audited. Competitor figures come from third parties (MarkTechPost) or were re-run by Thinking Machines and may not match rivals’ own reported numbers.

What is Inkling-Small, and what’s on the roadmap? Inkling-Small is a smaller variant (276B total / 12B active). As of launch it was still in preview, with weights not yet released. The main model already ships MTP layers for speculative decoding.