Skip to content
NetProjects
Menu

Insights

Thinking Machines' Inkling 2 Mini on a Mac: four MLX builds with DSpark and tool calls

NetProjects

Inkling 2 Mini is a general-purpose model from Thinking Machines Lab, released on 20 November 2026 under the Apache-2.0 licence. It takes text and images and writes text, and it is aimed at developers building agents, coding assistants, chatbots and retrieval systems. It is a looped mixture-of-experts model: 26.4B parameters with about 3.4B active per token, and 24 layers of which the middle twelve run three times, so each token goes through 48 layer passes. Each token is routed to 8 of 128 experts, and the context window is up to 1M tokens.

Thinking Machines reports, for example, 79.2% on SWE-bench Verified (bash only), 71.6% on Terminal Bench 2.1, 79.0% on BrowseComp with compaction, 74.9% on MMMU Pro and 66.9% on LongBench v2, and 20.1 on the Artificial Analysis Intelligence Index v5.0, the same as Qwen3.8-27B in its table. These are Thinking Machines' figures for its original weights, with its own harnesses and settings; we have not reproduced them.

We converted Inkling 2 Mini to MLX for Macs with Apple Silicon in four builds, each with the vision encoder and Thinking Machines' DSpark speculative-decoding draft (0.64 GB) bundled. Inkling 2 Mini now runs in MLX-VLM itself, from its main branch (not yet in a PyPI release); our inkling2-mlx package on GitHub adds Inkling's tool-call parser, so the MLX-VLM server returns OpenAI-style tool calls.

Always up to date. We keep these builds current on Hugging Face. When Thinking Machines releases a new version of the model, we rebuild, re-test and publish it there, so the links on this page always point to the latest version. The numbers in this article were measured on the version named in each section; the model cards on Hugging Face carry the current figures.

What we released

Converted from thinkingmachines/Inkling-2-Mini at revision 6e7c824. Thinking Machines released the routed experts in 4-bit NVFP4 (8-bit MXFP8 in the last four layers) and no higher-precision weights. Our 4/8-bit build repacks them into MLX's own nvfp4 and mxfp8 formats with every value unchanged, and keeps attention, embeddings, the output layer and the vision encoder in the original bf16: it is the release itself, in MLX. The 4-bit, 3-bit and 2.5-bit builds are re-quantised from the released values to plain affine formats (group 64) to save memory.

Hugging FaceSizeSame next token as Thinking Machines' codeKL vs their codeGSM8K, 50 questionsPeak memory, 8K-token prompt
netprojects/Inkling-2-Mini-MLX-4-8bit (recommended)19.5 GB + 0.64 GB draft98.4%0.001847/5027.8 GB
netprojects/Inkling-2-Mini-MLX-4bit16.5 GB + 0.64 GB draft95.9%0.029147/5023.5 GB
netprojects/Inkling-2-Mini-MLX-3bit14.1 GB + 0.64 GB draft95.5%0.042448/5021.2 GB
netprojects/Inkling-2-Mini-MLX-2.5bit10.8 GB + 0.64 GB draft87.5%0.189945/5018.2 GB

How well it matches the original

Measured on 20 and 21 November 2026, MacBook Pro M5 Max (128 GB), with MLX 0.32.4. The comparison with Thinking Machines' code was re-run on 21 November with MLX-VLM main, as in inkling2-mlx v0.2.0; the other checks were made with our earlier code (inkling2-mlx v0.1.0) on the same weights.

  • Against Thinking Machines' code: their Transformers implementation ran on the CPU with the released weights, on 12 short chat texts (488 answer positions). The 4/8-bit build gave the same next token at 98.4% of positions (mean KL 0.0018) and matched their greedy answers to 3 prompts token for token; every tensor of that build is bit-identical to the release as MLX reads it.
  • GSM8K, 50 fixed test questions, reasoning off, greedy: 47/50 for the 4/8-bit and 4-bit builds, 48/50 for 3-bit and 45/50 for 2.5-bit.
  • Tool calling: an agent prompt with bash and read tools produced a well-formed call in Inkling's format, which the MLX-VLM server returns as OpenAI tool calls.
  • Coding: 3 of 3 short Python tasks passed their asserts. Thinking: 2 of 2 questions answered correctly after one closed thinking block. Vision: the model named the red square and blue circle in a test image.
  • DSpark: the bundled draft loads with each build, and greedy output follows the model's own except at near-ties.

Speed and memory

Generation speed on the same MacBook Pro, median of 3 runs, 256 tokens, greedy, reasoning off: 36.6 tokens a second for the 4/8-bit build (47.1 with DSpark at block size 3), 43.6 for 4-bit (70.9 with DSpark), 44.4 for 3-bit (75.2) and 45.7 for 2.5-bit (83.9), the last three with DSpark at block size 4. The draft's default block size of 8 is slower on this model.

With MLX-VLM's defaults the 4/8-bit build peaks at 27.8 GB for an 8K-token prompt. With a prefill step of 256 it peaks at 21.6 GB (plus 0.64 GB with the draft), which fits the default GPU memory limit of a 36 GB Mac. With the same setting the 3-bit and 2.5-bit builds fit a 24 GB Mac. The 2.5-bit card explains how to run that build on a 16 GB Mac, without the draft and with a raised GPU memory limit.

Try it

On a Mac with Apple Silicon and Python 3.10 or newer, install our inkling2-mlx package (MLX-VLM plus Inkling's tool-call parser) and start the OpenAI-compatible server. PyTorch and torchvision are only used on the CPU by the image processor. Set a limit on output tokens: Thinking Machines notes that the model can think at length even with reasoning set to none, and can get stuck in long reasoning loops.

pip install "git+https://github.com/internet-projects/inkling2-mlx@v0.2.0" torch torchvision
mlx_vlm.server --model netprojects/Inkling-2-Mini-MLX-4-8bit --port 8000

The model card has Python examples for text, images and the DSpark draft: https://huggingface.co/netprojects/Inkling-2-Mini-MLX-4-8bit. Our weight files were updated on 21 November 2026 to the tensor names MLX-VLM uses (the values are unchanged), so if you downloaded a build before then, download it again.

Honest limits

  • We did not run SWE-bench, Terminal Bench, BrowseComp or any other benchmark suite on these builds, so the scores above are Thinking Machines', from its own setup.
  • Our checks are short: 12 chat texts for agreement, one tool-calling prompt, three coding tasks, two thinking questions, one test image and 50 GSM8K questions.
  • All figures come from one machine. The speeds and most checks were measured with our earlier code, and peak memory is for prompts of up to 8K tokens; longer contexts need more.
  • The 4-bit, 3-bit and 2.5-bit builds differ more from Thinking Machines' code than the 4/8-bit build does, the 2.5-bit build most of all.
  • When the model calls a tool, the server's reply text can also carry a short sentence of its reasoning and the tool name.

Licence

Inkling 2 Mini and our builds are under the Apache-2.0 licence, and use of the model is also governed by Thinking Machines' Model Acceptable Use Policy. Each of our repositories carries the licence text and a notice that describes the conversion. The inkling2-mlx code on GitHub is under the MIT licence.

Links

Credits

Inkling 2 Mini is by Thinking Machines Lab, under the Apache-2.0 licence. The MLX builds and inkling2-mlx are by NetProjects (Internet Projects Ltd). Not affiliated with Thinking Machines.

This article was drafted with AI assistance, then edited and approved by people on our team. You can read more about how we use AI at https://netprojects.com/standards/ai.