Model techniques map
ModelsInkling

Thinking Machines Lab · released 2026-07-15

Inkling

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

OpenRouterHugging Face

Curator’s note975B total / 41B active sparse MoE, Apache 2.0: 66-layer decoder-only transformer routing each token to 6 of 256 experts plus 2 shared experts (DeepSeek-V3-inspired), 1M context, pretrained on 45T tokens of text/image/audio/video, native image and audio input, variable thinking effort (evals reported at effort=0.99), shipped in BF16 and NVFP4. The lab's first from-scratch open-weights model and the first US entry in this list. Verified 2026-07-26: no arXiv technical report exists, so the first-party model card is the closest architecture document; thinkingmachines.ai/inkling/ is a ~800-char landing page and is not listed. Inkling-Small (276B total / 12B active) was previewed in the launch post but has no weights yet — see `watch`.

Against the consensus recipe

Its documents state 3 of the 15 methods the field agrees on.

The recipe from the overview: the methods the most labs adopt, per stage. A missing one is something the 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 8 of the 19 architecture features checked — 6 of them are not stated in its documents.

Documents 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-09-25.

FeatureCodeIts documentsEvidence
Grouped-query attention in its code used

Both the global-attention layers (64 query heads / 8 KV heads) and the sliding-window layers (64 query heads / 16 KV heads) use grouped-query attention via the qkvr projection sized by num_kv_heads.

text_config.num_attention_heads = 64text_config.num_key_value_heads = 8text_config.swa_num_key_value_heads = 16
self.num_kv_heads = max(1, self.num_total_kv_heads // tp_size)
attention.py · L103
Multi-head latent attention not in its codenot stated

There is no low-rank KV latent projection (no kv_lora_rank/q_lora_rank in config, and attention.py projects K/V directly with per-head width, not a shared latent).

Sliding-window attention code only in its codenot stated

Layers marked local (per local_layer_ids) use a sliding window of size sliding_window_size (512) via the FA4 window_size tuple.

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 code only in its codenot stated

local_layer_ids selects most layers (0,1,2,3,4,6,...) as sliding-window while the remaining layers (5,11,17,23,29,35,41,47,53,59,65) attend globally, an interleaved fixed pattern.

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 config or code) is present; attention is dense within the (possibly windowed) causal region.

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

All token-mixing layers are softmax attention (global or sliding-window) plus short convolutions on residual streams; there is no linear-attention/SSM mixer layer type.

@property
    def full_attention_layer_ids(self) -> list[int]:
        return list(range(self.num_hidden_layers))
configs.py · L173–175
Gated DeltaNet layers not in its codenot stated

No gated delta-rule recurrent mixer is implemented; the short convolution (sconv) is a plain depthwise causal conv1d with residual add, not a delta-rule/decay-gated state update.

Mamba-2 layers not in its codenot stated

No Mamba-2 SSD selective state-space blocks are implemented; mamba2_cache_params exists only as a stub returning a conv-only cache shape with temporal size (0,0,0), and there is no mamba_num_heads or ssm_state_size in config.

shape = TMLConvStateShape(
            conv=[
                (conv_len, full_kv_conv_dim),
                (conv_len, full_kv_conv_dim),
                (conv_len, local_kv_conv_dim),
                (conv_len, local_kv_conv_dim),
                (conv_len, stream_dim),
                (conv_len, stream_dim),
            ],
            temporal=(0, 0, 0),
        )
configs.py · L203–213
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 kernel; the only 'sink' concept here is the MoE shared-expert sink, unrelated to attention.

Gated attention output not in its codenot stated

The attention output goes directly from the FA4 kernel to the output projection wo_ud with no sigmoid gating multiplication applied to it.

flat = attn_output.view(num_tokens, -1)
        output, _ = self.wo_ud(flat)
        return output
attention.py · L269–271
QK normalization code unclearnot stated

Queries and keys are each RMS-normalized per head (q_norm, k_norm) before the attention dot product.

Partial RoPE not in its codenot stated

No RoPE is applied at all in this attention implementation (position signal comes from a relative-bias projection r_out/rel_logits, not rotary embeddings), so there is no partial-RoPE mechanism.

self.rel_logits_proj = RelLogitsProj(self.d_rel, self.rel_extent)
attention.py · L133
YaRN RoPE scaling not in its codenot stated

No rope_scaling config key or YaRN-related code exists anywhere in this model; positional signal uses a learned relative-bias projection instead of RoPE.

Layers without positional encoding (NoPE) code unclearnot stated

The model has no RoPE at all (uses relative bias instead), so the NoPE-layers concept (some attention layers with RoPE, others without) does not clearly apply and cannot be resolved from the given code.

Mixture of experts in its code core

Feed-forward layers past dense_mlp_idx route each token to a top-k subset of 256 routed experts chosen by a sigmoid gate.

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,
            intermediate_size=config.intermediate_size,
moe.py · L442–446
Shared expert code only in its codenot stated

MoE layers include 2 shared 'sink' experts that every token passes through, implemented in InklingSinkExperts and added to the routed output.

text_config.n_shared_experts = 2text_config.shared_expert_sink = true
self.sink_experts = sink_experts_cls(
            n_experts=n_shared,
            d_model=config.hidden_size,
            d_mlp=config.intermediate_size,
            prefix=f"{prefix}.shared_experts",
        )
moe.py · L466–471
Auxiliary-loss-free load balancing (selection bias) code only in its codenot stated

The router adds a per-expert selection bias (use_gate_bias / self.bias) to the sigmoid scores used only for top-k selection, not for output weighting, matching aux-loss-free bias-based 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 MTP next-token prediction depth layers, and a dedicated InklingMTP module builds and loads them as separate 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 · L118–120
SwiGLU feed-forward code only in its codenot stated

Both dense and shared-expert MLPs compute SiLU(gate(x)) * up(x) via silu_and_mul_triton / F.silu-based gating, consistent with hidden_act=silu.

gate_up, _ = self.gate_up_proj(x)
        x = silu_and_mul_triton(gate_up)
        x, _ = self.down_proj(x)
mlp.py · L57–59

model architecture 20

filed at the root 2

Regular Transformer decoder core
Short convolutions in attention and residual branches used

token mixer 4

Kernel-4 convolutional layers in decoder blocks used

softmax attention 2

sliding window attention 1

512-token Sliding Window Attention used

grouped-query attention 1

Grouped-query attention used

hybrid layer stacking 1

Hybrid Attention core

channel mixer 6

positional encoding 2

Relative attention core
Learned input-dependent relative position bias used

normalization & residual 1

Post-Embedding RMSNorm used

multimodal architecture 5

Discrete token encoding for audio core
Hierarchical patch encoder core
Joint multimodal decoding in a shared hidden space core
Native multimodal encoding core
Encoder-free multimodal architecture used

optimization 4

optimizer 1

Hybrid optimization with Muon and Adam used

training precision 1

NVFP4 optional

training stability 1

Weight decay coupled to learning-rate squared used

training parallelism 1

SConv-Aware Tensor-Parallel Sharding used

data curation 4

filed at the root 2

Data curation used
Training data deduplication and filtering used

synthetic data 2

Synthetic data generation and augmentation used
Tool-set and schema randomization used

post-training 10

filed at the root 1

Post-training on diverse domains used

supervised fine-tuning 3

LoRA fine-tuning core
SFT bootstrapping with synthetic data used
Safety training to an internal specification used

reinforcement learning algorithm 3

Large-Scale Reinforcement Learning used
Reinforcement Learning for Calibration with Proper Scoring Rules used
RL with Rubric and Claims Graders used

reward modelling 1

Abstention-aware reward for factual QA used

policy distillation 1

Distillation for Post-Training Data Generation used

rollout & RL infrastructure 1

Large-scale asynchronous RL core

inference & serving 9

decoding strategy 1

Multi-Token Prediction core

reasoning control 2

Configurable reasoning effort used
Controllable thinking effort via system message and per-token cost used

KV cache management 1

Prompt caching used

inference quantization 1

NVFP4 quantization default

serving parallelism 1

Fused reduce-scatter/all-gather collectives used

inference kernel 1

FA4 sheared-bias attention kernel used

agentic scaffolding 2

Python tool used
Claude Code skills for Tinker optional

software implementation 1

infrastructure service 1

Automatic provider failover used

evaluation 7

filed at the root 2

Refusal-suppressed variants for capability estimation used
Documenting evaluation configuration used

evaluation harness 2

Benchmark evaluation framework used
Inline training evaluators optional

human & real-world evaluation 3

Multi-turn open-ended external red-teaming used
Dangerous-capability uplift assessment used
Pre-release safety evaluation used

unfiled 18

Short convolution (sconv) modules core
OpenAI-compatible API used
benchmarking against public frontier models used
Calibrated answers with uncertainty flagging used
Fine-tuning via Tinker platform used
Open-weights release under Apache-2.0 license used
Pre-commit hooks with ruff used
Pre-training from scratch used
provider routing modes used
Training to resist censorship used
Fine-tuning on Tinker platform optional
Interaction models (AI that listens, speaks, and interrupts) evaluated
Application-layer safeguards (content filtering, rate limiting, monitoring) mentioned
Defense-in-depth for safety mentioned
defense-in-depth with layered input/output classifiers mentioned
Human oversight and review for high-stakes model outputs mentioned
Input/output classification with moderation tools mentioned
Input/output moderation classifiers layered around the model (defense-in-depth) mentioned

Further reading

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

Sources

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

DocumentKindPublisherStatus
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