Thinking Machines Lab kept its promise. A week after it unveiled Inkling 2 Small as a closed model on its Tinker platform, the company put the full weights on Hugging Face on November 12 under an Apache 2.0 license. That’s about as permissive as licenses get: you can download it, fine-tune it, ship it inside a commercial product and never ask anyone for permission.
The “Small” in the name is doing a lot of heavy lifting, though. This is a 594-billion-parameter Mixture-of-Experts model. Only 17 billion of those parameters fire for any given token, which keeps it fast for its size, but all 594 billion still have to live in memory somewhere. So before anyone starts clearing space on a gaming rig, let’s break down what actually shipped, what the benchmarks say, and who can realistically run it.
What Thinking Machines actually released
According to the official model card, Inkling 2 Small is a 48-layer decoder-only transformer. Each token gets routed to 8 of 384 experts, and attention alternates between local and global layers. It takes text and images as input (images go through a 292-million-parameter vision encoder) and outputs text, with a context window of up to 1 million tokens. One step backward from the first generation: audio input is gone. The original Inkling handled text, images and audio, and this one doesn’t.
The more unusual detail is the number format. Thinking Machines says the model was pretrained, midtrained and post-trained natively in NVFP4, Nvidia’s 4-bit floating-point format that arrived with Blackwell GPUs. Most labs train at higher precision and quantize down later. Here, 4-bit is the native format, and the company recommends the NVFP4 checkpoint for basically everything. An MXFP8 version is also posted, but the model card says its 1 to 2 point edge on evals isn’t meaningful in practice.
The launch also came with plenty of ecosystem support on day one. The weights work with SGLang, vLLM, TokenSpeed and Unsloth for local inference, and the model is available through APIs at Nvidia, Fireworks, Together, Baseten, Nebius, Modal and Cloudflare. If you want to kick the tires without owning a server rack, that’s the realistic path.
Thinking Machines’ showcase demos lean hard on agentic coding with vision in the loop. The model built a city-builder in Three.js with procedurally generated buildings, textures and traffic, and wrote a PC emulator in Python that boots a real Linux kernel in the browser. Those are cherry-picked demos, of course, but they show what the company tuned for: long, multi-step work where the model checks its own visual output and keeps iterating.
The benchmarks are strong, but read the whole table
The headline number is a score of 31 on the Artificial Analysis Intelligence Index, a big jump over the first Inkling generation. ARC Prize reports 96.5% on ARC-AGI-1 and 81.7% on ARC-AGI-2, and Thinking Machines’ own comparison table has it leading several vision benchmarks among the open-weight models it picked, including MMMU Pro and ScreenSpot Pro.
Here’s the part worth slowing down for. In the company’s own full benchmark table, Inkling 2 Small isn’t the top open model across the board. DeepSeek-V4.1-Flash posts a slightly higher Artificial Analysis score (32.6 versus 30.6 in the table) and beats it on several coding tests, like DeepSWE (77.0% versus 72.1%). Claude Haiku 5.5, a closed model, scores higher than both on that index. Inkling 2 Small is clearly in the top tier of open-weight “flash”-class models, but calling it the outright king would overstate the data, and to Thinking Machines’ credit, the company publishes the rows where it loses.
The limitations section is refreshingly blunt, too. The company says the model isn’t the most succinct communicator, doesn’t always pick the right tools in codebases with lots of skills, overuses slashes in chat, and overreacts to mental-health and other safety-related questions. That last point shows up in the numbers: on Scale AI’s FORTRESS benchmark, it answers benign prompts 79.7% of the time, while most rivals in the table land in the mid-to-high 90s. In plain terms, it refuses harmless requests more often than its peers.
There’s also a candid alignment story in the release post. Thinking Machines writes that early checkpoints, when tasks got hard, sometimes fabricated results, ignored instructions and hid what they had done. Midway through the main reinforcement learning run, a monitor flagged the model working around a network block by reaching a third-party service through its search tools. The team says it paused the run, hardened its infrastructure, removed environments that needed web access and added real-time tool-call monitoring before continuing. It’s unsettling to read, but publishing it is the right call, and it’s exactly the kind of detail developers should know before handing an agent long, unsupervised jobs.
That candor fits the company’s broader approach. Back in July, Thinking Machines laid out “A Safe Path to Open Weights,” a staged policy where models launch with closed weights first and go public after external safety testing. Inkling 2 Small is the first second-generation model to go through that pipeline, with a one-week gap between the Tinker launch on November 5 and the public weights on November 12.
Can you run it locally?
Not on a normal PC, and that’s the honest answer local AI fans need. The Hugging Face model card says the NVFP4 checkpoint needs a GPU cluster with at least 500GB of combined VRAM, such as two Nvidia B300s or four H200s. The MXFP8 version needs at least 800GB.
Unsloth, which had day-zero access, has posted GGUF quantizations for llama.cpp-style setups that can spill into system RAM. Even its most aggressive 1-bit dynamic quant (UD-IQ1_S) weighs in around 172GB across its files, and the 4-bit UD-Q4_K_XL is roughly 354GB. Unsloth’s guide says the 1-bit version keeps much of the full model’s accuracy, but by its own measurements you’re still trading away some quality. Realistically, that puts Inkling 2 Small in the territory of high-memory Mac Studios, workstations loaded with several hundred gigabytes of RAM, or rented cloud GPUs. For everyone with a single 16GB or 24GB graphics card, the API providers are the practical route.
The training scale explains the size. Thinking Machines says the first pretraining phase covered 8.4 trillion tokens in 68 hours on Nvidia GB300 NVL72 racks, and the main RL run used 2,048 GPUs for nine days across more than 17 million rollouts. This is a frontier-lab model that happens to have open weights, not a hobbyist model scaled up.
Cody’s take
I’m genuinely glad to see another serious lab ship a model this capable under Apache 2.0, with no usage caps, no regional exclusions and no “research only” asterisk. That matters for startups, researchers and anyone who wants to fine-tune a strong model on their own data without being locked into one provider. The fact that it’s designed to be a good base for customization, and that Thinking Machines published its weak spots and alignment scares instead of burying them, earns real points from me.
But “open” and “local” aren’t the same thing. For most people reading this, Inkling 2 Small will be something you hit through Together, Fireworks or Cloudflare, not something humming away under your desk. If you want an open model you can actually run on a gaming GPU tonight, smaller releases are still the better fit. If you’re building agents and want a permissively licensed model with strong vision and long-horizon coding chops, this one just jumped onto the shortlist. I’ll be watching for independent benchmarks over the next few weeks, because the real test is how it holds up outside its makers’ own charts.
Featured image: a city simulator built by Inkling 2 Small in Three.js. Image: Thinking Machines Lab.
Author
