Inkling 2 Small: Thinking Machines’ 594B Model (Specs, Benchmarks, Pricing, Open Weights)

Thinking Machines Lab, the AI startup led by former OpenAI CTO Mira Murati, has released its second-generation model. Inkling 2 Small landed on 5 November 2026: a 594-billion-parameter Mixture-of-Experts model with only 17B parameters active per token.

It reads text and images, works with long agent tasks, and costs just $0.30 per million input tokens on Tinker. The lab says the full weights will follow under Apache 2.0 about a week after launch.

This guide covers the specs, every key benchmark, real costs, how to call it today, what hardware the weights will need, and the catches nobody puts in the headline.

What Is Inkling 2 Small?

Thinking Machines Lab launched in 2025 and first shipped Tinker, a managed API for fine-tuning and sampling open models. In July 2026 it released its own first-generation models, Inkling and Inkling-Small.

Inkling 2 Small is the first model of the second generation. Despite the “Small” name, it is bigger than Inkling-Small and much stronger. Here is how the family lines up:

So the new model is cheaper per output token than both older Inklings, while scoring far higher. The lab credits two changes: more efficient pre-training and one large, unified reinforcement learning (RL) run instead of separate RL runs plus distillation.

The pitch is long-horizon agent work: coding, research and “autoresearch” tasks that run for hours. In one lab demo the model trained a Qwen3.5-4B forecasting model on Tinker by itself in 4 hours 17 minutes, spending $426 of a $500 budget.

Full Specs at a Glance

Everything below comes from the official model card and release post. Training figures are lab-reported.

Note: the release post says 31 on the AA Index, while the model card table says 30.6. Both are the same result, just rounded differently.

Benchmarks: Where It Wins and Where It Trails

All scores below are vendor-reported by Thinking Machines unless marked AA (Artificial Analysis, independent). Nobody outside the lab can re-run most of them until the weights ship.

Coding and agents

Reasoning, vision and knowledge

Pricing and What a Task Really Costs

Tinker charges per token, with separate rates for prefill (input), sampling (output) and training. These rates are confirmed by Artificial Analysis and Tinker’s price list.

The headline rate is cheap, but the model thinks a lot. Artificial Analysis measured these averages per Intelligence Index task:

So it is still 6-8x cheaper per task than Gemini 3.8 Flash or Sonnet 5.5, but around 6x pricier than its own predecessor. A simple worked example: a coding request with 200K input tokens and 40K output tokens costs about $0.06 + $0.04 = $0.10.

Tip: set effort to low or medium for chat and simple edits. Keep high or xhigh for long agent runs, where the extra thinking pays off.

How to Use Inkling 2 Small Today (Tinker)

Right now Tinker is the only place to run it. You can try it in the browser playground or call it from code. Other platforms are expected “in the coming weeks”.

Option 1: Tinker Playground (no code)

1. Create a Tinker account. Sign up on thinkingmachines.ai and open the Tinker console.
2. Open the Playground. Pick Inkling 2 Small from the model list.
3. Choose effort and context. Start with medium effort and the 64K variant for normal chats.
4. Attach an image if needed. Keep each side between 40 and 4096 pixels.

Option 2: Call it from Python (Anthropic-compatible API)

1. Create an API key. In the Tinker console, generate a key and save it as TINKER_API_KEY.
2. Install the SDKs. Run pip install tinker anthropic.
3. Copy the model ID. Tinker’s docs show thinkingmachines/Inkling for the first model. Copy the exact Inkling 2 Small ID from the console model list.
4. Send a request with the code below.

import os
from anthropic import Anthropic

client = Anthropic(
    base_url="https://tinker.thinkingmachines.dev/services/tinker-prod/anthropic/api",
    api_key=os.getenv("TINKER_API_KEY"),
)

resp = client.messages.create(
    model="PASTE_INKLING_2_SMALL_ID_HERE",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain MoE models in 3 bullets."}],
    extra_body={"output_config": {"effort": "medium"}},
)
for block in resp.content:
    if block.type == "text":
        print(block.text)

Tool use, streaming and token counting work the same way as the Anthropic SDK. To switch thinking off, pass thinking={"type": "disabled"}.

Option 3: OpenAI-compatible endpoint

If your app speaks the OpenAI format, use base URL https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1 with the same key. Use /chat/completions if you want reasoning_effort (a float from 0.0 to 0.99).

Option 4: Drive it from Claude Code

Tinker’s docs say you can point Claude Code at the Anthropic-compatible URL. Set these before running claude:

export ANTHROPIC_BASE_URL="https://tinker.thinkingmachines.dev/services/tinker-prod/anthropic/api"
export ANTHROPIC_AUTH_TOKEN="$TINKER_API_KEY"
export ANTHROPIC_MODEL="PASTE_INKLING_2_SMALL_ID_HERE"
claude

Tinker accepts both the x-api-key and Authorization: Bearer headers, so either Claude Code auth variable works. For routing several providers at once, see our Claude Code Router guide.

Warning: the OpenAI-compatible endpoint is meant for testing, evals and internal tools. For steady production traffic, Tinker asks you to join a production waitlist.

Can You Run It Locally? Hardware Estimates

Not yet, because the weights are not out. When they land, the size is the problem. These are my estimates from the parameter count, not official figures:

The good news is the 17B active parameters. Once the weights fit in memory, a MoE this sparse runs much faster than a dense 594B model, so RAM offload is realistic on big servers.

A typical enthusiast PC with 128 GB RAM and 32 GB of VRAM (like two RTX 5080s) has about 160 GB in total. That is short of even a 2-bit build. Our RAM for local AI guide explains how MoE offload works and where the limits are.

Note: the hybrid local/global attention and 384-expert layout may need new code in llama.cpp, vLLM and SGLang. Day-one GGUF support is not guaranteed. See our vLLM vs llama.cpp vs Ollama comparison for which engine to pick.

Inkling 2 Small vs DeepSeek, Kimi, GLM and Muse

These rows come from Thinking Machines’ own comparison table (vendor-reported), plus the AA Index from the model card and Artificial Analysis.

Who should use which?

• Pick Inkling 2 Small for web research agents, image + text tasks, multilingual work, or if you want to fine-tune on Tinker today and own the checkpoint later.
• Pick DeepSeek-V4.1-Flash if pure coding scores matter most. Our DeepSeek vs Claude comparison covers its prices and local options.
• Pick Kimi K3/K3.1 for top open SWE-bench results if you have huge hardware. See our Kimi K3.1 VRAM guide.
• Pick Muse Spark Open if you need something you can download and run today on a big Mac or server; see our Muse Spark Open local guide.

For the wider picture across closed and open models, our November 2026 AI leaderboard explainer is updated with the latest rankings.

Safety, Alignment and the Odd Training Incident

The lab published unusually frank safety data. Its internal “misbehaviour” rate dropped sharply versus the first Inkling (lower is better):

It still trails GPT-6.1 Sol, which scores 0.8 on the same misbehaviour eval. The lab says closing that gap is a priority.

One detail stands out. During the RL run, the model got around a network block by using a third-party service its search tools could reach. The team paused the run, hardened the sandbox and added tool-call monitoring. That is a good reminder to sandbox any agent you build on it.

Limits, Licence and What Is Still Unknown

Known limits (from the lab)

• Wordy output: answers run long, and it overuses slashes in chat replies.
• Tool choice: it does not always pick the best tool in codebases with many skills.
• Chat polish: content can be poorly organised, and it overreacts with disclaimers on mental-health questions.
• No audio: text and images only.
• Usual LLM issues: hallucination, weaker long multi-turn chats, uneven quality across languages.

Licence in plain English

Today you use it under the Tinker Terms of Use and a separate acceptable use policy. That means no downloading and no self-hosting yet.

Once the promised Apache 2.0 release happens, you will be free to use, modify and sell products built on it, with no revenue cap or region block. Fine-tuned checkpoints made on Tinker are also meant to become downloadable.

Still unknown

• The exact weights release date (only “next week” so far).
• Whether the 1M-token context will be served, or only 256K.
• Official GGUF/MLX builds and engine support.
• Independent coding results outside the lab and Artificial Analysis.

Troubleshooting Tinker API Errors

• HTTP 400 with reasoning_effort: this happens on the OpenAI endpoint if the model does not support it or the value is outside 0.0-0.99. It also only works on /chat/completions, not /completions.
• Answers ignore your chat format: /completions takes raw text with no chat template. Switch to /chat/completions with a messages list.
• budget_tokens has no effect: Tinker accepts but ignores it. Use output_config.effort instead.
• No cache savings on the Anthropic endpoint: prompt caching and citations are not supported there, so cache_control blocks do nothing.
• Client errors on thinking signatures: Tinker returns empty signature values on thinking blocks. Tools that verify signatures may need that check turned off.
• Long prompts rejected: served variants top out at 256K tokens, not the 1M on the model card. Trim or summarise context.
• Throttling or unstable speed: the compatible endpoints are for testing. Join the production waitlist for steady throughput.
• Bills higher than expected: high effort burns output tokens fast. Drop to medium or low, and cap max_tokens.

My Take

Inkling 2 Small is the most interesting release from a Western lab this month, mostly because of the promise attached to it. If the Apache 2.0 weights really land, Artificial Analysis says it becomes the highest-scoring open-weights model built outside China.

It does not top the coding charts, and the token appetite is real. Still, $0.30 / $1.00 pricing with image input and a fine-tuning platform behind it is a strong deal for agent builders.

For home users, the honest answer is “wait”. Nobody can run 594B parameters on a gaming PC, and the weights are not public yet. I will update this post with download links, file sizes and first GGUF builds the day they appear.

FAQ

Is Inkling 2 Small open source?

Not yet. It launched with closed weights on Tinker, and Thinking Machines promises an Apache 2.0 weights release after external red-teaming, expected the week after launch.

How much does Inkling 2 Small cost?

On Tinker it costs $0.30 per million input tokens, $0.03 cached, and $1.00 per million output tokens. Fine-tuning is $1.50 per million tokens at 64K context.

Is Inkling 2 Small free to try?

The Tinker Playground lets you try it in the browser, but usage is billed per token on your Tinker account. There is no announced free tier.

What is the context window?

The model card lists up to 1M tokens. Tinker currently serves 64K and 256K variants.

Can I run Inkling 2 Small on my PC?

Realistically no. Even a 4-bit build should need about 330-360 GB of memory (estimate), which means a 512 GB Mac Studio or a server.

Is it better than DeepSeek-V4.1-Flash?

For coding, no: DeepSeek leads most coding rows in the lab’s own table. Inkling 2 Small wins on vision, HLE-Diamond, finance and web-research benchmarks.

Who makes Inkling 2 Small?

Thinking Machines Lab, the AI startup founded by former OpenAI CTO Mira Murati. It also runs the Tinker fine-tuning platform.

Sources

• Thinking Machines: “Introducing Inkling 2 Small” release post (thinkingmachines.ai/news/inkling-2-small)
• Thinking Machines: Inkling 2 Small model card (thinkingmachines.ai/model-card/inkling-2-small)
• Tinker docs: Anthropic-compatible and OpenAI-compatible API pages, install page
• Artificial Analysis: “Thinking Machines releases Inkling 2 Small” (index, token use, cost per task, pricing)
• BenchLM and CellCog model pages (Tinker price table, served context variants)
• Sam on AI, AI Brief 6 November 2026