Inkling-Small: Thinking Machines Ships a 12B-Active Open Model That Beats Its Big Sibling on Agent Work

On July 30, Thinking Machines Lab released Inkling-Small, an open-weights Mixture-of-Experts model with 276B total parameters and only 12B active per token. It matches or beats the 975B Inkling - its own 41B-active flagship from July 15 - on reasoning, agentic coding, and tool use, at a quarter of the size. Tinker serverless pricing starts at $0.30 per million input tokens and $1.20 per million output, against Inkling's $1.00 / $4.05. The big model's small sibling is the more interesting developer option, and that is the point.

Cover: Thinking Machines Lab (via the official Inkling-Small announcement).

Official Sources#

What Shipped#

Inkling-Small is a 42-layer decoder-only transformer with a sparse MoE feed-forward backbone: each token routes to 6 of 256 experts plus 2 shared experts. It keeps the flagship's natively multimodal, encoder-free architecture - audio comes in as dMel spectrograms, images as 40x40-pixel patches through a lightweight hMLP - and its 1M-token context window. It was trained on NVIDIA GB300 NVL72 systems and released under Apache 2.0 with full weights on Hugging Face, in BF16 and NVFP4 formats.

The training story is the unusual part. Thinking Machines post-trained an earlier Inkling-Small preview checkpoint with on-policy distillation using Inkling as the teacher, then spent two more weeks scaling agentic coding RL. The result, per their own numbers: Inkling-Small surpassed Inkling on reasoning and agentic coding benchmarks, while Inkling keeps the edge on knowledge coverage and factuality.

Benchmarks#

All scores from the announcement, evaluated at effort 0.99. Coding scores come from Thinking Machines' internal harness (bash-only for SWEBench Verified), so treat cross-lab comparisons with the usual caveats; the caveats they state are in the announcement footnotes.

Two numbers deserve attention. SWEBench Verified at 80.2% puts it in the top tier of open-weights coding models, above DeepSeek V4 Flash (79.0) and Nemotron 3 Ultra (70.7). And the efficiency gap over Inkling shows in token counts: on GDPval-AA v2, Inkling-Small scores 1269 Elo at 23k output tokens per task, while Inkling scores 1238 at 28.6k and DeepSeek V4 Flash 1189 at 28.2k. Same ballpark of quality, fewer tokens spent per task.

The honesty tradeoff is visible in the factuality row: SimpleQA Verified drops from 43.9% on Inkling to 20.6% on the small model. If your workload leans on knowledge recall rather than tool use, this is the number to notice.

Pricing#

First-party Tinker rates (serverless inference beta, list price; a limited-time 50% discount is applied on Tinker today):

Worked example from the vendor's own eval numbers: a GDPval-AA-style agent task costs about $0.028 on Inkling-Small at list price (23k output tokens), versus $0.116 on Inkling (28.6k output tokens). A quarter of the compute and roughly a quarter of the cost per task, for a higher Elo. The Tinker IDs are thinkingmachines/Inkling-Small (64K context) and thinkingmachines/Inkling-Small:peft:262144:sampling-nvfp4 (256K, quantized sampling). Fine-tuning on Tinker is also available.

How to Run It#

Inkling-Small is not in OpenCode's default model list - we verified opencode models --verbose ships no inkling entry. The official Tinker docs cover wiring a Tinker model into OpenCode through its OpenAI-compatible endpoint, and the same pattern works with a base model. In your opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "tinker": {
      "env": ["TINKER_API_KEY"],
      "npm": "@ai-sdk/openai-compatible",
      "models": {
        "thinkingmachines/Inkling-Small": {
          "name": "Inkling-Small",
          "reasoning": true,
          "temperature": true,
          "tool_call": true,
          "limit": { "context": 65536, "output": 8192 }
        }
      },
      "options": {
        "baseURL": "https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1",
        "apiKey": "{env:TINKER_API_KEY}"
      }
    }
  }
}

Export TINKER_API_KEY (from the Tinker Console) and select the model in the picker. The endpoint is OpenAI-compatible, so the same pattern works in any agent harness that speaks that dialect. Alternatively, route through Vercel AI Gateway, which added Inkling-Small on July 30, or self-host: the BF16 checkpoint needs about 600GB aggregated VRAM (4x B300 or 8x H200), while the NVFP4 checkpoint runs W4A16 on 2x H200 or W4A4 on a single B300, with SGLang, vLLM, TokenSpeed, or Unsloth support.

Inkling-Small vs the Alternatives#

Choose Inkling-Small when: the workload is agentic - coding, tool use, MCP-style calls, long terminal sessions. It is the efficiency play in the current open-weights field: V4 Flash-class agent scores at comparable per-token cost, with better tool-use numbers (MCP Atlas 79.6 vs 69.0) and roughly a fifth of the output price of the closed mid-tier.

Choose Inkling (the big one) when: knowledge coverage and factuality dominate - SimpleQA, broad Q&A, general knowledge work. The 43.9 vs 20.6 factuality gap is real, and Inkling stays the reference for that profile.

Stay on the closed tier when: you need Luna-style frontier agent throughput (SWEBench 93.0, Terminal Bench 82.5 are materially ahead of every open model in this class). The open-weights gap has narrowed to roughly 10 points on coding; it has not closed.

Where it fits the trend: this is the second consecutive release cycle where a vendor's small open model beat its big sibling on the benchmarks that matter to agents - the same pattern as DeepSeek V4 Flash 0731 passing its own Pro preview. The economics of running 12B active parameters with a 1M context and native audio is where the open-weights race is being won.

FAQ#

What is Inkling-Small?#

An open-weights (Apache 2.0) Mixture-of-Experts model from Thinking Machines Lab, released July 30, 2026. It has 276B total parameters with 12B active per token, native text/image/audio inputs, and up to 1M-token context.

How much does Inkling-Small cost?#

On Tinker serverless inference: $0.30 per million input tokens ($0.06 cached), $1.20 per million output, with a limited-time 50% discount. For comparison, Inkling is $1.00 / $4.05.

Is Inkling-Small available through OpenCode?#

Not in the default model list. The official Tinker docs show wiring any Tinker model into OpenCode via the OpenAI-compatible endpoint with a custom provider in opencode.json; the config above does exactly that.

Can I run Inkling-Small locally?#

Yes. The NVFP4 checkpoint needs about 180GB of VRAM (1x B300 in W4A4 mode, or 2x H200 in W4A16). The BF16 checkpoint needs roughly 600GB (4x B300 or 8x H200). SGLang, vLLM, TokenSpeed, and Unsloth are supported.

How does it compare to DeepSeek V4 Flash?#

Very close on coding and reasoning: SWEBench 80.2 vs 79.0, HLE 31.6 vs 32.1. Inkling-Small leads on tool use (MCP Atlas 79.6 vs 69.0, Toolathlon 54.4 vs 50.9) and uses fewer output tokens per task; DeepSeek V4 Flash has the lower input price and a longer release history.

Sources#

Last updated: July 31, 2026

Continue Reading#

• Inkling: Thinking Machines Drops a 975B Open-Weights Model - the flagship this model distills from
• DeepSeek V4 Flash 0731: Benchmarks, Pricing, and OpenCode Setup - the sibling release-guide treatment of the V4 Flash agent update
• GLM 5.2 vs DeepSeek V4 vs Qwen3: The Open-Weights Coding Showdown - how the open field stacks up head to head
• Frontier Model API Pricing, June 2026 - where $1.20/M output sits against the closed tier
• Self-Hosting Open-Weights Models: The Break-Even Math - whether the 180GB NVFP4 route pays for itself
• Andrew Ng Launches LearnVector: AI-Native One-to-One Learning with $100M from Coursera