Open Models Almanac
ModelsInkling

Thinking Machines Lab

Inkling

What Inkling’s own documents say it is built from — every method with the sentence that describes it.

Parameters
975B / 41B active
Context
1M
Attention
sliding/global hybrid66 layers, mostly sliding-window (512) with every 6th layer global GQA, QK-norm
Experts
256 routed + 2 shared, top-6
Input
text, image, audio, video
Licence
Apache 2.0
Released
2026-07-15

Against the consensus recipe

Its documents state 6 of the 18 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something its documents do not say, not something the model lacks.
  1. Data curation

  2. Training objective

  3. Model architecture

  4. Optimization

  5. Post-training

  6. Inference & serving

Checked in its code

Its code shows 9 of the 19 architecture features checked — 4 of them are not stated in its documents.

Sources say what a lab chose to describe; the modeling code says what the checkpoint runs. Each feature below was put to a code verifier, and only the config values and source lines it cited that were found in the files are shown, linked to the line.

Read from vLLM (__init__.py, model.py, configs.py, attention.py, layernorm.py, fa4_rel_attention.py, qkvr_prep.py, sconv_swa_attn.py, sconv.py, short_conv.py, logits_processor.py, mlp.py, moe.py, lamport.py, norm.py, mtp.py) and config.json at revision 828496eeae, by anthropic/claude-sonnet-5 on 2026-11-07.

FeatureCodeIts documentsVerdict
Grouped-query attention in its codeadopted

Both full and local attention layers project queries with more heads than K/V heads (64 query heads vs 8 KV heads full, 64 vs 16 local)…

show evidence

Both full and local attention layers project queries with more heads than K/V heads (64 query heads vs 8 KV heads full, 64 vs 16 local), implementing grouped-query attention.

text_config.num_attention_heads = 64text_config.num_key_value_heads = 8
self.num_total_heads = num_heads
        self.num_total_kv_heads = num_kv_heads
        assert self.num_total_heads % tp_size == 0
        self.num_heads = self.num_total_heads // tp_size
attention.py · L95–98
Multi-head latent attention not in its codenot stated

No kv_lora_rank/q_lora_rank-style latent down/up projection exists; attention here is a GQA relative-position design with separate…

show the whole verdict

No kv_lora_rank/q_lora_rank-style latent down/up projection exists; attention here is a GQA relative-position design with separate per-head K/V projections, not MLA.

Sliding-window attention in its codeadopted

Layers marked local (local_layer_ids) use a sliding window of size sliding_window_size=512 implemented via the FA4 window_size and…

show evidence

Layers marked local (local_layer_ids) use a sliding window of size sliding_window_size=512 implemented via the FA4 window_size and SlidingWindowSpec KV cache.

text_config.sliding_window_size = 512text_config.local_layer_ids = [0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22, 24, 2…
self.window_size: tuple[int, int] = (
            (local_extent - 1, 0) if is_local else (-1, -1)
        )
attention.py · L150–152
Interleaved sliding-window and global attention in its codeadopted

local_layer_ids selects most layers as sliding-window (swa_*) while layers not listed (e.g. 5, 11, 17...) use full attention, giving a…

show evidence

local_layer_ids selects most layers as sliding-window (swa_*) while layers not listed (e.g. 5, 11, 17...) use full attention, giving a fixed interleaving of local and global attention layers.

text_config.local_layer_ids = [0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 18, 19, 20, 21, 22, 24, 2…text_config.num_hidden_layers = 66
self.attn = InklingAttention(
            config,
            num_heads=(
                config.swa_num_attention_heads
                if is_local
                else config.num_attention_heads
            ),
model.py · L152–158
Indexer-selected sparse attention (DeepSeek Sparse Attention) not in its codenot stated

No indexer-based top-k token selection mechanism (no index_topk/index_n_heads/index_head_dim) is present anywhere in the attention code.

Linear-attention or state-space layers alongside full attention not in its codenot stated

All token-mixing layers use the same relative-position softmax attention (full or sliding-window variants); there are no linear-attention…

show the whole verdict

All token-mixing layers use the same relative-position softmax attention (full or sliding-window variants); there are no linear-attention or SSM mixer layers in this model.

Gated DeltaNet layers not in its codenot stated

No gated delta-rule recurrent mixer exists; the only non-attention mixing component is a short depthwise convolution (sconv), not a…

show the whole verdict

No gated delta-rule recurrent mixer exists; the only non-attention mixing component is a short depthwise convolution (sconv), not a delta-rule gated state.

Mamba-2 layers not in its codenot stated

There are no Mamba-2 SSD blocks; config only carries short-conv (sconv) parameters, not SSM state sizes or per-head decay.

Learnable attention sink not in its codenot stated

No learned per-head sink logit is added to the attention softmax denominator anywhere in the attention or kernel code.

Gated attention output not in its codenot stated

The attention output is passed directly to the output projection (wo_ud) with no sigmoid gate multiplication applied to it.

show evidence
flat = attn_output.view(num_tokens, -1)
        output, _ = self.wo_ud(flat)
        return output
attention.py · L269–271
QK normalization code only in its codenot stated

Queries and keys are each passed through per-head RMSNorm (q_norm/k_norm) before the attention dot product.

show evidence
self.q_norm = InklingRMSNorm(head_dim, eps=config.rms_norm_eps)
        self.k_norm = InklingRMSNorm(head_dim, eps=config.rms_norm_eps)
attention.py · L134–135
Partial RoPE not in its codenot stated

The model uses a learned relative-position bias (d_rel/rel_extent projected logits added to attention scores) rather than rotary position…

show the whole verdict

The model uses a learned relative-position bias (d_rel/rel_extent projected logits added to attention scores) rather than rotary position embeddings at all, so there is no partial-RoPE mechanism; no rotary application appears anywhere in the attention code.

YaRN RoPE scaling not in its codenot stated

There is no rope_scaling key in the config and no RoPE scaling code of any kind; positions are encoded via a learned relative-bias…

show the whole verdict

There is no rope_scaling key in the config and no RoPE scaling code of any kind; positions are encoded via a learned relative-bias projection, not rotary embeddings.

Layers without positional encoding (NoPE) code unclearnot stated

The model has no RoPE at all (it uses a learned relative-position bias instead), so there is no distinction between layers with and…

show the whole verdict

The model has no RoPE at all (it uses a learned relative-position bias instead), so there is no distinction between layers with and without positional encoding visible in this code; this check does not clearly apply and the files don't show any per-layer toggle for positional encoding.

Mixture of experts in its codeadopted

Feed-forward layers beyond dense_mlp_idx route tokens to a learned sigmoid gate selecting top-6 of 256 routed experts via…

show evidence

Feed-forward layers beyond dense_mlp_idx route tokens to a learned sigmoid gate selecting top-6 of 256 routed experts via InklingMoE/FusedMoE.

text_config.n_routed_experts = 256text_config.num_experts_per_tok = 6
self.experts = FusedMoEFactory(
            num_experts=num_experts,
            top_k=config.num_experts_per_tok,
            hidden_size=config.hidden_size,
moe.py · L442–445
Shared expert in its codeadopted

MoE layers include 2 shared 'sink' experts that every token passes through in addition to the routed experts, enabled by…

show evidence

MoE layers include 2 shared 'sink' experts that every token passes through in addition to the routed experts, enabled by n_shared_experts=2 and shared_expert_sink=true.

text_config.n_shared_experts = 2text_config.shared_expert_sink = true
assert config.n_shared_experts > 0 and config.shared_expert_sink
        assert config.inference_moe_w13_interleaved
        n_routed = config.n_routed_experts
        n_shared = config.n_shared_experts
moe.py · L421–424
Auxiliary-loss-free load balancing (selection bias) code only in its codenot stated

The gate adds a learned per-expert bias to the sigmoid routing scores used only for top-k selection, controlled by use_gate_bias=true…

show evidence

The gate adds a learned per-expert bias to the sigmoid routing scores used only for top-k selection, controlled by use_gate_bias=true (DeepSeek-style selection-bias load balancing).

text_config.use_gate_bias = true
sel = tl.where(mask_r, tl.sigmoid(logits), float("-inf"))
    if HAS_BIAS:
        bias = tl.load(bias_ptr + offs, mask=mask_r, other=0.0).to(tl.float32)
        sel = tl.where(mask_r, sel + bias, float("-inf"))
moe.py · L110–113
Multi-token prediction layers code only in its codenot stated

The config declares 8 next-next-token prediction (MTP) depth layers, and the model ships an InklingMTP module that builds and runs these…

show evidence

The config declares 8 next-next-token prediction (MTP) depth layers, and the model ships an InklingMTP module that builds and runs these draft transformer blocks.

mtp_config.num_nextn_predict_layers = 8
n_predict = config.num_nextn_predict_layers
        num_spec = vllm_config.speculative_config.num_speculative_tokens
        self.num_mtp_layers = _select_mtp_depth_count(n_predict, num_spec)
mtp.py · L127–129
SwiGLU feed-forward code only in its codenot stated

Dense and shared-expert MLPs compute SiLU(gate(x)) * up(x) (silu_and_mul / torch.nn.functional.silu gating), matching SwiGLU, consistent…

show evidence

Dense and shared-expert MLPs compute SiLU(gate(x)) * up(x) (silu_and_mul / torch.nn.functional.silu gating), matching SwiGLU, consistent with hidden_act='silu' default (not overridden to gelu in this config).

gate_up, _ = self.gate_up_proj(x)
        x = silu_and_mul_triton(gate_up)
        x, _ = self.down_proj(x)
mlp.py · L57–59
hidden_states = torch.nn.functional.silu(gate) * up
moe.py · L403

filed at the root 2

Regular Transformer decoder core

“Inkling uses a regular Transformer decoder rather than the hybrid Mamba-Transformer approach used by Nemotron 3 Ultra.”

Short convolutions in attention and residual branches used

“We also apply short convolutions at two points — after the key and value projections in each attention layer, and on the attention and MLP…”

token mixer 4

Kernel-4 convolutions in decoder blocks used

“Each decoder layer applies short kernel-4 convolutions after the key and value projections and on the attention and MLP branch outputs.”

softmax attention 2

sliding window attention 1

Sliding Window Attention used

“Of the 66 decoder layers, 55 use local attention with a small 512-token window.”

grouped-query attention 1

Grouped-query attention used

“the use of conventional GQA rather than MLA or a recurrent hybrid stack suggest that raw decoding speed may not be Inkling’s main advantage”

hybrid layer stacking 1

Hybrid Sliding-Window and Global Attention core

“Attention is a hybrid of local and global layers.”

channel mixer 5

mixture of experts 5

Mixture of experts core

“A 66-layer decoder-only transformer with a sparse Mixture-of-Experts (MoE) feed-forward backbone”

Sigmoid router with auxiliary-loss-free load balancing used

“Inkling uses a sigmoid-based router with an auxiliary-loss-free load-balancing bias.”

expert routing 1

Top-k expert routing core

“each token is routed to 6 of 256 experts, plus 2 shared experts active on every token”

shared experts 2

Shared expert core

“each token is routed to 6 of 256 experts, plus 2 shared experts active on every token”

MoE with expert sinks core

“The 2 shared experts act as expert sinks: they participate in routing-score computation but are excluded from the top-6 candidate pool.”

positional encoding 2

Learned relative attention core

“Inkling replaces RoPE with relative attention: a learned relative-position term added to the pre-softmax logits.”

Learned input-dependent relative-position bias used

“In the 11 global layers, the released implementation applies the learned bias only over the preceding 1,024 tokens.”

normalization & residual 1

Post-embedding RMSNorm used

“An additional RMSNorm directly after the token embedding layer.”

multimodal architecture 5

Native multimodal architecture core

“The model is natively multimodal — images and video are encoded via a hierarchical patch encoder, and audio via discrete token encoding…”

Discrete audio token encoding core

“audio via discrete token encoding”

Hierarchical patch encoder core

“images and video are encoded via a hierarchical patch encoder”

Joint multimodal decoding in a shared hidden space core

“with all modalities projected into a shared hidden space and processed jointly by the decoder”

Encoder-free multimodal architecture used

“We opted for an encoder-free architecture for audio and vision inputs, consistent with the interaction model design.”

optimizer 1

Hybrid Muon and Adam optimization used

“We trained Inkling with a hybrid optimization strategy — Muon for large matrix weights, Adam for other parameters — and hyperparameter…”

training precision 1

NVFP4 optional

“The NVFP4 checkpoint offers a quantized alternative that reduces the aggregated VRAM requirement to at least 600 GB.”

training stability 1

Weight decay coupled to learning rate squared used

“We coupled the weight decay strength to the square of the learning rate, which we found kept the overall size of the model weights stable…”

training parallelism 1

Sconv-aware tensor-parallel sharding used

“sconv-aware TP sharding (each rank stores only its channel shard of the sconv cache)”

filed at the root 2

Data cleaning, processing, and modification used

“The training data curation process includes cleaning, processing, and modifying datasets.”

Deduplication and filtering used

“may include deduplication and filtering to remove junk or other low-quality data, or to advance safety or other objectives”

synthetic data 2

Synthetic data generation used

“synthetically generated or augmented”

Randomized tool set and schema during training used

“we randomized the tool set and schema during training to reduce sensitivity to any particular one.”

filed at the root 1

Post-training on diverse domains used

“We post-trained Inkling on a broad distribution of math, agentic code & tool use, audio, image, chat, and safety domains.”

supervised fine-tuning 3

Low-Rank Adaptation core

“create_lora_training_client”

SFT bootstrapping with synthetic data used

“To bootstrap post-training, we ran an initial SFT on synthetic data generated by open-weights models including Kimi K2.5.”

Safety training to an internal specification used

“We trained Inkling to an internal spec of safe model behavior across all modalities.”

reinforcement learning algorithm 3

Reinforcement learning used

“before large-scale reinforcement learning took over”

RL for calibration with proper scoring rules used

“We trained for calibration with RL against proper scoring rules on a large corpus of resolved real-world questions.”

RL with rubric and claims graders used

“We did RL with two automated graders: a rubric grader and claims grader.”

reward modelling 1

Abstention-aware factual QA reward used

“The largest is short-form factual QA with abstention-aware rewards: answering only pays off when the model is likely to be right, so the…”

policy distillation 1

Distillation-Based Post-Training Data Generation used

“it used other open-weight models — including Moonshot AI’s Kimi K2.5 — to help generate some of its early post-training data”

rollout & RL infrastructure 1

Asynchronous reinforcement learning core

“We relied on large-scale asynchronous RL to shape model behavior and improve its reasoning and overall performance.”

decoding strategy 1

Multi-Token Prediction core

“8 chained MTP heads (single-layer full-attention transformers with a dense MLP, all BF16) enable up to 9 tokens per forward step for…”

reasoning control 2

Thinking mode used

“lets users dial 'thinking effort' up or down when they want to trade for speed”

Continuously controllable reasoning effort used

“We specified the model’s effort level on different samples by changing the system message and adjusting the per-token cost. This caused…”

KV cache management 1

Prompt caching used

“The chart below shows the average price customers are actually paying after prompt caching.”

inference quantization 1

Mixed-precision NVFP4 routed-expert quantization default

“Only the routed experts are quantized to NVFP4; shared experts and the qkvr linears remain BF16.”

serving parallelism 1

Fused reduce-scatter/all-gather collectives used

“low-latency fused reduce-scatter / all-gather collectives built on FlashInfer's Lamport-protocol all-reduce”

inference kernel 1

FA4 sheared-bias attention kernel used

“the FA4 sheared-bias attention kernel for relative attention”

agentic scaffolding 2

Python tool for visual tasks used

“During inference, Inkling can also leverage a Python tool to support image understanding through operations such as zooming and cropping…”

Claude Code skills for Tinker optional

“Tinker Cookbook ships with Claude Code skills that teach Claude how to use the Tinker API.”

infrastructure service 1

Automatic provider failover and retry used

“OpenRouter monitors every provider continuously and automatically retries on the next-best provider when one returns an error.”

filed at the root 2

Refusal-suppressed capability evaluation used

“refusal-suppressed variants intended to estimate latent capability with safeguards removed”

Evaluation-setting documentation used

“We document our exact settings alongside all reported scores.”

evaluation harness 2

Tinker Cookbook benchmark framework used

“Tinker Cookbook includes a benchmark framework for evaluating trained models”

BenchmarkEvaluator optional

“Benchmarks can also serve as inline training evaluators via `BenchmarkEvaluator`.”

human & real-world evaluation 3

Multi-turn open-ended external red-teaming used

“including through multi-turn, open-ended external red-teaming designed to surface issues that only emerge over longer conversations”

Dangerous-capability uplift assessment used

“For CBRN and cyber, we assessed knowledge and procedural uplift through internal evaluations, external testing, and refusal-suppressed…”

Pre-release safety evaluation used

“We conducted safety evaluations ahead of release, spanning both everyday human-AI interaction and dangerous-capability testing.”

unfiled 18

Short convolution (sconv) modules core

“Each layer applies four window-4 sconv modules (on attention keys, values, output, and MoE output).”

OpenAI-compatible API used

“OpenRouter's API is OpenAI-compatible — most SDKs work by just swapping the base URL.”

benchmarking against public frontier models used

“benchmarked against public frontier models”

Calibrated answers with uncertainty flagging used

“Inkling is designed to give calibrated answers, including flagging uncertainty rather than guessing”

Fine-tuning via Tinker platform used

“something for organizations to fine-tune themselves through Tinker”

Open-weights release under Apache-2.0 license used

“It's Apache-2.0 licensed, and looks competitive with the open weight models coming out of China”

Pre-commit hooks with ruff used

“registers pre-commit hooks that run `ruff` formatting and linting on every commit. CI enforces these checks on all pull requests.”

Pre-training from scratch used

“pre-trained Inkling from scratch”

provider routing modes used

“OpenRouter routes your request to one of them based on the routing mode you pick — Balanced (price + speed), Nitro (fastest), or Exacto…”

Training to resist censorship used

“Finally, we trained Inkling to answer directly on topics that may be subject to censorship.”

Fine-tuning on Tinker platform optional

“a combination of qualities makes it a good open-weights base for customization: multimodal capabilities, efficient thinking, and…”

7 more mentioned or evaluated
Interaction models (AI that listens, speaks, and interrupts) evaluated

“AI designed to listen and speak (and even interrupt) instead of stop and wait as with typical chatbots”

Application-layer safeguards (content filtering, rate limiting, monitoring) mentioned

“Implement additional safeguards — such as content filtering, rate limiting, and monitoring — at the application layer”

Defense-in-depth for safety mentioned

“are best addressed with defense-in-depth rather than relying on the model’s refusals alone”

defense-in-depth with layered input/output classifiers mentioned

“are best addressed with defense-in-depth rather than relying on the model's refusals alone. Common downstream moderation tools, such as…”

Human oversight and review for high-stakes model outputs mentioned

“apply appropriate human oversight and review for outputs used in high-stakes or safety-critical contexts”

Input/output classification with moderation tools mentioned

“Common downstream moderation tools, such as Llama Guard, are compatible with Inkling and can be layered around the model to catch…”

Input/output moderation classifiers layered around the model (defense-in-depth) mentioned

“Common downstream moderation tools, such as Llama Guard, are compatible with Inkling and can be layered around the model”

Further reading

Picked by hand, not extracted: where to read more, not evidence for anything on this page.

Sources

The curated source list for this model. "not fetched" means the URL is recorded but its text was not read in the current run.

SourceKindPublisherStatus
thinkingmachines.ai/news/introducing-inklingofficial blogThinking Machines Labread
thinkingmachines.ai/model-card/inklingmodel cardThinking Machines Labread
huggingface.co/thinkingmachines/Inklingmodel cardThinking Machines Labread
huggingface.co/thinkingmachines/Inkling-NVFP4model cardThinking Machines Labread
github.com/thinking-machines-lab/tinker-cookbookcode repoThinking Machines Labread
recipes.vllm.ai/thinkingmachines/Inklingvendor docsvLLMread
openrouter.ai/thinkingmachines/inklingvendor docsOpenRouterread
sebastianraschka.com/blog/2026/inkling-architecture-benchmark-notes.htmlthird party analysisSebastian Raschkaread
artificialanalysis.ai/articles/thinking-machines-has-released-inkling-t…third party analysisArtificial Analysisread
simonwillison.net/2026/Jul/16/inklingthird party analysisSimon Willisonread
techcrunch.com/2026/07/15/thinking-machines-amps-up-its-bet-against-one…newsTechCrunchread
↑