Inkling Review (2026): Pricing, Features & Honest Verdict

Inkling is Thinking Machines Lab’s first open-weights model, a 975B-parameter multimodal mixture-of-experts release under Apache 2.0. Text, image and audio in, 1M token context, and a thinking-effort dial that actually saves money. The weights are free. Running them is not. Best for: teams fine-tuning their own models. Price: from $1/M input tokens (free plan: yes, weights are free to download). Rating: 8.5/10.

What is Inkling?

Inkling is a large multimodal language model released on 15 July 2026 by Thinking Machines Lab, the company Mira Murati founded after leaving OpenAI as CTO. It is the lab’s first model and its first open-weights release, and it landed under an Apache 2.0 licence, which means you can download it, modify it, and ship it commercially without asking anyone.

The architecture is a mixture-of-experts transformer with 975 billion total parameters and 41 billion active per token. That ratio is the whole point. You get the knowledge capacity of a very large model while only paying compute for a fraction of it on each forward pass. There are 256 routed experts with 6 active per token, plus 2 shared experts per layer. It interleaves sliding-window and global attention at a 5:1 ratio and adds short convolutions for efficiency. Pretraining ran on 45 trillion tokens of text, images, audio and video.

We found the release matters less for its benchmark numbers and more for what it signals. A well-funded frontier lab shipped a genuinely competitive multimodal model with open weights and a permissive licence, at a moment when the default assumption was that anything this capable stays behind an API. VentureBeat framed the launch around low cost and resistance to censorship, and both are fair readings of what Thinking Machines is going for.

What Are Inkling’s Key Features?

Controllable thinking effort

This is the feature we would actually pay for. Inkling exposes an effort setting you can sweep from roughly 0.2 to 0.99, and it maps reasoning depth against tokens generated. Turn it down for classification and extraction. Turn it up for hard multi-step reasoning. Thinking Machines’ own charts show Inkling matching competing models’ performance while generating around a third of the tokens.

Anyone who has watched a reasoning model burn 4,000 tokens deciding whether an email is spam understands why this matters. Most providers give you a coarse toggle: reasoning on, reasoning off, maybe three named levels. A continuous dial you can tune per endpoint is a different kind of control, and on a high-volume workload it is the difference between a viable unit economic and an unviable one.

Native multimodality, including audio

Text, images and audio all go into the same token stream rather than through bolted-on adapters. Audio arrives as dMel spectrograms. Images are encoded as 40×40 pixel patches through a four-layer hMLP. Output is text only, so this is an understanding model, not a generation one. Native audio input is still rare in open-weights models, and it opens up call analysis, voice agents and meeting tooling without stitching Whisper into your pipeline first.

A 1M token context window

Inkling handles up to a million tokens of context. That is enough for a full codebase, a long deposition, or a year of support tickets in a single prompt. Long context in open models has historically come with a quality cliff where recall collapses past a few hundred thousand tokens, and we would want independent needle-in-haystack testing before betting a product on the full million. But the ceiling being there at all, in weights you can host yourself, is new.

Fine-tuning through Tinker

Inkling is live on Thinking Machines’ own Tinker platform with 64K and 256K context options, currently at a 50% introductory discount. There are updated cookbook recipes and a tml-renderer that handles tool calls and multimodal inputs, which removes most of the tedious formatting work. This is the piece that makes Inkling interesting to builders rather than just to people reading benchmark tables. An open-weights model you can cheaply specialise on your own data is a much stronger position than an API you rent.

How Much Does Inkling Cost?

Inkling is free to download. The full weights are on Hugging Face under Apache 2.0, and you can self-host and commercialise them with no licence fee.

If you would rather rent it, OpenRouter lists Inkling at $1 per million input tokens and $4.05 per million output tokens. Thinking Machines’ own API sits slightly higher at roughly $1.87 in and $4.68 out according to Artificial Analysis. OpenRouter also notes that effective pricing can land 60 to 80 percent lower with prompt caching if you reuse a lot of context. Hosting is available through Together AI, Fireworks, Modal, Databricks and Baseten, and it runs on vLLM, SGLang and llama.cpp.

Against closed frontier models that is cheap, roughly a quarter to a fifth of what the top-tier proprietary APIs charge for comparable reasoning work. Against other open-weights models it is mid-range rather than bargain-basement, because 41B active parameters still cost real compute to serve.

Now the honest part. Free weights are not free inference. Running the full model needs somewhere around 2 TB of VRAM, which is a multi-node H100 or B200 cluster, not a server you have lying around. There are 1-bit quantised builds that will run on a workstation, with the quality loss you would expect. For almost every team, “self-host Inkling” means “pay a hosting provider,” and the licence buys you portability and the option to fine-tune rather than a zero on your invoice.

Who is Inkling Best For?

Use Inkling if you want to fine-tune a frontier-class model on proprietary data. This is the strongest case. Apache 2.0 plus Tinker means you can specialise it, own the result, and deploy it wherever you like without renegotiating terms with a vendor.

Use Inkling if you have regulatory or data-residency constraints that rule out sending prompts to a third-party API. Self-hosting is expensive, but for banks, health systems and defence-adjacent work it is the only option, and Inkling raises the quality ceiling of what is available on that path.

Use Inkling if you are running high-volume reasoning workloads where the effort dial can cut your token spend by a third or more.

Use Inkling if you need native audio understanding and do not want a separate transcription step in your pipeline.

Skip Inkling if you just need a good API model for a normal product. The frontier proprietary models are still ahead on coding and agentic reliability, the tooling around them is more mature, and the migration cost is not worth chasing a lower per-token rate you may not notice.

Skip Inkling if “open weights” is the only reason it appeals to you and you have no intention of fine-tuning or self-hosting. Renting Inkling through OpenRouter is a perfectly fine thing to do, but you are then just choosing a model on price and capability like any other, and you should compare it that way.

Best Inkling Alternatives

DeepSeek’s open-weights line. The long-standing benchmark for cheap open reasoning models, typically well under $1 per million input tokens. Weaker on native multimodality, particularly audio. Pick DeepSeek if cost per token is the dominant constraint and your workload is text only.

Qwen’s open multimodal models. Strong vision, extensive size range from small enough to run on a laptop up to large server models, and a permissive licence. Better if you need something that fits on modest hardware. Pick Qwen if you want an open multimodal family with real deployment flexibility rather than a single very large model.

Llama’s latest open release. The largest ecosystem, most tutorials, most fine-tuning tooling, most vendors who will host it for you. Generally behind Inkling on reasoning depth and the effort-control idea. Pick Llama if ecosystem maturity and hiring for existing skills matters more than being on the frontier.

Final Verdict: Is Inkling Worth It?

Inkling is the most interesting open-weights release of 2026 so far, and the controllable thinking effort is the part worth copying. Most of the industry is still shipping reasoning as a binary switch. A continuous dial that lets you trade accuracy for tokens at the endpoint level is a better abstraction, and it will be standard within a year. The 1M context, native audio input and Apache 2.0 licence make the rest of the package hard to argue with, and the fact that a lab with Thinking Machines’ funding chose to open it rather than gate it behind an API is a meaningful move.

The caveat is the one every open-weights release carries and most coverage skips. Downloading the weights costs nothing and serving them costs a great deal. Two terabytes of VRAM is a cluster, not a purchase, and the 1-bit quantised builds that fit on a workstation are not the model the benchmarks describe. If you have a fine-tuning plan, a compliance requirement or a genuine high-volume workload, Inkling is excellent and you should be testing it this month. If you are building a normal product and just want a good model behind an API, rent it through OpenRouter at $1 in and $4.05 out, judge it on the same terms as everything else, and ignore the licence entirely.