TL;DR: Thinking Machines released the full Inkling-Small weights on July 30, 2026 — 276B total parameters, 12B active, Apache 2.0, with Unsloth GGUFs live the same day. The 2-bit dynamic quant is 87.9GB, which fits a single RTX PRO 6000 96GB. It’s the highest-scoring open-weights model at or below its size — but it exactly ties DeepSeek V4 Flash, whose API costs $0.14 per million input tokens.

	Inkling-Small (local)	Inkling 975B (API)	DeepSeek V4 Flash (API)
Best for	Air-gapped/privacy-first coding on owned hardware	Multimodal work, fine-tuning base via Tinker	Cheapest credible daily coding backend
Price / Cost	$0/token after ~$13,250 GPU (or existing rig)	$1.87/$4.68 per M (64K tier, launch discount)	$0.14/$0.28 per M tokens
The catch	Ties V4 Flash on quality at 100× the entry cost	Too big to self-host; not a coding leader	Your code transits DeepSeek’s cloud

Honest take: Inkling-Small is a genuinely impressive engineering result and the new best open-weights model you can fit on one workstation card — but as a coding backend, DeepSeek V4 Flash delivers the same measured intelligence tier for pocket change via API. Run Inkling-Small locally if privacy or offline operation is the requirement, or if the hardware is already on your desk. Don’t buy a $13,250 GPU for it.

What actually shipped on July 30

Thinking Machines announced Inkling-Small alongside the 975B Inkling flagship on July 15, but as a preview — weights withheld pending testing. That testing finished: on July 30, 2026, the company released the full weights, stating the model “achieves comparable performance to Inkling at a quarter of its size.”

The verified spec sheet, cross-checked against the announcement, the Hugging Face model card, and Latent Space’s coverage:

• Architecture: Mixture-of-Experts transformer, 276B total parameters, 12B active per token
• License: Apache 2.0 — no MAU caps, no attribution clauses, commercially clean
• Modalities: natively multimodal; text, image, and audio processed jointly
• Thinking effort: controllable, carried over from the flagship
• Checkpoints: standard BF16 weights (~544GB) plus a native NVFP4 checkpoint for NVIDIA Blackwell hardware
• Inference support at launch: SGLang, vLLM (day-0), TokenSpeed, and llama.cpp, with Unsloth dynamic GGUFs published the same day
• Fine-tuning: available on Thinking Machines’ Tinker platform from day one, with free chat in Tinker Playground

That last point signals the company’s actual positioning. Like the flagship, Inkling-Small is pitched as a customization base — the announcement highlights “coding, using LLMs to grade, or generating synthetic data” as the workloads where 12B active parameters and low latency pay off.

One number worth pausing on: 544GB of BF16 weights compressing to an 87.9GB usable quant. Unsloth’s dynamic 2-bit method (UD-Q2_K_XL) is what makes the single-card story possible at all, and their 1-bit UD-IQ1_S variant goes down to 74.8GB if you need more KV-cache headroom. A 3-bit UD-Q3_K_XL sits around 120GB — that one needs a second card or unified memory.

The benchmarks: matches its 975B sibling, ties a 284B rival

Vendor charts first, independent data second — and the independent data is the more interesting story.

From Thinking Machines’ own comparison (flag: vendor-reported), Inkling-Small matches or beats the 975B flagship on several benchmarks. The clearest published win is instruction following: IFBench 83.4% vs the flagship’s 79.8%. On SWE-bench Verified, the announcement reports Inkling-Small above 80% — measured on a bash-only harness, so not directly comparable to leaderboard numbers from agent-framework harnesses. For Terminal-Bench 2.1, both models are reported on an internal coding harness, with a footnote worth respecting: solutions found contaminated by web search were scored zero. That level of self-policing is rare in launch posts.

The independent signal comes from Artificial Analysis, which ran Inkling-Small within a day of the weights drop:

Metric (Artificial Analysis, independent)	Inkling-Small	Inkling 975B	DeepSeek V4 Flash
AA Intelligence Index	40	41	40
Total / active params	276B / 12B	975B / 41B	284B / 13B
AA-Omniscience (knowledge)	−9 (31% accuracy)	2 (40% accuracy)	—
Hallucination rate	57%	63%	—

Three takeaways. First, the headline claim holds up independently: one point behind the flagship with less than a third of the parameters, and no open-weights model at Inkling-Small’s size or below scores higher — MiniMax-M2.7 (230B/10B active) sits two points back.

Second, the weakness is exactly where you’d expect for a smaller total-parameter count: factual knowledge. An AA-Omniscience score of −9 against the flagship’s 2 means the model knows meaningfully less about the world. For coding, that translates to weaker recall of obscure library APIs and version-specific behavior — the kind of thing that matters most when your agent has no web search.

Third — and this is the finding that drives the verdict — DeepSeek V4 Flash lands on the identical index score of 40, from a similar shape (284B total, 13B active). We covered V4 Flash as a Cursor and Cline backend in June: it costs $0.14/$0.28 per million tokens via API. Two models, one measured intelligence tier, radically different delivery costs.

What doesn’t exist yet: any independent SWE-bench or Terminal-Bench run on Inkling-Small, and any community consensus on how well its tool calling holds up inside agent loops. The flagship’s launch numbers (SWE-bench Verified 77.6%, Terminal-Bench 2.1 63.8%, also vendor-reported) are the nearest anchor. Treat coding quality as “credible mid-tier, unproven in agents” until third-party runs land.

Hardware reality: what actually runs it

The quant table decides everything here.

Quant	Size	Fits on
UD-IQ1_S (dynamic 1-bit)	74.8GB	RTX PRO 6000 96GB with ~21GB KV headroom
UD-Q2_K_XL (dynamic 2-bit)	87.9GB	RTX PRO 6000 96GB, tight (~8GB headroom)
UD-Q3_K_XL (dynamic 3-bit)	~120GB	128GB unified-memory box, 2× 96GB, or 4× RTX 3090 + RAM offload
BF16	~544GB	Multi-node territory — not a home-lab conversation

The single-card path runs through the NVIDIA RTX PRO 6000 Blackwell, and here’s the bad news: NVIDIA’s official marketplace price rose to $13,250 in June 2026 — a 55% increase over the March 2025 MSRP, driven by the GDDR7 shortage, per Tom’s Hardware. Secondary-market listings run higher still.

Cheaper roads exist. Four used RTX 3090s give you 96GB of pooled VRAM for roughly a tenth of the price, at the cost of power draw, tensor-parallel setup, and PCIe bandwidth bottlenecks on a MoE this wide. A 128GB unified-memory Strix Halo box handles the Q2 and even Q3 quants at lower speed. Our sister site’s VRAM-by-model guide is the right starting point if you’re sizing a rig for a model this wide — motherboards, offload patterns, and the measured constraints that matter.

And if you want the model without the capex: renting a 96GB-class GPU by the hour on RunPod lets you benchmark Inkling-Small against your real workload for a few dollars before any purchase decision. Given the cost math below, that trial run is the single highest-value step in this article.

The 12B-active MoE math is the one genuinely friendly number: token generation touches only 12B parameters per step, so once the weights are in memory, throughput lands in the same speed class as a dense ~12B model — this is the same bandwidth arithmetic that made Ornith-1.0’s 3B-active design quick on a 3090.

Wiring it into Cline and Cursor

llama.cpp is the least-friction serving path for the GGUF quants. One command pulls the quant from Hugging Face and exposes an OpenAI-compatible endpoint:

llama-server -hf unsloth/Inkling-Small-GGUF:UD-Q2_K_XL \
  -c 32768 --port 8080
# expected: "main: server is listening on http://127.0.0.1:8080"

Watch the -c flag. Coverage of the release doesn’t state Inkling-Small’s native context ceiling (the flagship is 1M native, though Tinker’s hosted tiers expose 64K and 256K), but your practical limit on a 96GB card is KV cache: with the Q2 quant occupying 87.9GB, the ~8GB that remains supports modest contexts only. Start at 32K for agent work, drop to the 74.8GB 1-bit quant if you need more window, and don’t expect long-context miracles on one card.

Cline: Settings → API Provider → OpenAI Compatible. Base URL http://localhost:8080/v1, any non-empty API key, model ID as reported by curl http://localhost:8080/v1/models. This is the same wiring as every local backend we’ve covered; if Cline can’t reach the server, the fixes in our Ollama connection-refused guide apply identically to llama-server.

Cursor: Settings → Models → API Keys → Override OpenAI Base URL to http://localhost:8080/v1, add the model ID manually. Two standing traps from our GLM 5.2 and local-model setup coverage still apply: the base-URL override is global (it disables Cursor’s cloud models while active), and Tab completion always runs Cursor’s proprietary cloud model regardless — only Chat, Cmd+K, and Agent respect the override.

vLLM is the better path if you have Blackwell hardware and want the NVFP4 checkpoint instead of GGUF — Inkling had day-0 vLLM support and the recipe lives at recipes.vllm.ai. For a single consumer-class card, stick with llama.cpp.

One thing to test before trusting it with a real refactor: tool-call reliability. No community reports existed as of July 31 on how Inkling-Small behaves across Cline’s 20-plus-tool loop, and we’ve seen strong models flub structured tool calls at launch — qwen3-coder’s XML fallback saga being the canonical example. Give it three small bounded tasks before anything multi-file.

The cost math nobody at the launch party ran

Here’s the break-even against the two API backends that bracket Inkling-Small’s quality tier, assuming the $13,250 single-card build. Claude Sonnet 5’s pricing was re-verified today against Anthropic’s official pricing page: $2/$10 per million tokens through August 31, 2026, then $3/$15 standard.

A heavy solo developer — roughly 40 agentic sessions a week at ~50K input / 8K output each — burns about 8.6M input and 1.4M output tokens a month:

Backend	Monthly cost (heavy solo)	Break-even vs $13,250 GPU
Claude Sonnet 5 (standard, from Sep 1)	~$47	~23 years
DeepSeek V4 Flash	~$1.60	never, effectively
Inkling-Small local	$0/token + electricity	—

Even an aggressive multi-agent fleet — 300M input and 50M output tokens a month — costs about $1,650/month on standard Sonnet 5 (break-even ~8 months, the one scenario where the card pays for itself) but only ~$56/month on DeepSeek V4 Flash. At V4 Flash prices, the GPU never pays for itself on token savings. And V4 Flash, remember, scores the identical 40 on the independent intelligence index.

So the economics are unambiguous: you don’t buy this hardware to save money on an Inkling-Small-tier model. You buy it — or already own it — because the code can’t leave the building, because you want zero cloud dependency after a summer in which a frontier model vanished overnight by government order, or because you’re fine-tuning on proprietary code, which is the use case Thinking Machines built Tinker around. Against that requirement set, Inkling-Small is now the strongest Apache 2.0 model that fits one card, full stop.

For everyone else, the cost-comparison framework still points to API routing: V4 Flash or GLM 5.2 for volume work, Sonnet 5 for the hard 20%.

Where it breaks

The knowledge gap is real and measurable. A −9 AA-Omniscience score with 31% accuracy means Inkling-Small will confidently misremember niche framework APIs more often than the flagship or frontier cloud models. Pair it with documentation in context (or an MCP docs server) rather than trusting recall.

Coding benchmarks are vendor-only right now. “Above 80% SWE-bench Verified on a bash-only harness” is promising and the contamination-zeroing footnote earns goodwill, but until vals.ai or the tbench.ai leaderboard runs it, the honest label is unverified. The 975B flagship’s verified-at-launch numbers trailed Sonnet 5 and DeepSeek V4 Pro on both major coding suites — expect Small to sit at or below that line in agent harnesses.

Hosted access is murkier than the flagship’s. Inkling 975B runs on Fireworks, Modal, Databricks, and Baseten with OpenAI-compatible endpoints; as of July 31, provider pages hadn’t uniformly confirmed Inkling-Small serving. If you want it via API rather than local metal, check your provider’s model list before planning around it — self-hosting is the only guaranteed path this week.

And the single-card fit is tight. 87.9GB of weights on a 96GB card leaves little room for KV cache, so long agentic sessions with big context will force you to the 1-bit quant, with whatever quality tax that carries. Unsloth’s dynamic quants hold up better than naive quantization at these bitrates, but 2-bit is 2-bit — run your own evals on your own codebase before promoting it to daily driver.

FAQ

Is Inkling-Small actually available to download now? Yes. The full weights went live July 30, 2026 on Hugging Face under Apache 2.0, in BF16 and NVFP4, with Unsloth GGUFs (74.8GB–120GB usable range) published the same day. Earlier “weights pending testing” coverage from the July 15 flagship launch is outdated.

Can I run it on a 24GB card like an RTX 4090? No. The smallest usable quant is 74.8GB. The realistic floor is 96GB of VRAM or a 128GB unified-memory machine. On 24GB cards, look at Ornith-1.0 35B or the models in runaihome’s VRAM guide instead.

Is it better than DeepSeek V4 Flash for coding? Independent measurement says they’re the same intelligence tier (both score 40 on the AA index). Neither has an independent agentic-coding run yet at these sizes. The decision comes down to delivery: V4 Flash is $0.14/M via API; Inkling-Small is $0/token on hardware you must already justify some other way.

Does it work with Ollama? Launch-day support is SGLang, vLLM, TokenSpeed, and llama.cpp. Ollama typically follows for major GGUF releases; llama-server gives you the identical OpenAI-compatible endpoint today, so nothing about the Cline/Cursor wiring waits on it.

What about fine-tuning it on my team’s code? That’s the use case Thinking Machines is explicitly courting — Tinker supports Inkling-Small from day one, and Apache 2.0 means the resulting checkpoint is yours. For self-hosted FOSS tooling around that workflow, aifoss.dev covers the open-source side of the stack.

Recommended Gear

• NVIDIA RTX PRO 6000 Blackwell — the only single card that fits the 87.9GB Q2 quant
• NVIDIA RTX 3090 — four used units = 96GB pooled VRAM on a budget, with tensor-parallel caveats

Sources

• Introducing Inkling-Small — Thinking Machines Lab (official announcement)
• Thinking Machines release announcement — X, July 30, 2026
• thinkingmachines/Inkling-Small — Hugging Face model card
• unsloth/Inkling-Small-GGUF — dynamic GGUF quantizations
• Inkling — How to Run Locally — Unsloth documentation
• Inkling Small lands within a point of Inkling on the Intelligence Index — Artificial Analysis
• Thinky’s Inkling: 975B-A41B multimodal, with Inkling-Small 276B-A12B — Latent Space AINews
• thinkingmachines/Inkling — vLLM recipes (day-0 serving)
• Nvidia raises RTX Pro 6000 Blackwell pricing to $13,250 — Tom’s Hardware
• Claude API pricing — Anthropic official docs (Sonnet 5 verified July 31, 2026)

Last updated July 31, 2026. Model availability, quant sizes, and GPU prices change frequently; verify current state against the official pages before purchasing hardware.