Inkling 2 Small’s weights are out. What it takes to run, and how to try it free

What Thinking Machines released

On November 5, 2026, Thinking Machines introduced Inkling 2 Small as “our second model generation,” at first only on Tinker, its own platform for running and fine-tuning models, “with closed weights.” It promised the full weights under the Apache 2.0 license once external safety testing and red-teaming were done. On November 12, an update to the same post said: “Inkling 2 Small’s weights are now available for download on HuggingFace.”

It is “a Mixture-of-Experts model with 594B total parameters, 17B active, and supports image inputs and variable effort.” It reads text and images, writes text, and doesn’t take audio. The model card gives it “a context window of up to 1M tokens” and the Apache 2.0 license, which allows commercial use. There are two checkpoints: the main one in NVFP4, the 4-bit format the model was trained in, and an MXFP8 one. Hugging Face’s automatic counts read 383B and 612B parameters for the two; the 594B is Thinking Machines’ own figure.

It follows Inkling and Inkling-Small, the open-weight models Thinking Machines wrote about in A Safe Path to Open Weights on July 31. It calls the new one “more capable across the board than our first generation.”

How good it is

Artificial Analysis, which tests models itself, gives Inkling 2 Small 31 on its Intelligence Index, against a median of 24 for comparable open-weight models. On its open-weights leaderboard, that’s fourth, behind Kimi K3.1 Pro at 46, DeepSeek V4.1 Flash 1017 at 33 and GLM-5.3 at 32.

The rest of the numbers are from Thinking Machines’ announcement, which ran Inkling’s evaluations “at effort 0.99 (xhigh) and temperature 1.0.” Higher is better.

Model	Intelligence Index v5.0	SWE-Bench Pro v2 (Hard)	DeepSWE v1.1	BrowseComp
Inkling 2 Small	30.6	86.3%	72.1%	90.2%
DeepSeek V4.1 Flash 1017	32.6	89.7%	77.0%	87.8%
GLM 5.3	31.7	84.3%	69.0%	75.1%
Kimi K3	No score	88.2%	68.5%	88.4%
Mistral Large 4	26.1	83.8%	61.7%	84.5%
GPT-6 Luna	27.9	88.7%	66.6%	83.6%
Gemini 3.8 Flash	30.8	58.8%	73.8%	89.4%
Claude Haiku 5.5	36.5	52.9%	59.9%	80.2%

So it isn’t the strongest open model, even in its maker’s table: DeepSeek V4.1 Flash 1017 beats it in three of the four columns, and Kimi K3.1 Pro, which isn’t in the table, is far ahead on Artificial Analysis’s index. Where it leads is BrowseComp, a test of research on the web, though the table notes that Inkling’s score was run “with compaction” and doesn’t say the same of the others. Against the closed models in the table, it’s ahead of GPT-6 Luna on the index, about level with Gemini 3.8 Flash, and behind Claude Haiku 5.5.

It’s also slow and wordy. Artificial Analysis measured 84 tokens a second, 67.71 seconds before the first token of an answer, and 29.6 minutes per index task, against 14.6 for comparable models; it wrote 154 million tokens to finish the index. Thinking Machines lists the weaknesses itself: it “is not the most succinct communicator,” “doesn’t always choose the best tools for the job—especially in codebases with a large number of skills,” and “is also less optimized for the chat experience.”

What it takes to run

“The main NVFP4 checkpoint requires a GPU cluster with at least 500GB of aggregated VRAM,” the model card says, and the Hugging Face page gives two NVIDIA B300s or four H200s as examples. The MXFP8 checkpoint needs at least 800 GB, such as four B300s or eight H200s. vLLM, SGLang, Unsloth and TokenSpeed support it. vLLM’s recipe says to use the Docker image vllm/vllm-openai:inkling-2-small until a vLLM release includes it, and serves it on four GPUs with:

vllm serve thinkingmachines/Inkling-2-Small \
  --tensor-parallel-size 4 \
  --max-model-len 262144 \
  --max-num-seqs 256 \
  --reasoning-parser inkling \
  --speculative-config '{"method":"dspark","num_speculative_tokens":7,"draft_sample_method":"probabilistic"}'

On one four-GPU GB200 tray, that held 262,144 tokens of context; the full 1M took two trays. For agents, note that its tool-call parser, also named inkling, is opt-in, and the recipe says it is unit-tested but hasn’t had an end-to-end tool-calling benchmark.

For one big computer rather than a cluster, Unsloth has GGUF builds:

Unsloth build	Size
UD-IQ1_S (1-bit)	171.7 GB
UD-IQ2_XXS (2-bit)	190.6 GB
UD-Q2_K_XL (2-bit)	205.0 GB
UD-Q3_K_XL (3-bit)	285.1 GB
UD-Q4_K_XL (4-bit)	354.2 GB
UD-Q8_K_XL (8-bit)	386.5 GB

Unsloth’s guide adds a 658 MB file for image input, and says file size “is not total inference memory”: leave room for the system and the context, and start at 32K tokens. They need a llama.cpp built from pull request 32187, a draft opened on November 13 and not merged; Unsloth says older builds may not recognize the new inkling2 architecture, and the pull request says “Non-CUDA GPU backends run the banded op on the CPU.”

That rules out every MacBook Pro, which tops out at 128 GB. An M5 Ultra Mac Studio can be ordered with 256 GB or 512 GB, which on paper holds the 1-bit and 2-bit builds or, at 512 GB, the 4-bit one. Nobody has published Mac speeds that we could find, and on a Mac, by that note, part of the work falls to the CPU.

Ollama lists only a cloud tag, so ollama run inkling-2-small:cloud runs it on Ollama’s servers, not yours. Unsloth’s guide doesn’t mention LM Studio.

Where to try it, and what it costs

Prices per million tokens, as each host listed them on November 13:

Where	Input	Output	The catch
OpenCode, Inkling 2 Small Free	Free	Free	“For a limited time”; data kept and may be used for training; not in the EU
OpenRouter, free version	Free	Free	20 requests a minute; 50 a day until you’ve bought 10 credits, then 1,000
Tinker, serverless (beta)	$0.30	$1.00	Thinking Machines’ own; fine-tuning costs $1.50 or $3.00 per million training tokens, by context length
Cloudflare Workers AI	$0.30	$1.00	Needs Workers Paid or prepaid AI Gateway credits; zero data retention
OpenRouter, paid	$0.15 to $0.30	$0.50 to $1.00	Prime Intellect is the cheapest; DeepInfra caps context at 262,144 tokens
Ollama’s cloud	$0.30	$1.00	Runs on Ollama’s servers
Your own GPUs	Your hardware	Your hardware	500 GB of GPU memory, or a 171.7 GB build in llama.cpp

On OpenRouter, DeepInfra, Modal, Nebius, Together and Cloudflare all charge $0.30 and $1.00, and the free version is served by Thinking Machines; the limits are OpenRouter’s for all free models. Tinker’s prices cache input at $0.03, and Cloudflare’s at $0.10. Thinking Machines also names NVIDIA, Fireworks, Baseten, Nebius, Modal and Together as API hosts.

How to use it in a coding agent

1. OpenCode, free. OpenCode’s model list includes Inkling 2 Small Free, ID inkling-2-small-free: it “is free on OpenCode for a limited time.” Run /models and choose it; OpenCode shows its free models unless you set OPENCODE_DISABLE_FREE_MODELS=1. Two conditions: “Its provider retains your data and may use it for model training,” and it’s “not available in the European Union, Iceland, Liechtenstein, Norway, Cuba, Iran, North Korea, Russia, Ukraine, or Venezuela.” It works only in OpenCode: “Free-tier chat models require OpenCode.” Thinking Machines tested early versions “on OpenCode under the name Fledge-Alpha.”
2. OpenCode, through OpenRouter. Connect an OpenRouter account in OpenCode, or give it OPENROUTER_API_KEY, and refer to the model by OpenRouter’s ID after the provider prefix: openrouter/thinkingmachines/inkling-2-small, or openrouter/thinkingmachines/inkling-2-small:free.
3. Your own server. OpenCode looks for a vLLM server at http://127.0.0.1:8000/v1 on its own, and takes one elsewhere in its config:

{
  "$schema": "https://opencode.ai/config.json",
  "providers": {
    "vllm": { "settings": { "baseURL": "http://gpu-host:8000/v1" } }
  }
}

OpenCode’s docs warn that vLLM models it discovers “start with tools disabled,” because it can’t tell whether they support tools. Before you give it agent work, turn tool support on in the model’s capabilities, and turn on vLLM’s inkling tool-call parser too.

Enjoy runs OpenCode beside Claude Code, Codex and the other labs’ agents, and its model picker lists the models OpenCode offers, free ones included. So when a Claude or ChatGPT plan runs low, you can hand the conversation to Inkling 2 Small and keep going, or give it the same task to compare. Enjoy doesn’t run models itself, so the free period and its data terms are OpenCode’s and Thinking Machines’.

What to watch for

• What it did in training. “Midway through the main RL run, our asynchronous monitor flagged an instance where the model, failing at a task,” “worked around a network block through a third-party service it could reach using its search tools,” Thinking Machines writes. It “paused the run, hardened our infrastructure, removed environments that required web access.” It also says the model “still trails closed-weights models, such as GPT-6.1 Sol on our alignment evaluations,” while the model card concludes it “did not present risk of material uplift.” For agent work, that argues for a sandbox, no credentials within reach, and a look at its tool calls before you leave it alone.
• Where your code goes. The free version in OpenCode keeps what you send: “collected data is retained and may be used to monitor the model’s real-world performance and for model training.” If your code can’t be trained on, use a paid host with zero retention, such as Cloudflare, or run the weights yourself.
• Tools in big projects. By Thinking Machines’ own account, it doesn’t always pick the right tool where a project has many skills, so start it on a small job.

What isn’t known

• How long it stays free in OpenCode. OpenCode says only “for a limited time.”
• When llama.cpp support lands, and how fast it runs on a Mac.
• Its knowledge cutoff. The model card says its knowledge is limited to its training cutoff, without a date.
• Independent coding scores. Artificial Analysis’s index is independent; the coding numbers above are Thinking Machines’.

If you already use OpenCode, Inkling 2 Small costs nothing to try on a real task this week, as long as the code can go to Thinking Machines. If you need the strongest open model, Kimi K3.1 Pro still scores far higher, and DeepSeek V4.1 Flash is slightly ahead, at $0.30 in and $1.20 out on OpenCode’s paid list.