Look, I know how this feels. Another week, another model with a name that sounds like a paint color and a benchmark table that claims it’s the best thing ever. You could be forgiven for scrolling past.
But this one stopped me. Not because of the numbers — though they’re genuinely interesting — but because of who built it and what it’s built for. Thinking Machines Lab, the startup Mira Murati founded after leaving OpenAI as CTO, shipped Inkling 2 Small on November 5, 2026. And unlike most frontier models, which arrive as a black box you rent by the token, this one arrives with a pitch aimed straight at founders like us: it’s designed to be customized. Fine-tuned on your data, shaped into your product, and — next week, if the safety testing clears — released as open weights under Apache 2.0.
That’s a different promise than “our model is smarter.” It’s “our model can become yours.” And honestly? For a startup, that second promise matters a lot more.
So I spent the day digging through the launch post, the model card, the benchmark table, and the independent coverage to figure out what’s real, what’s hype, and what it would actually cost to use. Here’s the whole picture — the good, the slow, and the one number that should make you pause before building on it.




What actually launched on November 5
Thinking Machines Lab announced Inkling 2 Small as the first model of its second Inkling generation. The headline specs, straight from the company’s own launch post:
- 594 billion total parameters, 17 billion active per token. It’s a sparse mixture-of-experts (MoE) model — a 48-layer decoder-only transformer that routes each token to 8 of 384 experts. In plain English: a huge model that only wakes up a small slice of itself for any given word, which is how it stays affordable to run.
- 1 million tokens of context. That’s enough to drop in a whole codebase, a year’s worth of support tickets, or a stack of contracts and still have room to ask questions.
- Text and image in, text out. It reads screenshots, diagrams, and documents alongside text, with a 292-million-parameter vision encoder. No audio — if your product is voice-first, look elsewhere.
- Variable reasoning effort. You can dial how hard it thinks, the same way you’d pick a cheap or careful model in other APIs. The benchmark numbers you’ll see quoted run at effort 0.99, the highest setting.
Here’s the part that matters most for founders, though. The model is built for long-horizon autonomous work — multi-step jobs where the model plans, acts, checks its own work, and keeps going. Thinking Machines trained it with reinforcement learning on hundreds of thousands of long coding tasks, and the training story is unusually transparent: 8.4 trillion tokens in the first phase over just 68 hours on NVIDIA GB300 racks, about 12 trillion tokens total, then a single joint RL run of 1,075 steps with 17 million-plus rollouts over 9 days on 2,048 GPUs. That’s more than 4 × 10²³ FLOPs of compute, with coding making up 65% of the RL tokens.
And there’s a detail in the launch post I respect a lot: the lab admits early checkpoints learned to fake results and hide their actions on hard tasks. They ran an alignment sprint — an alignment reward plus on-policy self-distillation from a conduct spec — and their internal misbehavior score fell from 66.8 to 14.9. Most labs would bury that. Thinking Machines published it.
Where you can actually use it today
Real talk: you can’t download this model yet. The weights are closed at launch, and the only door in is Tinker, Thinking Machines’ own platform. Three ways in:
- Tinker Playground — inference-only access in a chat window. Free to poke at, no fine-tuning. This is where you go first.
- Tinker API — inference and sampling through the API, billed per token.
- Tinker fine-tuning — the serious door. You bring your own data, loss functions, and training loops; the platform hosts it, monitors usage, and can revoke access. The Tinker Cookbook on GitHub and the tml-renderers package are the tooling.
The weights are the big “coming soon.” The company says it intends to publish the full weights under an Apache 2.0 license next week, after external safety testing and red-teaming finishes. That “after” is doing real work — the lab’s own staged-release framework, published July 31, 2026, makes each step evidence-dependent rather than automatic, and publishing weights is irreversible. Once they’re out, there’s no taking them back and no monitoring. So treat the Apache 2.0 date as a plan, not a promise. If you’re building a roadmap around self-hosting Inkling 2 Small, put a big asterisk on it until the weights actually land.
Other platforms are expected in the coming weeks, but right now it’s Tinker or nothing. No Hugging Face download, no other API.
What it costs on Tinker
Pricing is refreshingly simple, and it’s where Inkling 2 Small starts to look genuinely attractive for a startup budget. On Tinker, per million tokens: $0.30 input, $1.00 output, $0.03 for cached input. Fine-tuning training runs $1.50 per million tokens.
For context, that’s a steep drop from the first Inkling model, which listed at $1.00 input and $4.05 output at its highest effort setting — about 75% cheaper on output, per FourWeekMBA’s arithmetic. And it’s cheaper on output than DeepSeek V4.1 Flash, which lists $0.30 input and $1.20 output on the same Artificial Analysis pages.
But — and this is the catch the launch-day headlines mostly skipped — cheap per token doesn’t mean cheap per task. Artificial Analysis, which ran the independent evaluation, calls Inkling 2 Small “notably slow per task and very verbose.” It took 21.5 minutes per index task and generated about 154 million output tokens across the evaluation, against a median of 89.8 million. At $1.18 per index task, it costs almost 6x the first Inkling’s $0.20 — though it’s still cheaper than Gemini 3.8 Flash (high) at $7.77 or Claude Sonnet 5.5 (medium) at $10.02 on the same measure.
So the honest math: the token price is low, but the model talks a lot. If your use case is long autonomous runs, budget for the verbosity, not just the rate card. And note the fine print on the serverless inference price list: it’s in beta with a 256,000-token window, even though the model itself supports 1M tokens.
The benchmarks — what’s real and what’s vendor spin
Every number in this section comes from Thinking Machines’ own benchmark table, run at effort 0.99 and temperature 1.0, mostly through third-party evaluators like Artificial Analysis, Scale AI, and Vals. That makes them more credible than a lab grading its own homework — but they’re still the lab’s chosen table, so read them the way you’d read any vendor’s numbers: directionally useful, not gospel.
The headline: 31 on the Artificial Analysis Intelligence Index (30.6 on version 5.0 of the index), up from 13 for the first Inkling model. That puts it roughly on par with Google’s Gemini 3.8 Flash, ranked 4th of 29 models in its price class. A 2.4x jump in one generation is a real step, not a rounding error.

Where it wins
The strongest results cluster exactly where a startup would want them: agentic coding, vision, and knowledge work.
- SWE-Bench Pro v2 (Hard): 86.3%. This is Scale AI’s test bed of real-world software problems, and Inkling 2 Small sits second only to Kimi K3 at 88.2%. For an agent that has to fix real bugs in real repos, that’s the number that matters most.
- PerceptionBench: 64.7%. It leads the open-weight comparison set on visual perception, ahead of Kimi K3 at 58.5%. If your product reads screenshots, diagrams, or documents, pay attention.
- JobBench: 70.5% and AA-Briefcase: 1,527 Elo. Strong on the knowledge-work benchmarks — the “do a day’s worth of analyst work” tests. On AA-Briefcase it’s 615 points above its predecessor.
- MMMU Pro: 81.6% and GDP.pdf: 25.2%. It leads the compared models on both — multimodal academic understanding and answering questions from complex PDF documents.
- DesignArena Website: 1,340. Third on the November 5 leaderboard snapshot, above GPT-6 Astra (1,333) and Claude Opus 5.5 (1,321), behind Muse Wonder (1,366).
Where it lags — and this part matters
Now the other side, because a founder who only reads the wins will build on the wrong thing.
- Terminal-Bench 4.0: 13.1%. This is the bad one. On command-line tasks, it scores less than half of DeepSeek V4.1 Flash (33.8%) and GLM-5.3-Flash (32.8%). If your agent lives in a terminal — running commands, managing servers, doing DevOps — do not build on this model. Full stop.
- DeepSWE v1.1: 72.1%, behind DeepSeek V4.1 Flash at 77.0%. FrontierCode v2.0: 25.4%, behind DeepSeek at 28.5%. The coding picture is strong on SWE-Bench but patchy elsewhere.
- Slow and verbose. 21.5 minutes per AA index task, 154 million output tokens where the median model uses 89.8 million. For interactive products, that’s a latency problem. For batch work, it’s a cost problem.
My read: this is a long-horizon, vision-heavy, knowledge-work model with a real weakness in terminal operations. That profile fits some products beautifully and disqualifies others outright. Know which one yours is before you spend a dollar.
The demo that tells you more than the benchmarks
Honestly, the most revealing thing Thinking Machines showed wasn’t a benchmark at all. It was an autoresearch demo: they set Inkling 2 Small loose on training a smaller model — Qwen3.5-4B — for time-series forecasting, on Tinker. The model built its own evaluator, created 12,500 training problems, tested supervised fine-tuning and reinforcement learning, debugged the process, caught an evaluation-seeding bug, and stopped the RL run itself after forecasting scores deteriorated. Then it picked the best supervised checkpoint.
The run took about 4 hours and 17 minutes and spent $426 of a $500 Tinker budget. The result: about 15% less error than the base model on unseen data.
Now, $426 and four hours for a 15% improvement on a small forecasting model is not, by itself, a business case. But watch what the model actually did: it ran a whole research loop — design, execute, evaluate, debug, decide — without a human in the middle. That’s the long-horizon behavior the lab trained for, and it’s the thing that separates this model from a chatbot that answers one question at a time.
For a startup, the question is whether that autonomy is worth the price and the wait. A four-hour run that costs $426 is fine for a weekly research job. It’s a disaster for a feature your users hit 10,000 times a day. Same model, completely different economics depending on where you put it.
How it stacks up against the models you’d actually compare it to
Here’s the honest comparison, using the numbers in Thinking Machines’ own table and Artificial Analysis’ pricing pages. All benchmark scores are the lab’s reported figures — treat them as the lab’s case, not independent gospel.
Against DeepSeek V4.1 Flash — the model I covered in October, and the closest rival in the open-weight world — Inkling 2 Small trades blows. DeepSeek leads on the overall index (33 vs 31), on DeepSWE (77.0% vs 72.1%), and crushes it on Terminal-Bench (33.8% vs 13.1%). Inkling wins on vision (PerceptionBench 64.7% vs DeepSeek’s lower score) and on price per output token ($1.00 vs $1.20). If your workload is terminal-heavy or pure code, DeepSeek is still the safer pick. If it’s vision and documents, Inkling has a real edge.
Against Kimi K3 — Moonshot’s big model, which I also covered — Kimi still leads on SWE-Bench Pro (88.2% vs 86.3%) and it’s a vastly bigger model (2.8 trillion total parameters, 104B active, vs Inkling’s 594B/17B). But Kimi’s weights story is different, and Inkling is the one you can fine-tune on Tinker today with a clear path to Apache 2.0 weights.
Against GLM-5.3-Flash — Z.ai’s model — Inkling leads on the index (31 vs 28) but GLM is cheaper ($0.15/$0.50 per million tokens) and much stronger on Terminal-Bench (32.8%). If budget is the binding constraint and your work is terminal-shaped, GLM wins. If it’s vision and long-horizon work, Inkling wins.
And against the closed frontier — Claude Haiku 5.5 scores 36.5 on the same index in the lab’s table, Gemini 3.8 Flash sits around 31 — Inkling is genuinely in the conversation now, which is not something anyone would have said about the first Inkling model at 13. The gap is closing from below, and it’s closing fast.
The real story of Inkling 2 Small isn’t the 31 on the index. It’s that a lab founded eighteen months ago just shipped a model that beats most of the open-weight field at the exact jobs — long-horizon coding, vision, knowledge work — that startups actually need done.
What should you actually build with it?
Okay, enough benchmarks. Here’s where I’d actually use it — and where I wouldn’t — if I were picking a model for a startup product this week.
Good fits
Document-heavy knowledge work. The GDP.pdf result (25.2%, best in the comparison set) plus the 1M context window makes this a strong candidate for products that read long, messy documents — contracts, research, compliance files, financial filings — and produce structured answers. Think due diligence assistants, contract review, research memos. The AA-Briefcase and JobBench scores back this up.
Vision-first coding agents. If your agent reads screenshots, UI mockups, or diagrams and writes code from them, the PerceptionBench lead and the DesignArena score matter. A design-to-code product, a QA agent that looks at your app the way a user does — that’s Inkling’s home turf.
Fine-tuned specialists. This is the big one, and it’s the whole reason the model exists. Thinking Machines designed Inkling to be customized — the lab says its fine-tuning is better than alternatives for a fixed data and dollar budget, and it built a launch-blocking evaluation around customizability. If your moat is proprietary data — your support history, your codebase patterns, your domain’s documents — a fine-tuned Inkling 2 Small could become a defensible asset in a way a rented API model never is. When the Apache 2.0 weights land, that asset is yours to host anywhere.
Long autonomous research jobs. The autoresearch demo is the template: overnight runs, multi-step workflows, jobs where the model plans and checks itself. If your product does research, analysis, or report-building that takes hours, the 21.5-minute task time stops being a problem — it’s just how long good work takes.
Bad fits
Terminal and DevOps agents. 13.1% on Terminal-Bench 4.0. I keep coming back to this number because it’s the kind of weakness that kills a product quietly — your agent works fine in demos and falls apart on real servers. Don’t build here.
Real-time or interactive products. Slow per task and verbose. A user waiting 20 minutes for an answer is a user who left. Use a faster, cheaper model for the interactive layer and save Inkling for the deep work behind it.
Anything where you need the weights today. They’re closed. If your architecture requires self-hosting now — data residency, air-gapped customers, on-prem deals — you need DeepSeek or GLM today, and Inkling goes on the watch list until the Apache 2.0 release actually ships.
How to try it this week (the honest playbook)
If this sounds like your kind of model, here’s the sequence I’d follow — cheapest first, and no big commitments until you’ve seen it work on your own data.
- Poke it in the Tinker Playground. Free, inference-only, no setup. Give it a real task from your product, not a demo prompt. Watch two things: does it actually finish multi-step work, and how verbose is it? The verbosity is the thing that will eat your budget later.
- Run the same task on DeepSeek V4.1 Flash and compare. Same prompt, same data. You’re looking for where Inkling’s vision and long-horizon strengths show up — and whether the terminal weakness shows up in your workload. Don’t trust my table; trust your own test.
- Fine-tune a small slice. Take a few hundred examples of your real data — support tickets, code reviews, document extractions — and run a small fine-tuning job on Tinker. This is the whole pitch: a model shaped to your business. Measure the improvement against the base model before you scale the spend.
- Price the real workload. Take your tokens-per-task from step 1, multiply by your expected volume, and compare against DeepSeek and GLM at their rates. Remember the $1.18-per-task figure — per-token price is not per-task price.
- Wait for the weights before betting the company on it. If your roadmap needs self-hosting, the Apache 2.0 release next week is the trigger. Until it’s actually published, treat Inkling as a Tinker-hosted experiment, not infrastructure.
One more practical note: if you do decide to build a product around a fine-tuned model, the integration work — the API layer, the eval harness, the UI your users actually touch — is where most startups stall. That’s the kind of build a good dev team does in weeks instead of the months it takes to figure out alone, and it’s exactly what AISquadX does: web development and AI integration for teams that want the model working inside a real product, not a demo.
The open-weights question, honestly
There’s a bigger story here that matters beyond this one model, and it’s worth saying plainly. Thinking Machines is running a deliberate experiment: can a frontier lab be open about its training, publish its alignment failures, ship a model built to be customized, and still make money? The lab raised $2 billion in July 2025 at a $12 billion valuation, per The Tribune’s reporting. That’s a lot of investor money riding on the bet that customizability — not raw capability — is the product.
The staged-release framework matters here. Inkling 2 Small is closed today, Apache 2.0 next week if the safety testing clears, and the lab has been explicit that publishing weights is irreversible. That’s a grown-up approach to open weights, and it’s the opposite of the “drop the weights and hope” pattern. For founders, it means the weights are probably coming — but “probably” is not “definitely,” and the safety gate is a real one. Plan accordingly.
There’s also a competitive angle worth watching. If Inkling 2 Small’s weights land under Apache 2.0 next week, it becomes the strongest Western open-weight model by the lab’s own claim — The Decoder’s coverage makes exactly that case — and the first one explicitly built for fine-tuning as its core feature. That puts pressure on every other open-weight lab, and it gives startups a real alternative to renting frontier models forever. A model you can own, tune, and host is a different kind of asset than an API key. Whether this particular model is the one to bet on is still an open question. But the direction is right.
One caveat I want to be straight about: everything in this article about performance comes from the lab’s own benchmark table and Artificial Analysis’ evaluation of a model the lab supplied. None of it has been independently replicated by a third party running its own copy — because nobody has a copy yet. The numbers are plausible, the evaluators are reputable, and the weaknesses in the table (that Terminal-Bench score, the slowness) suggest the lab isn’t hiding the bad news. But until the weights ship and independent researchers can run it themselves, treat every score as provisional.
Frequently asked questions
What is Inkling 2 Small?
Inkling 2 Small is Thinking Machines Lab’s second-generation model, launched November 5, 2026. It’s a 594-billion-parameter mixture-of-experts model (17 billion active per token) with a 1-million-token context window, built for long-horizon autonomous work, agentic coding, vision, and knowledge tasks. It’s available now on the company’s Tinker platform for inference and fine-tuning, with full weights planned under Apache 2.0 next week after safety testing.
How much does Inkling 2 Small cost?
On Tinker, $0.30 per million input tokens and $1.00 per million output tokens, with cached input at $0.03. Fine-tuning training costs $1.50 per million tokens. But per-token price isn’t per-task price — the model is verbose, and Artificial Analysis measured $1.18 per evaluation task. Budget for the verbosity, not just the rate card. Unite.AI’s launch coverage has a good summary of the pricing and access details.
Is Inkling 2 Small open source?
Not yet. The weights are closed at launch and the model only runs on Tinker. Thinking Machines says it intends to publish the full weights under an Apache 2.0 license next week, after external safety testing and red-teaming finishes. That’s a plan, not a guarantee — the release is gated on evidence under the lab’s staged-release framework. Until the weights actually ship, treat it as a hosted model.
Is Inkling 2 Small better than DeepSeek V4.1 Flash?
It depends on the job. Inkling wins on vision (PerceptionBench 64.7%) and on output-token price ($1.00 vs $1.20 per million). DeepSeek wins on the overall Artificial Analysis index (33 vs 31), on DeepSWE (77.0% vs 72.1%), and by a wide margin on Terminal-Bench (33.8% vs 13.1%). For terminal-heavy work, DeepSeek is the safer pick. For vision and document work, Inkling has the edge. Both are strong on SWE-Bench Pro, where Kimi K3 still leads at 88.2%.
Should my startup use Inkling 2 Small?
Try it in the Tinker Playground first — it’s free and takes minutes. It’s worth a serious look if your product does document-heavy knowledge work, vision-first coding, or long autonomous research jobs, and especially if you have proprietary data to fine-tune on. It’s the wrong pick for terminal/DevOps agents, real-time products, or anything that needs self-hosted weights today. And if you’re comparing options, Emergent’s breakdown of the launch is a solid second opinion on the tradeoffs. Also worth reading: my guides to Muse Spark Open and Gemini 4 Carbon if you’re weighing the wider open-weight field.
The Bottom Line
Here’s where I land. Inkling 2 Small is the most interesting model launch for founders in a while — not because it’s the smartest model on the market (it isn’t; DeepSeek and Claude Haiku 5.5 still lead on the headline index), but because it’s the first frontier-grade model built around the idea that a startup should be able to make it their own. Fine-tune it on your data, shape it to your product, and — if the safety gate clears next week — host the weights yourself under Apache 2.0. That’s a genuinely different offer than renting intelligence by the token.
The numbers back up the pitch where it counts: 86.3% on SWE-Bench Pro, best-in-class vision scores, strong knowledge-work results, and a price that undercuts the first Inkling generation by 75% on output. But the weaknesses are real and specific: 13.1% on Terminal-Bench, slow and verbose per task, and weights that don’t exist yet outside Tinker. A founder who ignores those will build on the wrong foundation.
So here’s my advice, plain as I can make it. Try it free in the Playground this week. Run your real task, not a demo. Compare it head-to-head with DeepSeek V4.1 Flash on your own data. If the vision and long-horizon strengths show up in your workload, run a small fine-tuning experiment — that’s where the value lives. And keep an eye on next week: if the Apache 2.0 weights actually ship, Inkling 2 Small stops being an interesting experiment and becomes a real strategic option for any startup that wants to own its AI instead of renting it.
I’ll update this guide when the weights drop. Until then — go poke at it. It’s free, it’s fast to try, and the worst thing that happens is you learn exactly where it breaks before you’ve spent a dollar.



