A working review of Inkling, Thinking Machines Lab's first open-weights multimodal LLM. What it nails on openness, calibration, and reasoning, where it stops, and who it fits.
Inkling is a genuinely significant first release from Thinking Machines Lab: a frontier-scale, natively multimodal open-weights model under Apache 2.0, rated the leading U.S. open-weights model on Artificial Analysis's Intelligence Index at launch, with calibrated answers and controllable thinking effort as real differentiators. Judged as what it is — an open base you run and customize — it is excellent. It is not a content tool: it outputs text only, renders no media, publishes nothing, and running a 975B-parameter model takes real infrastructure. Score it high for openness, reasoning, and calibration; look elsewhere if you came to produce and ship content.
Most coverage of Inkling is either a "Mira Murati's lab finally ships" narrative or a benchmark leaderboard that misses what it is for. This review is neither. We build a content engine and we read model cards for a living, so the goal here is to say what Inkling is genuinely good at, where it stops, and — because people arrive at this sideways — whether it can power a content operation.
Short version up top: Inkling is a landmark open release. On July 15, 2026, Thinking Machines Lab, the startup led by former OpenAI CTO Mira Murati, published its first in-house model as open weights under Apache 2.0 — an unusually open move at frontier scale. It is a natively multimodal mixture-of-experts model, 975B total parameters with about 41B active per token, that reads text, images, and audio and reasons in text, with up to a 1M-token context. Two things set it apart from the open-model pack: it is built to be calibrated — flagging uncertainty rather than guessing — and it lets you dial "thinking effort" up or down to trade depth against speed and cost. Artificial Analysis rated it the leading U.S. open-weights model on its Intelligence Index at launch, and it is notably token-efficient.
The honest catch is scope and operability. Inkling is a text-output model — it reasons over images and audio but generates no media and publishes nothing. And running the full model well is an infrastructure project, not a download-and-go. None of that is a flaw; it set out to be an open, customizable base layer — a deliberate bet against one-size-fits-all systems — not a finished application. But it is the thing to understand before you decide it fits your workflow.
This review covers what Inkling actually is in 2026, how its openness, reasoning, and calibration stack up, where it is strong, where it is honestly the wrong tool, and who should use it versus who should keep looking.
Inkling is the first in-house model from Thinking Machines Lab, released on July 15, 2026 as open weights under the Apache 2.0 license. It is a natively multimodal mixture-of-experts model — 975 billion total parameters with roughly 41 billion active per token — that accepts text, image, and audio input and produces text output, with up to a 1M-token context on the open weights (256K through the company's Tinker fine-tuning API) and training on about 45 trillion tokens of text, images, audio, and video. Its architecture uses hundreds of routed experts with a small number active per token, interleaving local and global attention, which is how it delivers frontier-scale capability at a fraction of the active compute. A lighter preview, Inkling-Small (276B total, ~12B active), targets low-latency, low-cost workloads. What sets it apart is the combination of openness, calibration, and control. It is released under Apache 2.0 so it can be used and fine-tuned commercially, it is built to give calibrated, uncertainty-aware answers, and it exposes controllable thinking effort so you can tune reasoning depth per task. You reach it by downloading the weights from Hugging Face, fine-tuning on Tinker, or using hosted inference through partners like Together AI, Fireworks, Modal, Databricks, and Baseten; it runs in SGLang, vLLM, llama.cpp, and the transformers library. Note that "open weights" is not the same as fully open source — the checkpoint and license are public, but the complete training corpus is not.
The clearest fit is anyone who wants to run, fine-tune, or control a frontier-grade open model: product teams building on an open base, researchers, and organizations that need the model and its inference on their own infrastructure without vendor lock-in. It suits builders who value calibrated, uncertainty-aware output and the ability to tune reasoning cost per task, and teams that need native reasoning over audio and images, not just text. It is the wrong tool for someone whose actual output is published content — video, images, carousels, social posts — because producing and distributing that is entirely outside what a text model does, and for non-technical users who want a hosted, log-in-and-go experience rather than a 975B-parameter model to operate.
| Dimension | Score | Why |
|---|---|---|
| Openness & licensing | 4.5 / 5 | Frontier-scale weights under Apache 2.0 for commercial use and fine-tuning. Docked slightly because the full training corpus is not released — open weights, not fully open source. |
| Model quality & reasoning | 4.5 / 5 | Rated the leading U.S. open-weights model on Artificial Analysis's Intelligence Index at launch; strong agentic and reasoning scores, though the top closed frontier models still lead overall. |
| Multimodal input (text, image, audio) | 4.4 / 5 | Reads and reasons over images and audio natively in one model — broader input than most open peers. |
| Calibration & uncertainty handling | 4.3 / 5 | Built to flag uncertainty rather than guess, a genuine differentiator for trustworthy reasoning tasks. |
| Controllable thinking effort & efficiency | 4.4 / 5 | Dial reasoning depth against speed and cost; notably token-efficient versus comparable models per task. |
| Ease of use / accessibility | 3.2 / 5 | Downloadable and partner-hosted, but running the full 975B model well needs real infra and ML ops. Not a non-technical, log-in-and-go experience. |
| Ecosystem & tooling | 4.0 / 5 | Strong day-one support — Hugging Face, Tinker, Together/Fireworks/Modal/Databricks/Baseten, and SGLang/vLLM/llama.cpp/transformers. |
| Content / social media production | 1.0 / 5 | Not the product. No image, video, audio, captions, or design output. Out of scope by design. |
| Multi-platform publishing | 1.0 / 5 | Inkling produces text; it does not post. There is no scheduler and no platform integration. |
Inkling has no license price. The weights are free under Apache 2.0, so the cost question is really "what does it cost to run." Self-hosting a 975B-parameter model means substantial GPU and inference infrastructure at real throughput — the lighter Inkling-Small helps here — plus the engineering to operate it. If you would rather not run hardware, hosted partners like Together AI, Fireworks, Modal, Databricks, and Baseten offer inference at their own pricing, and Thinking Machines' Tinker platform handles fine-tuning (it ran a launch discount). One quiet economic advantage: Inkling's token efficiency and controllable thinking effort can lower per-task cost versus chattier models.
For the customization and control use cases Inkling targets, that model is exactly right: a free, fine-tunable, self-hostable frontier model is enormous value when owning and specializing the model is the requirement, and Apache 2.0 removes the per-seat and per-token drag of closed APIs. The catch is that "free model" is not "free outcome" — the total cost is the infrastructure and the application you build around it.
The honest framing on value is that Inkling is priced like what it is: open infrastructure. It is not priced or built as a content-marketing tool, and no amount of inference budget adds rendering or publishing. If your spend is meant to produce and distribute content, you are comparing the wrong line item.
| Use case | Fit | Why |
|---|---|---|
| Running or fine-tuning a frontier-grade open model in-house | Strong | Apache 2.0 weights plus a Tinker fine-tuning path make it an ideal open base to specialize without lock-in. |
| Reasoning over audio and images, not just text | Strong | Native multimodal input lets one model analyze recordings and screenshots alongside text. |
| Tasks that need calibrated, trustworthy answers | Strong | Built to flag uncertainty rather than guess, with tunable thinking effort per task. |
| Drafting copy, scripts, and summaries | OK | Capable text generation, but output needs a human pass and it is one input to a content workflow, not the whole thing. |
| Producing short-form or avatar video for social | Weak | No video generation of any kind. Entirely outside Inkling's scope. |
| Brand-consistent content across formats | Weak | No persona or brand-voice system, no design layer. It generates text but does not govern a content voice or render media. |
| Scheduling and publishing across platforms | Weak | No publishing layer and no scheduler. Inkling produces text, not posts. |
| Non-technical, hosted, log-in-and-go use | OK | Partner-hosted access exists, but the experience is a model endpoint, not a finished application. |
If you arrived at this review wondering whether Inkling can run your content operation, the honest answer is no — and that is a category question, not a criticism. Inkling is a foundation model: open, calibrated, multimodal reasoning infrastructure. It has no renderer, no caption engine, no design layer, and no scheduler, because it was never meant to be a content tool. Scoring it as one would be unfair to a model that is genuinely excellent at its actual job, and the calibration and controllable-effort features that make it trustworthy for reasoning do nothing to put a post on TikTok.
Kompozy sits at the layer above. Where Inkling stops at text, Kompozy turns an idea or a draft into 18 content formats — persona and avatar video, carousels, quote cards, infographics, blogs, newsletters, and platform-native posts — holds one brand voice through a Persona Brief, and schedules and publishes across nine platforms plus email and blog. It runs that generation on managed Claude and OpenAI models, so there are no GPUs to operate. The two are not rivals: a control-minded team could draft in its own fine-tuned Inkling deployment — even feeding it a recording for Inkling to summarize — and let Kompozy produce and ship the finished content. Use Inkling for the open model layer it is built for, and a content engine for the content.
Inkling is the first open-weights model from Thinking Machines Lab, the startup founded by former OpenAI CTO Mira Murati, released on July 15, 2026 under Apache 2.0. It is a natively multimodal mixture-of-experts model — 975B total parameters with about 41B active per token — that reads text, images, and audio and responds in text, with up to a 1M-token context.
For running, fine-tuning, or controlling a frontier-grade open model — yes, it is one of the strongest open-weights releases available, free under Apache 2.0, with calibration and multimodal input as standout traits. It is not worth adopting for content production, because it generates no media and publishes nothing; for that you need a content engine on top.
At launch, Artificial Analysis rated it the leading U.S. open-weights model on its Intelligence Index, with strong reasoning and agentic scores. It is very competitive among open models, but the top closed frontier models still lead overall on the hardest tasks — you trade away openness and self-hosting to use them.
The model is free under Apache 2.0. Your real cost is the GPU/inference infrastructure to self-host a 975B-parameter model (the lighter Inkling-Small helps), or a hosted provider's inference pricing through partners like Together AI, Fireworks, Modal, Databricks, and Baseten; Tinker handles fine-tuning.
No. Inkling reads images and audio but outputs text only — it does not render video, generate images, write captions on a clip, or post to any platform. To turn its text into published content you need a content engine like Kompozy.
Its scale and design: a 975B/41B multimodal mixture-of-experts with up to a 1M-token context, plus two traits many open models lack — calibrated answers that flag uncertainty rather than guess, and controllable "thinking effort" to trade reasoning depth for speed and cost. It is also notably token-efficient per task.
It is best described as open weights rather than fully open source. The model checkpoint is downloadable under the permissive Apache 2.0 license, which allows commercial use and fine-tuning, but the complete 45-trillion-token training corpus is not released, so you cannot reproduce the model from scratch.
Kompozy, without question. Inkling produces text and nothing else; Kompozy generates video, images, carousels, blogs, and newsletters and publishes them across platforms. Use Inkling as an open model layer — for control-minded teams, even as a drafting source — and Kompozy to produce and ship the content.