Inkling review: is Thinking Machines' open model worth it?

Is Inkling worth it for you? (30-second check)

Before the deep dive, pick what matters most and get a straight answer. This is the same call I'd make on a real project.

What Inkling actually is

Quick grounding before the review proper. Inkling is Thinking Machines Lab's first public model, and the lab is refreshingly upfront that it isn't chasing the leaderboard. The pitch is a broad, balanced open foundation you fine-tune for your own use on the lab's Tinker platform. It's a starting point you shape, not a chatbot you subscribe to.

The specs that matter, from the model card:

• Architecture: a Mixture-of-Experts transformer, 975B total with 41B active per token (6 of 256 experts routed, plus 2 shared). That's how a near-trillion-parameter model serves at a sane speed.
• Inputs: text, images, and audio (16 kHz WAV, best under ~20 minutes). Output is text only.
• Context window: up to 1M tokens.
• License: Apache 2.0, so commercial use is fine and the weights are on Hugging Face.
• Released: July 15, 2026.

The audio is the standout. As the top comment on the launch thread called it, this is the "largest open weight model that supports audio," which matters the moment you want a model to listen to a support call rather than read a transcript of it.

The benchmarks: smart, with sharp edges

Here's where you separate the vendor's pitch from the independent read. Thinking Machines' own tables show flattering max-effort numbers, but the cleaner signal is Artificial Analysis, which benchmarks everyone the same way.

Their verdict: Inkling scores 41 on the AA Intelligence Index, #10 of 97, well above the ~25 average for open-weights models its size. So it's a smart model. But it sits below the frontier leaders and lands in a cluster with peers like DeepSeek V4 Flash. Broader community trackers put it nearer #41, which is where the "is 'competitive' fair?" debate came from.

Read that honestly and Inkling gets a real personality: strong on scientific and long-context reasoning, noticeably weak on physics and raw knowledge reliability (its AA-Omniscience knowledge-reliability index is a lowly 2 on a −100-to-100 scale). Sharp edges, not a smooth all-rounder.

There's also a genuinely useful efficiency claim underneath the scores. Inkling exposes a controllable thinking-effort dial (none through max in the Hugging Face integration), and the lab says it hits the same Terminal-Bench score as Nemotron 3 Ultra while spending about a third of the tokens. For anyone paying per token or renting a GPU, "same answer, fewer tokens" beats a fractional benchmark win.

The launch thread caught the same mixed picture I did:

"I just looked at the benchmarks and was kinda disappointed that it seems to be between KimiK2.6 and KimiK2.7 on most of the benchmarks."

juliangoetze, Hacker News

The price: the one real knock

This is the part that surprised me most in the review. Inkling is open weights, and yet on Thinking Machines' own API it's priced like a proprietary frontier model. Per Artificial Analysis, it lands at #81 of 97 on price, among the most expensive in its class.

Two things stand out. First, there's currently one API provider, Thinking Machines itself, so no cheaper third-party host is undercutting them yet. Second, "open weights" only makes it free if you're willing to run it, which is a real decision, not a footnote. So the price verdict is simple: renting Inkling is hard to justify; owning it can be a bargain.

Running it yourself: the actual selling point

Because the weights are open, the community had Inkling running locally on day one. The Hugging Face launch blog lays out three tiers: the full BF16 checkpoint wants around 2 TB of VRAM (data-center territory), the NVFP4 quant drops that to roughly 600 GB on Blackwell hardware, and community 1-bit GGUF builds cut it ~95%, enough for a beefy workstation.

Tooling support landed fast too: day-zero integration in transformers 5.14, SGLang, vLLM, and llama.cpp/Unsloth, plus speculative-decoding drafter layers for a lossless speed-up. That "run it yourself" story is the real reason to care. The tradeoff is control versus convenience: you own the weights, your data never leaves your infrastructure, and nobody can deprecate the model out from under you, but you're now on the hook for the GPUs.

For teams that want that control without babysitting a cluster, Inkling showed up on Databricks on day zero, reachable through the Unity AI Gateway with governance built in and no per-token pricing.

Pros and cons

Here's the balance sheet from the review, no hedging.

What Inkling gets right

• Genuinely open — Apache 2.0 weights, commercial use, self-hostable down to a 1-bit build.
• Native audio input — the largest open-weight model that listens, not just reads.
• 1M-token context — ties the top tier on length.
• Token-efficient reasoning — the effort dial delivers real savings, not just a marketing line.
• Strong scientific + long-context reasoning — 87% GPQA Diamond, 63% AA-LCR.

Where it falls short

• Expensive to rent — #81 of 97 on API price, a strange place for open weights to land.
• Not a leaderboard winner — sits below frontier leaders, mid-pack among open peers.
• Weak knowledge reliability — AA-Omniscience index of 2, plus a rough 5% on physics reasoning.
• One API host — no third-party competition on price yet.
• Serious hardware to self-host — "free" model, ~2 TB VRAM for the full build.

What the community actually thinks

The Hacker News launch thread (1,214 points, ~292 comments) is the clearest read on reception. The mood was enthusiastic but measured, and the excitement was less about scores and more about who shipped it:

"Not to mention - it is American. This is the first competitive non-Chinese open weights model since what, Llama 3?"

paxys, Hacker News

That framing got pushback (people named Mistral, Cohere's North, Gemma), but the underlying "a credible Western open-weights option was overdue" sentiment ran through the whole thread. There was also a healthy "how does a company that gives its model away survive?", with the answer landing on Tinker, the hosted fine-tuning business. The most useful line for anyone doing their own review, though, was the reminder that no public benchmark is the real test:

"want to know how good a model is? Run it with your own non-public benchmark, basically the only way to get proper answers you can somewhat rely on, everything else is manipulated, misunderstood or over-relied on."

embedding-shape, Hacker News

Hold onto that instinct, because it's exactly the one that matters the moment you point a model at your support queue.

What an Inkling-class model means for support

Here's where I've spent the last few years, so let me be direct. I build the agent layer that sits on top of models like Inkling, and the thing I've learned watching real rollouts is this: a better base model rarely changes what actually ships to a support queue.

A raw model, however smart, doesn't know your refund policy, can't see the last 40,000 tickets your team already solved, and has no idea when it should shut up and hand off to a human. Point it straight at customers and it will answer confidently and wrongly, which is worse than not answering. That failure mode is the exact reason AI hallucinations in support burn teams, and it's why the model is only ever the engine.

The car is the layer around it. That's what eesel is: it learns from your solved tickets and help docs (not just a marketing page), routes on confidence so low-certainty answers get drafted instead of sent, and, the part I care most about, it lets you simulate the agent against your own past tickets before a single customer sees it. That simulation is the "run it on your own benchmark" advice from Hacker News, turned into a product step.

It also means you don't bet your support stack on any single model. The best model changes every few weeks (Inkling today, something else next month), so eesel stays model-agnostic and rides whichever one is strongest, while the part that matters to customers, the knowledge, the guardrails, the ticket triage, stays put.

Verdict

Inkling is a genuinely good open-weights model with a pricing quirk you have to plan around. If you want to own the weights, need audio or long context, and can run the hardware, it's one of the most interesting open releases of 2026 and well worth downloading. If you just want the cheapest capable API, or the single highest benchmark score, it isn't the pick, and you shouldn't force it.

And if your actual goal is to answer support tickets, remember what the review keeps circling back to: a model card is not a support agent. The engine is only half the job.

Try eesel

Inkling is a fun release, but a model card is not a support agent. If your real goal is to automate tier-1 support, what you need is the layer that turns any strong model (open or closed) into a teammate: eesel plugs into your existing helpdesk (Zendesk, Freshdesk, Gorgias, HubSpot, Front and 100+ others), learns from your history, and lets you simulate on real past tickets before you go live, so you see coverage and accuracy first, not after a customer catches a bad reply. Gridwise used exactly that approach to resolve 73% of tier-1 requests in their first month.

Pricing is usage-based at around $0.40 per resolved ticket, with no per-seat fees, and you can start free. It's the difference between admiring a great engine and actually driving somewhere.