Inkling 2 Small review (2026): honest verdict on Thinking Machines Lab's 594B/17B vision MoE — specs, benchmarks, the closed-weights launch, and its real limits.
Inkling 2 Small is a strong second-generation efficiency model: a 594B/17B mixture-of-experts with vision input that posts top-tier open-model scores on agentic coding, reasoning, and design. For drafting, coding, and visual reasoning it's excellent. The honest caveats: its weights are closed at launch (Tinker-only, open Apache 2.0 release planned but not yet shipped), it dropped the audio input the first Inkling line had, it's less polished in chat — and like any language model it writes text but renders no media and publishes nothing.
Inkling 2 Small is the second-generation efficient model from Thinking Machines Lab, the lab founded by former OpenAI CTO Mira Murati. It was introduced on November 5, 2026, and I reviewed it as what it is at launch: a fast, capable, vision-enabled language model you reach through hosted inference — not a content or publishing platform it never claimed to be, and not yet the open-weights download its predecessors were on day one.
The headline is capability-per-parameter. It's a mixture-of-experts with about 594 billion total parameters and roughly 17 billion active per token, trained natively in NVFP4 on NVIDIA GB300 NVL72 racks and post-trained with a single large reinforcement-learning run that replaced the separate reasoning and agentic stages of the first Inkling. On Artificial Analysis's Intelligence Index it scores around 31, and it posts strong agentic-coding, vision, knowledge-work, and design numbers — on one DesignArena website-building leaderboard snapshot it ranked as the top open-weights entry, with that ranking explicitly pending its weights release. It also reads images and uses that vision to inspect and refine its own code and design output, which is a genuinely useful loop.
The honest caveats are three. First, availability: at launch the model is Tinker-only with closed weights, and the full Apache 2.0 release is planned after external safety testing — described as roughly a week out at announcement — so the "open" part is a promise, not a download, on the review date. Second, scope: it takes text and image input but dropped the audio input the first Inkling and Inkling-Small supported, and it outputs text only — no media of any kind. Third, polish: Thinking Machines notes it's less concise and less organized in chat than the best closed models. This review scores it as a model. Where it fits, where you'd need something else, and an honest note on where Kompozy sits are all below.
Inkling 2 Small is Thinking Machines Lab's second-generation efficient model. It's a mixture-of-experts — about 594B total parameters, roughly 17B active per token — that takes text and image input (via a vision encoder) and responds in text, with up to a 1M-token context and a controllable reasoning-effort dial. It was trained natively in NVFP4 on NVIDIA GB300 NVL72 systems and uses a single unified RL run rather than the separate reasoning and agentic-RL stages of the first Inkling. It generates code, websites, small games, and 3D scenes, and uses its vision input to visually self-check that output. At launch it is available through the company's Tinker platform with closed weights — inference, fine-tuning, and sampling in Tinker Playground — with the full weights planned under Apache 2.0 after external safety testing and red-teaming. What it is not is a content tool: no image or video generation, no captioning, no carousel or graphic rendering, no brand-voice governance, no scheduler, and no publishing. It reasons and writes; that's where its job ends.
Inkling 2 Small fits developers and teams who want a capable, efficient model for code, agentic tasks, and visual reasoning, and who are comfortable using it through Tinker until the weights ship. Its vision-plus-code self-checking loop is a real draw for anyone building web or design tooling. For creators specifically, it's a sharp drafting and visual-reasoning front end — hand it a reference screenshot or a brief and it writes a script or an outline — but it's a weak fit for anyone who assumed "AI model" meant a shortcut to finished posts, because once the text is written, rendering media, sizing per platform, and publishing are all still ahead of them, and Inkling 2 Small does none of it. Teams that require self-hosting on day one should also wait for the open-weights release.
| Dimension | Score | Why |
|---|---|---|
| Efficiency & architecture | 4.4 / 5 | A 594B/17B MoE trained natively in NVFP4 with a single unified RL run — strong capability for its active-parameter cost. |
| Reasoning & agentic coding | 4.4 / 5 | Top-tier open-model scores on agentic-coding and reasoning benchmarks; one of its clearest strengths. |
| Vision & multimodal input | 4.1 / 5 | Reads images and self-checks its own visual output — but input only, and it dropped the earlier line's audio support. |
| Design & code generation | 4.3 / 5 | Builds websites, games, and 3D scenes; ranked top open-weights on a DesignArena snapshot pending weights release. |
| Context length | 4.2 / 5 | Up to a 1M-token context handles long documents and transcripts comfortably. |
| Openness & availability | 3.3 / 5 | Closed weights at launch, Tinker-only; Apache 2.0 open release planned after safety testing but not yet shipped. |
| Chat polish & usability | 3.4 / 5 | Thinking Machines notes it is less concise and less organized in chat and can over-disclaim on sensitive prompts. |
| Content & publishing capability | 1.5 / 5 | None by design — no media generation, captions, brand voice, or publishing. It stops at text. |
Pricing is the part that's least settled at launch. Thinking Machines has not published a per-token rate for Inkling 2 Small the way it did for earlier models; access runs through its Tinker platform, which links to its own pricing page, and the launch write-up illustrated cost only with example spend on a research task. So on the review date, "what does it cost to run" depends on Tinker's current rates rather than a headline number I'd want to quote firmly. Once the Apache 2.0 weights ship, self-hosting will cost only your own GPU and infrastructure to serve a 594B mixture-of-experts — real, but yours to control.
For a creator, the more useful framing is what any model price does and doesn't buy: it buys text. The total cost of turning that text into published content still includes whatever you spend on image generation, video, captioning, design, and scheduling on top — none of which the model provides.
For context on the other side of that line, a shipping content engine meters finished output rather than tokens. Kompozy, for example, runs credit-based tiers from $199/mo (5,500 credits) up through a sales-led enterprise plan, covering generation across 18 formats plus publishing. The two aren't priced on the same axis — tokens (or infra) versus finished, distributed posts — and that difference is the whole point of the comparison.
| Use case | Fit | Why |
|---|---|---|
| Agentic coding & tool use | Strong | Top-tier open-model scores and a vision loop that self-checks generated code and interfaces. |
| Visual reasoning & image-to-text | Strong | Native image input turns a screenshot or mockup into structured text directly. |
| Website / design generation | Strong | It builds and visually refines sites, games, and 3D scenes — a standout at its size. |
| High-volume text drafting | Strong | Efficient MoE design makes drafting scripts and outlines at scale practical. |
| Day-one self-hosting / data control | Weak | Weights are closed at launch; self-hosting has to wait for the planned open release. |
| Audio-to-text ingest | Weak | Unlike the earlier Inkling models, it does not accept audio input at all. |
| Making finished social posts | Weak | It writes the text but renders no media and publishes nothing — most of the job is left undone. |
| Multi-platform publishing | Weak | There is no scheduler or platform integration; publishing needs a separate engine entirely. |
The fair way to place Kompozy against Inkling 2 Small is to admit they're not competing — they're adjacent halves of a pipeline. Inkling 2 Small is a model: it drafts, reasons, reads images, and codes, and it does that well. Kompozy is a content engine: it drafts too, but its real work starts where the model's ends — generating the persona and avatar video, carousels, quote graphics, blogs, and newsletters a language model can't render, keeping them on-brand with a Persona Brief and HyperFrames, and publishing to the eight primary social platforms plus blog and email with scheduling and autopilot.
So if you're reading this review to decide whether Inkling 2 Small is "worth it" for a content operation, the honest answer is that it's worth it as a drafting and visual-reasoning layer and not much use as the whole solution. Its text-only scope means you'll still need a rendering and publishing layer on top, and at launch you're reaching it through Tinker rather than running it yourself. The natural setup is to let Inkling 2 Small do the drafting, image-reading, and code work it's genuinely good at, then hand the winners to an engine like Kompozy to turn into finished, scheduled posts. One writes the words; the other ships them.
Inkling 2 Small is Thinking Machines Lab's second-generation efficient model, introduced November 5, 2026. It is a mixture-of-experts — about 594B total parameters, roughly 17B active per token — that takes text and image input and responds in text, with up to a 1M-token context and a controllable reasoning-effort dial.
Not at launch. It is available through Thinking Machines' Tinker platform with closed weights for inference, fine-tuning, and sampling, and the company says it plans to release the full weights under the Apache 2.0 license after external safety testing and red-teaming — described as roughly a week out at announcement. So the open release is planned, not yet shipped, as of this review.
It is a newer, larger-but-still-efficient generation — about 594B total / 17B active versus Inkling-Small's 276B/12B — with stronger agentic-coding, vision, and reasoning benchmarks. The trade-offs: it takes text and image input only (it dropped audio), and its weights are closed at launch rather than open on day one like Inkling-Small.
As a capable, efficient model for coding, visual reasoning, and drafting at volume, yes — it posts top-tier open-model scores. As a complete content solution, no: it outputs text only, so you'll still need media generation and a publishing layer, and at launch you access it through Tinker rather than self-hosting.
No. It reads images and reasons over them but outputs text only — it does not render images, video, or audio, and unlike the earlier Inkling models it does not accept audio input. To turn its text into finished posts you pair it with a generation and publishing engine like Kompozy.
At launch it runs through Thinking Machines' Tinker platform (inference, fine-tuning, sampling) with closed weights. The company plans to release downloadable weights under Apache 2.0 after external safety testing, which would let you self-host a 594B mixture-of-experts on your own hardware — a real infrastructure task despite the low active-parameter count.
Use it to draft scripts and caption packs and to turn a reference screenshot into structured text, then bring the best into a content engine like Kompozy to render persona video, carousels, quote cards, blogs, or newsletters in your brand voice and publish them across platforms. The model writes; the engine ships.