Inkling: Thinking Machines’ open-weights model is built to be customized

Thinking Machines Lab has released Inkling, its first open-weights model. It is now available on the app.nz gateway as thinkingmachines/inkling (or the shorter inkling alias), routed directly to the company's Tinker inference API.

Inkling is unusually interesting because the release is not framed as a narrow coding checkpoint or a benchmark specialist. It is a general model built for reasoning, agentic software work, tools, and multimodal interaction—and its Apache 2.0 model card makes the weights genuinely usable outside a single hosted product.

A large model with a relatively small active footprint

Inkling is a mixture-of-experts model with 975 billion total parameters and 41 billion active parameters per token. It has 256 routed experts plus two shared experts; six routed experts are selected for each token. That does not make self-hosting easy, but it does separate total model capacity from the work done on each token.

The attention stack alternates sliding-window and global layers at a 5:1 ratio. Thinking Machines also replaced RoPE with a learned relative-position scheme. The model was pretrained on 45 trillion tokens spanning text, images, audio, and video, and the underlying model supports contexts up to one million tokens.

There is an important serving distinction: Tinker currently exposes Inkling in 64K and 256K configurations. The direct app.nz route starts with the 64K configuration, so the catalog advertises what this upstream can serve today, not the largest context mentioned in the research release.

What it can do

The practical surface is broad:

• agentic coding and multi-step tool use;
• controllable reasoning effort, including none, minimal, low,

medium, high, and xhigh through Tinker's OpenAI-compatible API;

• image input through standard OpenAI content parts;
• native text, image, and audio capabilities in the released model;
• continued training and customization through Tinker.

That last point is central. Inkling is the base model for Thinking Machines' training platform, so the same identity can refer to the base model, a training checkpoint, or a saved sampler path. The Inkling cookbook shows supervised fine-tuning, reinforcement learning, checkpoint sampling, tool calls, controlled effort, and multimodal examples rather than treating inference as the end of the workflow.

Launch results, with the usual caveat

Thinking Machines reports the following results for its high-effort configuration:

These are vendor-reported launch numbers. They are useful for forming a test shortlist, not a substitute for evaluating your own repository, tool harness, latency budget, and output-token limits. The controllable effort setting also means two requests to “the same model” can have meaningfully different cost, latency, and quality.

Use Inkling through app.nz

The route uses the standard OpenAI client. No Tinker-specific SDK is required:

from openai import OpenAI

client = OpenAI(
    base_url="https://app.nz/v1",
    api_key=APP_NZ_API_KEY,
)

response = client.chat.completions.create(
    model="thinkingmachines/inkling",
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": "Review this patch and identify risky assumptions."}
    ],
)
print(response.choices[0].message.content)

Or use curl:

curl https://app.nz/v1/chat/completions \
  -H "Authorization: Bearer $APP_NZ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "inkling",
    "reasoning_effort": "medium",
    "messages": [{"role": "user", "content": "Plan a safe database migration."}]
  }'

The same catalog entry is visible in the web gateway, Go desktop client, CLI, and MCP servers. In the CLI, app gateway models --provider thinkingmachines discovers the route. MCP clients can call list_models or gateway_models instead of baking the model ID into their configuration.

For direct provider keys, set TINKER_API_KEY. The gateway preserves the exact upstream model ID, thinkingmachines/Inkling, while exposing a lowercase, stable public route. Tinker's model and pricing table currently documents limited-time 64K upstream rates of $1.87 per million input tokens, $0.374 for cached input, and $4.68 per million sampled tokens; the live app.nz catalog shows the final metered price including platform margin.

Open weights do not mean a small deployment

Apache 2.0 is a strong license, but a 975B model remains serious infrastructure. For many teams the sensible path is hosted inference for product work, Tinker for customization, and downloaded weights for research or a later dedicated deployment. Thinking Machines also previewed Inkling-Small, a 276B-total, 12B-active model, but its weights were not part of this release.

Tinker's OpenAI-compatible inference documentation still describes the service as beta and intended for testing or lower-traffic internal workloads. Thinking Machines says production-grade inference is coming; until that changes, design retries and fallbacks around the route rather than assuming an enterprise SLA.

Inkling's real contribution is the combination: a capable general model, open weights, explicit reasoning control, native multimodality, and a first-party path from inference into post-training. That makes it worth testing as more than another name on a leaderboard.