Inkling is here: what Thinking Machines Lab’s first open model offers

A hands-on look at the 975B-parameter Inkling model, and how to wire it into OpenCode before it lands in the default picker.

Try it on OpenCode today.

Science fiction has long warned us about thinking machines. Frank Herbert’s Dune imagined the Butlerian Jihad, a revolt against AI that could think for itself. A few decades later, a startup literally named Thinking Machines Lab releases a model called Inkling and asks us to do the opposite: not fear it, but fine-tune it. That transition from using frozen black boxes to customising open weights, may very well be the whole point of the company Mira Murati started after leaving OpenAI.

On 15 July 2026, Thinking Machines Lab announced Inkling, its first open-weights model. Inkling is a 975-billion-parameter mixture-of-experts transformer, with 41 billion active parameters and a context window of up to 1 million tokens. It reasons natively over text, images, and audio. The full weights are on Hugging Face. It’s being built as the best base for people who want to make a model their own, rather than marketed as the strongest model on every benchmark.

The lab behind the model

Mira Murati left OpenAI in late 2024 and came out of stealth on 18 February 2025 with a very clear mission: to build AI that extends human will and judgment. The New York Times reported that Thinking Machines Lab wants systems that are “more widely understood, customizable and generally capable.” In plain terms, that means more transparency, more adaptability, and less one-size-fits-all.

“Our mission is to build AI that extends human will and judgment.” (Thinking Machines Lab)

The team is stacked with former OpenAI talent. John Schulman, an OpenAI co-founder, is chief scientist. Barret Zoph, who led post-training at OpenAI, is CTO. Lilian Weng, a former OpenAI VP who led safety and robotics work, is a founding member. The Reuters funding story is as dramatic as the roster: a $2 billion seed round led by Andreessen Horowitz valued the company at $12 billion before it had shipped a product.

For Murati, the move carries some history. She was at OpenAI in 2019 when the lab withheld the full version of GPT-2 over misuse fears. Now her own lab is releasing a model with the full weights available for download.

What Inkling is

Inkling is a 66-layer, sparse mixture-of-experts transformer. Rather than activate all 975 billion parameters for every token, it routes each token through six of 256 specialised experts plus two shared experts. Only 41 billion parameters are active at once. That sparse design is how the model can be huge and still practical to serve.

The deets, drawn from the Baseten launch post, are not that hard to remember:

• 975B total parameters across a sparse MoE architecture.
• 41B active parameters per forward pass.
• 1 million token context window, enough for very long documents or codebases.
• 45 trillion pre-training tokens spanning text, images, audio, and video.
• Native multimodality: text, image, and audio inputs; text outputs.

Baseten also notes the hardware reality of it all: the full BF16 checkpoint needs at least 2 TB of aggregate GPU memory. The quantised NVFP4 checkpoint brings that down to at least 600 GB.

It’s still a stark reminder that open weights do give you control, but control still costs money.

Why open weights?

Open weights mean the model file is yours. You can inspect it, modify it, fine-tune it on private data, and run it wherever you have compute. That’s a different proposition from an API-only model, where the weights live inside someone else’s datacentre and your prompts leave your control.

Thinking Machines Lab is doubling down on this. Inkling is available for fine-tuning on Tinker, the lab’s customisation platform.

The Tinker platform dashboard.

The official announcement even demoed Inkling writing, running, and evaluating a fine-tuning job on itself inside OpenCode, a neat loop that ends with the model loading its own updated weights. The point isn’t the lipogram gimmick. The point is that the tooling is built for iterative work.

For developers, the practical benefits are straightforward:

• Domain adaptation on private data without sending it to a third party.
• Cost control by choosing your own inference stack and provider.
• Latency trade-offs by picking the quantised checkpoint or a smaller variant.
• Reproducibility because the weights are fixed artifacts you can version.

This is the lab’s bet: the future of useful AI isn’t one universally best model, but millions of specialised models fine-tuned on real work.

Where to run Inkling today

Day-zero support is spread across the major inference platforms. You don’t have to download 975 billion parameters to start experimenting.

• **Hugging Face** hosts the full weights and supports inference through Hugging Face Inference Providers. The easiest direct path is the any-to-any pipeline in transformers with model_id = "thinkingmachines/Inkling".
• Together AI offers serverless and dedicated endpoints with a 1 million token context window and an OpenAI-compatible API.
• Baseten provides Model APIs and Dedicated Inference, with vLLM and the Baseten Inference Stack handling scaling and cross-cloud placement.
• Databricks exposes Inkling through Unity AI Gateway, which means it plugs into existing governance, security, and audit policies and connects to coding agents such as OpenCode or Cursor.
• Tinker is the lab’s own fine-tuning and deployment platform, with an OpenAI-compatible endpoint for checkpoints.

That’s a lot of on-ramps, and each provider treats Inkling as a first-class endpoint.

Adding Inkling to OpenCode

OpenCode is a terminal-first coding agent that pulls its model catalogue from models.dev. When a provider launches a new model, two things have to happen before it appears in OpenCode’s picker: someone adds the model to the models.dev registry, and OpenCode picks up the updated registry.

Until then, the model is “hidden”, but the provider’s API already serves it. You just have to tell OpenCode it exists.

This is where my short OpenCode guide becomes handy. If the provider is already built into OpenCode, you can extend it in opencode.json without creating a full provider block. No npm, no baseURL, no new credentials plumbing. You add the model ID and a friendly name.

It’s only a few lines.

Baseten is already a supported OpenCode provider, and thinkingmachines/inkling is already available on it. If it isn't showing in your picker yet (which is the case at the time of writing), adding it's a mere three-line change. Open your opencode.json and add:

{
  "$schema": "https://opencode.ai/config.json",
  "baseten": {
    "models": {
      "thinkingmachines/inkling": {
        "name": "Inkling (TML)"
      }
    }
  }
}

Then authenticate with your Baseten API key, either through /connect or by setting BASETEN_API_KEY. Baseten also gives new signups $20 in free credits, so you can try the model before touching a credit card. Once connected, select baseten/thinkingmachines/inkling from the model picker.

The same pattern works for any provider that’s already in OpenCode. The only tedious part is getting the exact model ID the provider’s API expects. For Baseten, it’s thinkingmachines/inkling. For Together AI, it might look like accounts/togetherai/models/... or the raw model slug; check the provider's docs if the first guess fails.

If you’re using a standard model path (thinkingmachines/Inkling) or fine-tuned checkpoint from Tinker, the story is slightly different. Tinker isn’t a built-in OpenCode provider, so you need the full provider block with npm, baseURL, and the model/checkpoint path:

Did I forget to mention that you’ll need to top up at least $10 as well before you can even use it?

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

Inference served directly by Thinking Machines.

And don’t forget that it’s multimodal (i.e. can analyse images)

Spike result

I re-ran the spike with Baseten. opencode models baseten already lists baseten/thinkingmachines/inkling, so the model is already in the picker. I then ran:

opencode run -m baseten/thinkingmachines/inkling "Implement Hello World in Python"

and got a correct Python one-liner back:

If the model isn’t in your picker yet, the three-line baseten block above adds it. Then authenticate with /connect or BASETEN_API_KEY, select baseten/thinkingmachines/inkling, and you're talking to Inkling.

Blazing fast on Baseten.

What to expect when you try it

Inkling is a research-grade model, but the developer experience is intentionally ordinary. You send text, images, or audio, and you get text back. The difference is scale and control.

A few things to keep in mind:

• You probably don’t want to self-host the full BF16 checkpoint unless you have a cluster. 2 TB of aggregate GPU memory is a serious bar. The NVFP4 quantised version at 600 GB is more feasible, but still not a single-GPU affair.
• Cloud inference is the easiest starting point. Hugging Face Inference Providers, Together AI, and Baseten all expose standard OpenAI-compatible endpoints, so switching from another model is mostly a config change.
• Multimodal inputs are unified. You don’t need separate vision and audio pipelines. One call can include text, an image, and audio together.
• Controllable thinking effort is a real feature. You can ask for more or less reasoning depending on the task, which matters when you’re paying per token.
• Fine-tuning is the long-term promise. Tinker and the open weights make domain adaptation the headline use case, not chat.

The official model card makes a point: Inkling isn’t the strongest model available today. It’s a broad, balanced foundation model built to be customised.

That’s a different kind of ambition.

The bottom line

An inkling is the first faint awareness of something before it becomes a full vision. The name fits. Thinking Machines Lab isn’t claiming to have shipped the final, godlike AI. It has shipped a very large, very open, very customisable starting point, and it wants developers to take it from there.

The day-zero support from Hugging Face, Together AI, Baseten, and Databricks means you can start experimenting without building your own datacentre. The OpenCode integration means you can route a terminal coding agent through it today, even before the model picker catches up. And the open weights mean that, if you have the compute and the data, you can turn Inkling into something no one else has.

That’s the bet. Not that one lab will make the best model. But that thousands of developers, each with their own data and their own needs, will make better models together.

You can do more with this article

• Read the Inkling model card for benchmarks and the self-fine-tuning demo.
• Try the Hugging Face weights to run thinkingmachines/Inkling directly.
• Follow the OpenCode provider docs for the general pattern beyond Hugging Face.
• Set up a Tinker fine-tuned checkpoint if you want to go beyond the base model.
• Compare cloud providers on the Together AI, Baseten, and Databricks docs pages.