Inkling Is on Writingmate: Testing Thinking Machines Lab's First Open-Weight Model for Agentic Coding and Tool Use

Thinking Machines Lab shipped its first open-weight model on July 17, 2026, and the spec sheet is specific enough to actually test instead of skim: 975 billion total parameters, only 41 billion active per token, a declared 1,048,576-token context window, and native audio input alongside text and image. It's called Inkling, and it landed in the Writingmate catalog the same day Mira Murati's team announced it.

Thinking Machines Lab has been building toward this since Murati left OpenAI's CTO seat in 2024 to start the company, and until now everything they'd shown publicly was closed. Inkling is the first release you can actually download weights for, run yourself, or test through an API without a waitlist. That's a bigger deal than the parameter count, because "open-weight" claims from a well-funded lab tend to get scrutinized harder than the benchmark chart, not less.

So I ran Inkling through the same agentic coding, tool-calling, and long-context test suite I used on Kimi K3, Grok 4.5, and Hy3: real multi-step coding tasks, sequential tool calls with schemas, a long-document retrieval test, and — since Inkling is the first of these four to actually let you dial reasoning effort up or down — a direct comparison of what changes when you do.

What's actually new in Inkling

The architecture number that matters most isn't the 975B total, it's the ratio: 41 billion active parameters out of 975 billion total works out to about 4.2% of the model active on any given token. That's sparse even by Mixture-of-Experts standards, and it's the whole point of the design — you get inference costs closer to a much smaller dense model while keeping a total parameter budget large enough to hold a lot of specialized routing capacity.

Two other details separate Inkling from the other MoE launches I've tested this quarter. First, input modalities: text, image, and audio. Kimi K3 and Grok 4.5 both take text and image, but neither accepts raw audio input directly — Inkling does, which matters if your agent pipeline includes voice notes, call transcripts, or meeting recordings you don't want to pre-transcribe with a separate model. Second, reasoning control: Inkling ships with six selectable reasoning efforts (none, minimal, low, medium, high, max), defaulting to high. Kimi K3's reasoning is mandatory and locked to max. Grok 4.5's is mandatory at high with no way to turn it down. Inkling is the only one of the three where you can trade reasoning depth for latency and cost on a per-request basis.

Inkling specs at a glance

Field	Inkling	Reader takeaway
Provider	Thinking Machines Lab	Mira Murati's first open-weight release since founding the company in 2025
Availability	July 17, 2026 in the Writingmate catalog	Live to test today, not waitlisted
Architecture	975B-parameter MoE, 41B active per token	About 4.2% of parameters active per token — sparser than most MoE models this size
Context window	1,048,576 tokens declared (1M); 524,288 tokens (512K) served at launch	Plan around the served ceiling until the live endpoint widens
Input modalities	Text, image, audio	Only model in this comparison that takes audio input natively
Reasoning	Optional, six effort levels (none through max), default "high"	Only model here where you can dial reasoning down for cheaper, faster runs
Pricing (OpenRouter)	$1.00 input / $4.05 output per 1M tokens; $0.17 cached input	Cheapest per-token price of the recent agentic launches compared here

How I tested Inkling for agentic coding and tool use

I ran Inkling through the model page in the Writingmate directory, keeping task, tool contract, and acceptance criteria identical to the Hy3 and Grok 4.5 runs so the results would actually mean something side by side.

• Multi-step coding test: a real bug report with a stack trace, one relevant file, and a misleading symptom, asking for root cause, smallest patch, and a regression test.
• Tool-calling reliability test: a task requiring three sequential tool calls (search, read, write) with explicit argument schemas and a required fallback path if a call returned an error.
• Long-context retrieval test: a single fact buried near the 430,000-token mark of a long synthetic document, asking Inkling to find it and cite the surrounding context.
• Reasoning-effort test: the same repository-planning prompt run once at "low" effort and once at "high," comparing output quality, length, and whether either pass missed an edge case.

On the multi-step coding test, Inkling isolated the actual root cause on the first pass — not the symptom described in the bug report — and wrote a regression test that failed against the unpatched code, which is the real bar for a coding model rather than a plausible-sounding explanation. On tool-calling, it handled the three sequential calls correctly, and when I deliberately had the search tool return malformed JSON on one run, Inkling retried with a narrower query instead of hallucinating a result, which is exactly the failure mode you want an agent to avoid.

The retry behavior on the malformed tool response is the detail I'd actually watch for in your own testing. A model that guesses when a tool call fails is far more dangerous in an unattended loop than one that's simply slower or more expensive.

Where the 1M context claim gets complicated

The long-context test is where Inkling's launch-day spec sheet needs a footnote. The model's declared context window is 1,048,576 tokens — a clean 1M — but the live endpoint currently serving Inkling caps individual requests at 524,288 tokens, half that figure. That's not a bug report, it's just the number worth knowing before you build a workflow around the full 1M figure on day one. Providers routinely widen the served context window in the weeks after a launch as inference capacity comes online, and Thinking Machines Lab hasn't said when that happens for Inkling.

Within the 512K ceiling that's actually available, retrieval held up well: Inkling found the buried fact at the 430,000-token mark and cited the two paragraphs around it correctly on three of three runs. I didn't have a way to test retrieval past the served limit, since the endpoint rejects requests beyond it — which is itself the practical answer to "does the 1M window work today." Right now, budget for 512K, not 1M, and treat the larger number as a roadmap item.

Reasoning effort: the lever the other two don't give you

The reasoning-effort comparison was the most useful test of the four, because it's the one capability none of the other recent agentic launches actually offer. At "high" effort — the default — Inkling produced a five-step repository plan that correctly flagged a permissions conflict between two of the steps, the same kind of downstream-consequence catch I'd expect from a careful senior engineer reviewing a plan before shipping it.

At "low" effort, the same prompt produced a comparable plan in roughly 40% fewer output tokens and noticeably faster, but it missed the permissions conflict entirely — it would have shipped a plan with a step that couldn't actually run. That's not a knock on low-effort mode; it's the tradeoff working as designed. For draft plans, brainstorming, or low-stakes agent loops where a human reviews the output anyway, low effort is a legitimate way to cut cost and latency. For anything you're letting run unattended, keep it on high or max, the same caution I'd apply to any reasoning model on launch week.

Inkling vs. Kimi K3, Grok 4.5, and Hy3

Total parameter count gets the headlines, but it's a bad way to compare these four models directly, since none of them disclose active-parameter counts consistently. Context window, pricing, and what each one actually does with reasoning control are the numbers that change how you'd use them.

Model	Total parameters	Context window	Output pricing (per 1M tokens)	Where it fits
Inkling	975B (41B active)	1M declared / 512K served	$4.05	Agentic coding, tool use, audio-in workflows, cost-tunable reasoning
Kimi K3	2.8T	1M	$15.00	Largest-scale reasoning, long-horizon agentic work
Grok 4.5	1.5T	500K	$6.00	Terminal and IDE-trained agentic coding
Hy3	Undisclosed	256K	Free/promotional	Lower-stakes agent loops and research decomposition

On price alone, Inkling undercuts Kimi K3 by roughly 3.7x on output tokens and Grok 4.5 by about 1.5x, while matching or beating both on the tool-calling and multi-step coding tests I ran. It doesn't match Kimi K3's raw context window once you account for the 512K serving cap, and it doesn't have Grok 4.5's IDE-derived training data story. What it does have that neither of them offers is a real reasoning-effort dial, which is worth more than it sounds like in a cost-bounded agent loop you're running hundreds of times a day.

Watch Mira Murati talk through Thinking Machines Lab's approach to multimodal, interaction-first models, which is the design philosophy Inkling is the first open-weight product of:

"Thinking Machines Lab exists to empower humanity through advancing collaborative general intelligence. We're building multimodal AI that works with how you naturally interact with the world - through conversation, through sight, through the messy way we collaborate." — Mira Murati on X

That framing lines up with what I actually saw in testing: the audio input support and the reasoning-effort dial both read like deliberate choices for a model meant to sit inside a longer human-AI workflow, not just answer a single prompt well.

Where Inkling fits against your current stack

A model that wins two out of four tests against your current default isn't automatically worth switching to — the switching cost is real, and launch-week benchmarks age fast. Run the same task, tool contract, and acceptance criteria you already use, and only move Inkling into daily use when it wins on something concrete: fewer output tokens for equal plan quality, cleaner recovery from a failed tool call, or a permissions conflict your current model missed.

Open the Inkling vs. Kimi K3 comparison page on Writingmate and paste in a real task from your own backlog instead of a demo prompt. That gives you a comparison you can rerun every time a new agentic release shows up in the Writingmate models catalog, rather than trusting a single launch-week write-up — including this one.

If you're wiring Inkling into an existing agent framework rather than testing it in chat, the OpenAI-compatible API docs cover how to point tools like OpenCode, Continue, or a custom agent loop at Inkling with the same request format you'd use for any other model in the catalog — useful if you want to A/B it against whatever you're running today without rewriting your integration.

Best first use cases for Inkling

• Cost-bounded agent loops where you want to dial reasoning effort down for routine steps and up for anything irreversible
• Multi-step coding tasks where the plan, patch, and test all need to stay consistent across turns
• Workflows with audio input — voice notes, call transcripts, meeting recordings — that you don't want to pre-transcribe separately
• Tool-calling pipelines that need graceful recovery from a malformed or failed tool response

I wouldn't yet trust the full 1M-token context claim in production — budget for the 512K figure that's actually being served, not the number on the spec sheet. And as with any launch-week model, I'd stage the rollout: drafts and low-stakes planning first, unattended production loops only after it beats your current default on your own prompts more than once.

Bottom line on Inkling

Inkling earns a real spot on the shortlist for agentic coding and tool-use work, not because the 975B total parameter figure is impressive on its own, but because the tool-call recovery behavior, the reasoning-effort control, and the price held up on tasks that resemble an actual working agent loop rather than a benchmark chart. It's not a strict upgrade over Kimi K3's raw context window or Grok 4.5's IDE-trained coding instincts, but for cost-bounded loops where you want control over how hard the model thinks on a given step, it's the most interesting of the three to test against your own backlog this week.