CanItRun Logocanitrun.

Inkling

Inkling needs roughly 667.5 GB VRAM at Q4_K_M quantization (2186.5 GB at FP16). 1 GPUs we track can run it fully in VRAM at 8k context.

1 GPU runs this natively · 0 with CPU offload

Thinking Machines Lab975B params41B active (MoE)1024k contextApache 2.0 + AUPCommercial use ok

Inkling is a Mixture of Experts (MoE) large language model with 975B total parameters but only 41B active per token developed by Thinking Machines Lab. Released in July 2026, it supports text and vision and audio inputs with a 1M context window, released under the Apache 2.0 + AUP license, allowing commercial use. General-purpose native multimodal model with 256 routed experts, 6 selected plus 2 shared experts, hybrid local/global attention, image input, and 16 kHz audio input up to about 20 minutes. Thinking Machines reports GPQA-Diamond 87.2, SWE-Bench Verified 77.6, and Terminal-Bench 2.1 63.8. BF16 needs at least 2 TB aggregate VRAM; the official NVFP4 checkpoint still needs roughly 600 GB.

To run Inkling locally, you need approximately 667.5 GB of VRAM at Q4_K_M quantization with 8k context. 1 of the GPUs we track can run it fully in VRAM, with a further 0 able to offload to system RAM. At Q4_K_M it requires 667.5 GB — more than any single consumer GPU. A multi-GPU server or 80 GB datacenter GPU is required. At Q8_K_M (1163.3 GB), you get near-FP16 quality while still fitting on large server or multi-GPU setups. FP16 requires 2186.5 GB, limiting it to datacenter-class hardware with 80 GB+ VRAM. As a MoE model, inference speed depends on active parameters (41B) rather than total size, so once it fits in VRAM it runs noticeably faster than dense models of the same parameter count.

Inkling is designed for reasoning and problem-solving. Thanks to its MoE architecture with only 41B active parameters, it delivers strong quality while keeping inference latency manageable for local use.

VRAM at each quantization

Figures below assume 8k context; KV cache grows linearly as context length increases.

QuantWeightsKV cacheTotal
FP323900.0 GB2.21 GB4370.5 GB
BF161950.0 GB2.21 GB2186.5 GB
FP161950.0 GB2.21 GB2186.5 GB
Q8_01036.4 GB2.21 GB1163.3 GB
Q6_K800.5 GB2.21 GB899.0 GB
Q5_K_M694.2 GB2.21 GB780.0 GB
Q4_K_M593.8 GB2.21 GB667.5 GB
Q3_K_M469.0 GB2.21 GB527.7 GB
Q2_K371.5 GB2.21 GB418.5 GB
NVFP4reccuda487.5 GB2.21 GB548.5 GB

KV cache figures assume 8k context at FP16. NVFP4 quantization requires a CUDA-capable GPU. Enable TurboQuant in the calculator to see reduced KV cache estimates.

Benchmarks

GPUs that run Inkling natively (1)

Notes

General-purpose native multimodal model with 256 routed experts, 6 selected plus 2 shared experts, hybrid local/global attention, image input, and 16 kHz audio input up to about 20 minutes. Thinking Machines reports GPQA-Diamond 87.2, SWE-Bench Verified 77.6, and Terminal-Bench 2.1 63.8. BF16 needs at least 2 TB aggregate VRAM; the official NVFP4 checkpoint still needs roughly 600 GB.

Hugging Face ↗Released 2026-07-15

How to run Inkling locally

816244880160320

NVFP4 needs 548.5 GBneeds multiple datacenter-class GPUs (80 GB+ each).

vLLM or SGLang

vllm serve thinkingmachines/Inkling

LM Studio: BF16 requires at least 2 TB aggregate VRAM. Even the official NVFP4 form needs roughly 600 GB, so desktop frontends are useful only when connected to a remote server.

Why this quantization? Thinking Machines explicitly supports BF16, MXFP8, and NVFP4. NVFP4 is the practical self-hosted choice, but its roughly 600 GB deployment footprint still means 4x B300 or 8x H200-class hardware rather than a local workstation.

Who is Inkling for?

Research and platform teams that need a customizable, open multimodal model accepting text, images, and audio with controllable reasoning effort.

Best for

  • Audio and image understanding
  • Custom fine-tuning and post-training
  • Coding and general tool-use agents
  • Million-token research workflows

Not ideal for

  • Desktop deployment
  • Real-time voice output—the model accepts audio but emits text
  • Teams without a large distributed inference stack

Frequently asked questions

What are the VRAM requirements for Inkling?
Inkling requires approximately 667.5 GB of VRAM at Q4_K_M quantization, 1163.3 GB at Q8, and 2186.5 GB at FP16. These numbers assume 8k context window; VRAM scales linearly with context length due to the KV cache.
How many parameters does Inkling have?
Inkling has 975 billion total parameters, but only 41 billion are active per token thanks to its Mixture of Experts (MoE) architecture. This makes inference significantly faster than the total parameter count suggests.
Can Inkling run on a 16 GB GPU?
No. At Q4_K_M, Inkling needs 667.5 GB of VRAM — more than 16 GB. You will need a multi-GPU server.
Can Inkling run on a 24 GB GPU?
No. Even at Q4_K_M, Inkling needs 667.5 GB. Consider a multi-GPU server with 80 GB+ total VRAM.
What is the smallest quantization for Inkling that fits in 24 GB of VRAM?
Inkling cannot fit in 24 GB of VRAM at any standard quantization level. The minimum needed is 418.5 GB at Q2_K.
What GPU do I need to run Inkling locally?
You need a multi-GPU server. At Q4_K_M, Inkling needs 667.5 GB VRAM, more than any single consumer GPU. Consider 2–4× H100 or A100 GPUs.