Thinking Machines Inkling API Access Guide (2026): Setup, Pricing & Code Examples

On July 15, 2026, Thinking Machines Lab, the startup founded by former OpenAI CTO Mira Murati, shipped its first model: Inkling. And they did something the big labs mostly don't. They released the weights. Apache 2.0. Download it, run it, fine-tune it, ship it in a product. No permission slip required.

That alone makes this worth a look. But the interesting part isn't just "another open model." It's the bet behind it. Thinking Machines is arguing that models organizations adapt themselves will beat the one-size-fits-all flagships from OpenAI, Anthropic, and Google. Inkling is the starting point for that, not a finished chatbot. Let's unpack what you actually get and how to use it.

What Inkling Actually Is

Inkling is a 66-layer decoder-only transformer with a sparse Mixture-of-Experts backbone. Each token routes to 6 of 256 experts, plus 2 shared experts that fire on every token. The total parameter count is 975B, but only about 41B are active for any given token. That's the standard MoE trick: you get the knowledge capacity of a giant model while paying compute closer to a mid-size one.

It's natively multimodal. Images go through a hierarchical patch encoder, audio through discrete token encoding, and everything projects into one shared hidden space that the decoder processes together. Inputs can be text, images (40px to 4096px per dimension), or audio (16kHz WAV, up to about 20 minutes). Outputs are text only for now, including code and structured data. It was pretrained on 45 trillion tokens across text, image, audio, and video.

One honest note from Thinking Machines themselves: they explicitly say Inkling is "not the strongest overall model available today, open or closed." What they're going for is well-rounded, efficient, and adaptable. On one coding benchmark, the company reports Inkling hits the same score as Nvidia's Nemotron 3 Ultra while using about a third as many tokens. Fewer tokens for the same result is a real cost lever, not a vanity metric.

Inkling Specs at a Glance

Three Ways to Access Inkling

This is where Inkling breaks from the usual model launch. There's no single "here's your $X per million tokens" chat endpoint from Thinking Machines. Instead you've got three paths, and which one you pick depends on how much control you want.

1. Fine-tune via Tinker

Tinker is Thinking Machines' own model-customization platform, and it's the headline use case. Inkling ships as a base you shape with your own data. If you have machine-learning talent in-house, this is where the "adapt it yourself" bet pays off. Start with the Tinker Cookbook and install the tml-renderers package. Keep in mind: when you fine-tune, you own the safety of your customization, not Thinking Machines.

2. Third-party inference providers

If you just want to send prompts and get completions, third-party inference providers are hosting Inkling. This is the closest thing to a normal API experience, and pricing depends entirely on the provider you pick. Most expose an OpenAI-compatible endpoint, so the request shape looks familiar:

curl https://your-inference-provider.example/v1/chat/completions \
  -H "Authorization: Bearer $PROVIDER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "inkling",
    "messages": [
      {"role": "system", "content": "You are a careful coding assistant. Flag uncertainty instead of guessing."},
      {"role": "user", "content": "Refactor this function for readability and explain the tradeoffs."}
    ],
    "max_tokens": 800
  }'

Because the interface is OpenAI-style, you can point an existing client at it with almost no code change. Here's the same call in Python using the standard OpenAI SDK:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["PROVIDER_API_KEY"],
    base_url="https://your-inference-provider.example/v1",
)

resp = client.chat.completions.create(
    model="inkling",
    messages=[
        {"role": "system", "content": "You are a careful coding assistant. Flag uncertainty instead of guessing."},
        {"role": "user", "content": "Write a Python function to parse ISO-8601 timestamps with timezones."},
    ],
    max_tokens=800,
)

print(resp.choices[0].message.content)

If you're already routing multiple models through one OpenAI-compatible gateway, adding Inkling as another option is a one-line model-name change. This is exactly the kind of setup a gateway like KissAPI is built for: keep Claude, GPT-5.6, and open-weight models like Inkling behind a single key and swap between them per task without rewriting your client.

3. Self-host the open weights

Full control, no per-token bill, and your data never leaves your infrastructure. The catch is hardware. Inkling ships in two checkpoint formats:

Serving runs on SGLang, vLLM, TokenSpeed, Unsloth, or plain Hugging Face. A minimal vLLM launch looks like this:

# Download weights from Hugging Face first
huggingface-cli download thinkingmachines/inkling --local-dir ./inkling

# Serve with vLLM (adjust tensor-parallel size to your GPU count)
vllm serve ./inkling \
  --tensor-parallel-size 8 \
  --max-model-len 1000000 \
  --quantization nvfp4

The NVFP4 quantized checkpoint is the practical choice for most teams. Dropping from 2 TB to 600 GB of VRAM is the difference between a rented 4-8 GPU box and a small datacenter cluster.

Inkling vs Other Open-Weight Options

Inkling doesn't exist in a vacuum. If you want a big open-weight model with a long context, you've got real alternatives. Here's how it stacks up on the attributes that matter for a deployment decision:

Rough Cost Picture

Since Inkling's per-token cost depends on your inference provider (or your own hardware), here's a comparison against models with published API pricing so you can frame the tradeoff. Prices are in USD per 1 million tokens.

The takeaway: if raw cost-per-token is your only goal, a text-only model like DeepSeek V4 Flash undercuts almost everything. Inkling's value shows up when you need native multimodal input, or when you plan to fine-tune it into something the general-purpose models can't match. The Bridgewater collaboration Thinking Machines cited, where a fine-tuned open model scored 84.7% on financial reasoning at roughly a fourteenth of the cost of top proprietary models, is the pattern they're pitching. Just remember those numbers came from the two companies' own eval, not an independent one.

Who Should Actually Use Inkling?

Be honest with yourself here. If you want a drop-in chatbot that beats GPT-5.6 out of the box, this isn't it, and Thinking Machines says so. Inkling makes sense if you fit one of these:

• You have ML talent and proprietary data. Fine-tuning Inkling on domain expertise is the whole point.
• You need native multimodal input. Text plus image plus audio in one open model with a 1M context is rare.
• You care about data residency. Self-hosting means prompts never leave your infrastructure.
• You want to avoid vendor lock-in. Apache 2.0 weights can't be deprecated out from under you.

If none of those apply, a hosted flagship or a cheap text-only open model will probably serve you better and cheaper.

Frequently Asked Questions

What is Inkling by Thinking Machines Lab?

Inkling is Thinking Machines Lab's first open-weights model, released July 15, 2026 under the Apache 2.0 license. It's a Mixture-of-Experts transformer with 975 billion total parameters and 41 billion active parameters, supports a context window of up to 1 million tokens, and accepts text, image, and audio inputs while producing text outputs.

How do you access the Inkling model via API?

Inkling is available for fine-tuning through Thinking Machines Lab's Tinker service, through third-party inference providers, and as downloadable open weights on Hugging Face at huggingface.co/thinkingmachines/inkling. There is no first-party pay-per-token chat endpoint from Thinking Machines, so per-token pricing depends on the inference provider you choose.

What hardware do you need to run Inkling yourself?

The BF16 checkpoint needs at least 2 TB of aggregated GPU VRAM, such as 8 NVIDIA B300 GPUs or 16 NVIDIA H200 GPUs. The quantized NVFP4 checkpoint drops that to at least 600 GB, which runs as W4A4 on 4 NVIDIA B300 GPUs or W4A16 on 8 NVIDIA H200 GPUs. Supported serving frameworks include SGLang, vLLM, TokenSpeed, Unsloth, and Hugging Face.