Thinking Machines Inkling-Small: A 276B Model That Beats Its Bigger Sibling

Thinking Machines Lab has released Inkling-Small, an open-weights Mixture-of-Experts model with 276B total parameters and 12B active — about a quarter the size of its first model, Inkling, yet matching or beating it on reasoning and agentic coding. The story here isn't scale; it's efficiency. This guide covers Inkling-Small's specs, its benchmark numbers straight from the release, how much it costs to run, and what an efficient open-weights model means if you're building AI agents.

What is Inkling-Small?

Inkling-Small is the second model from Thinking Machines Lab, the startup founded by former OpenAI CTO Mira Murati. It arrived roughly two weeks after Inkling, the lab's first open-weights release, and it's built around one idea: keep the capability, cut the compute.

The headline facts, from the lab's release post and model card:

• 276B total parameters, 12B active — a sparse MoE transformer. That's roughly a quarter of Inkling's 975B total / 41B active.
• 1M-token context window.
• Natively multimodal — reasons over text, images, and audio, using the same encoder-free architecture as Inkling.
• Variable thinking effort — dial reasoning up or down to trade accuracy for speed and cost.
• Open weights under Apache 2.0, on Hugging Face — including an NVFP4 quantized checkpoint for efficient inference.
• Trained on NVIDIA GB300 NVL72 systems.

Architecturally, it's a 42-layer decoder-only transformer that routes each token to 6 of 256 experts, plus 2 shared experts active on every token (model card). The MoE recipe follows the same lineage as Inkling.

The twist: the small model beats the big one

The surprising part is that Inkling-Small doesn't just approximate Inkling — on several benchmarks it pulls ahead. Thinking Machines explains why in the release: Inkling-Small started training after its larger sibling, so the team could improve the pre-training data mix and recipe, then post-train an early checkpoint using on-policy distillation with Inkling as the teacher. From there they scaled agentic-coding reinforcement learning for another two weeks (release post).

The result, in the lab's own words: Inkling-Small surpassed Inkling on reasoning and agentic coding, while Inkling keeps an edge on knowledge coverage and factuality. A concrete example — on Humanity's Last Exam (text-only) it scores 31.6%, ahead of Inkling's 29.7%, and the lab reports the advantage holds at every thinking budget.

Inkling-Small benchmarks

All numbers below are from the release, run at effort 0.99. The pattern is a broad, balanced generalist rather than a leaderboard spiker. Where a self-reported harness is involved, we flag it.

*SWEBench Verified and Terminal Bench 2.1 use the lab's own coding harnesses for the Inkling models; external models use self-reported numbers. Take cross-model comparisons with that caveat in mind — independent verification will matter.

Two takeaways. First, on the coding and reasoning tasks that matter most for agents, the small model is at least even with the big one. Second, the trade-off is factuality: on SimpleQA Verified, Inkling-Small drops to 20.6% versus Inkling's 43.9% — fewer parameters means less memorized world knowledge, which is exactly where retrieval or tools earn their keep.

Against its actual weight class, Inkling-Small is competitive with open-weights peers like DeepSeek V4 Flash, Qwen3.5-397B-A17B, and GLM 5.2 — trading wins depending on the benchmark rather than dominating.

The efficiency case: cost and compute

The real pitch is the performance-per-dollar curve. Because only 12B parameters are active per token, Inkling-Small is cheaper to serve than Inkling at a similar quality bar.

• Output pricing: Inkling-Small is listed at $1.20 / 1M tokens versus Inkling's $4.05 / 1M tokens (release post) — roughly a third the cost.
• Hardware floor: the BF16 checkpoint needs at least 600 GB of aggregated VRAM (e.g. 4× NVIDIA B300 or 8× H200). The NVFP4 quantized checkpoint drops that to 180 GB and can run on a single B300 (model card, MarkTechPost).

That single-GPU path is the headline for smaller teams: a 276B multimodal model that a startup can self-host on one rented B300, rather than needing a frontier-lab cluster.

Multimodality, epistemics, and safety

Multimodal. Inkling-Small uses the same natively multimodal, encoder-free design as Inkling — audio as dMel spectrograms, images split into 40×40 patches — and the lab says it improved the model's ability to use Python for visual tasks like cropping and zooming into charts and documents. It nearly matches Inkling across most multimodal evals at lower cost.

Epistemics. Calibration was trained with reinforcement learning against proper scoring rules on real-world forecasting questions. On ForecastBench (no search) it posts a Brier Index of 61.3 ± 0.46, slightly ahead of Inkling's 60.1 (release post).

Safety. It inherits Inkling's safety recipe. StrongREJECT sits at 98.4%, and on FORTRESS it scores 71.6% adversarial / 96.9% benign. The lab recommends layering downstream moderation such as Llama Guard on consumer-facing deployments (MarkTechPost). As with Inkling, teams that fine-tune the open weights own the safety of their customizations.

How to run it

You have three paths (model card):

1. Download the weights from Hugging Face — BF16 or the NVFP4 quantized checkpoint.
2. Fine-tune on Tinker, the lab's fine-tuning platform, which also exposes API access and a Playground for text, image, and audio chat.
3. Third-party inference providers via API for teams that don't want to host it themselves.

Why an efficient open-weights model matters for AI agents

For teams building agents, Inkling-Small sharpens the same shift Inkling started: you can run a capable, multimodal model on your own infrastructure, fine-tune it on your domain, and keep the result private — without paying per API call to a closed provider. The difference now is economics. A quarter-size model at a third of the price, with a single-GPU quantized path, moves self-hosting from "frontier-lab budget" to "one rented instance."

The variable thinking effort is the agent-native feature: slow the model down for hard planning steps, speed it up for cheap ones, all inside your own loop — which is exactly what long, multi-step workflows need. If you're comparing open options, our writeup of the original Thinking Machines Inkling covers the larger model and the fine-tune-it-yourself thesis in more depth.

Do this with your own AI workforce

Inkling-Small's whole premise — that an efficient, self-hosted model you can shape yourself beats one-size-fits-all — is the same bet behind Eigent, the open-source "Cowork" desktop app that runs a multi-agent AI workforce locally. Where Inkling-Small is a base model you fine-tune, Eigent is the workforce layer on top: a team of agents that automate real, multi-step workflows on your machine, using the models you choose. To put open-weights models to work instead of just reading benchmark tables, download Eigent and start building your own agent workflows.