Blog · AI models

Inkling 2 Mini: specs, benchmarks, and how to run it with Ollama and Hugging Face

Inkling 2 Mini is Thinking Machines Lab's open-weight, Apache 2.0 looped Mixture-of-Experts model, released November 20, 2026: 26.4B total and 3.4B active parameters in a single checkpoint of about 20 GB that runs on a Mac with 32 GB of memory or on one NVIDIA DGX Spark. It takes text and images and writes text, with a context window of up to 1M tokens. This guide covers what "looped" means, the specs, how to run it with Ollama, Hugging Face and Unsloth's GGUF quants, the hardware it needs, Thinking Machines' and Artificial Analysis's benchmarks, and how it compares with Qwen3.8-27B. Updated November 21, 2026.

What Inkling 2 Mini is

Inkling 2 Mini comes from Thinking Machines Lab and was released on November 20, 2026, with weights on Hugging Face under Apache 2.0. Thinking Machines names its intended uses as agentic and tool-use systems, coding assistants, chatbots and retrieval-augmented generation, plus research, fine-tuning and third-party products.

It's a "looped" transformer. The model stores 24 decoder layers, grouped in four blocks of six. The first and last blocks run once. The middle 12 layers (blocks 2 and 3) run three times in a row with the same weights. So each token passes through 48 layer applications while only 24 layers are stored on disk. The model gets more compute per token without getting bigger.

The feed-forward layers are a sparse Mixture of Experts: each token uses 8 of 128 experts per layer. Thinking Machines trained with 384 experts and pruned two-thirds of them. Of 26.4B parameters, 3.4B are active per token; each extra pass through the loop adds about 1.0B effective active parameters, so with three passes it's 5.4B effective active per token.

  • Weights are mostly 4-bit: NVFP4 for 20 layers and MXFP8 for the last 4, in one file of about 20 GB.
  • Attention mixes local and global layers. Images go through a vision transformer; Thinking Machines recommends each image side be 40 to 4096 pixels.
  • Inkling 2 Small is its larger sibling in the same Hugging Face collection, at 594B parameters.

Inkling 2 Mini specs

Inkling 2 Mini
MakerThinking Machines Lab, Inc.
ReleasedNovember 20, 2026
LicenseApache 2.0
Hugging Face repothinkingmachines/Inkling-2-Mini
Parameters26.4B total, 3.4B active, 5.4B effective active per token with three loop passes
Layers24 stored, 48 applied per token (middle 12 run three times)
Experts8 of 128 per token per layer
PrecisionNVFP4 (20 layers) and MXFP8 (last 4)
Checkpoint sizeAbout 20 GB (main safetensors file 19.5 GB, plus a 0.64 GB multi-token-prediction file)
Context windowUp to 1M tokens
Input / outputText and image in, text out
Default samplingtemperature 1.0 in generation_config.json; the model card gives no other settings
Training data cutoffNot stated

How to run Inkling 2 Mini

Commands below are copied from each source page on November 21, 2026. We didn't run them ourselves.

  1. Ollama

    Ollama's library page lists inkling-2-mini:latest, inkling-2-mini:26b-a5b and inkling-2-mini:26b-a5b-nvfp4 (MLX), each 20GB with 1M context and text and image input. The page says it needs Ollama's pre-release (it links a preview download, with no version number) and a Mac with 32GB+ memory, and that it also runs on a DGX Spark. See Ollama's page.

    # From Ollama's library page (needs Ollama's pre-release; Mac with 32GB+ memory)
    ollama run inkling-2-mini
  2. Hugging Face

    The weights are at thinkingmachines/Inkling-2-Mini. The model card has no code of its own; it lists SGLang, vLLM, TokenSpeed, NVIDIA Dynamo, Unsloth, llama.cpp (for GGUF), Llama App, Ollama and Exo Labs as supported, and links SGLang and vLLM recipe pages. The lines below are Hugging Face's auto-generated snippet for vLLM.

    # Hugging Face's auto-generated "Use this model" snippet, not written by Thinking Machines
    pip install vllm
    vllm serve "thinkingmachines/Inkling-2-Mini"
  3. Unsloth GGUF: get Unsloth's llama.cpp build

    Unsloth's guide uses releases from Unsloth's llama.cpp fork. This is its Apple silicon build; the guide also has NVIDIA CUDA 12, AMD ROCm, Windows CUDA 12 and DGX Spark builds.

    # Unsloth's guide: llama.cpp build from Unsloth's fork, Apple silicon
    curl -L -o llama.tar.gz https://github.com/unslothai/llama.cpp/releases/download/b12588-mix-c0c3de8/llama-b12588-mix-c0c3de8-bin-macos-arm64.tar.gz
    mkdir -p llama.cpp
    tar -xzf llama.tar.gz -C llama.cpp --strip-components=1
    ./llama.cpp/llama-server --version
  4. Download the recommended quant

    This fetches UD-Q4_K_XL (17.6 GB), the vision projector mmproj-F16.gguf (adds 639 MB) and a 0.4 GB draft model for speculative decoding, from unsloth/Inkling-2-Mini-GGUF.

    pip install -U huggingface_hub
    hf download unsloth/Inkling-2-Mini-GGUF \
        Inkling-2-Mini-UD-Q4_K_XL.gguf mmproj-F16.gguf dspark-Inkling-2-Mini-Q8_0.gguf \
        --local-dir Inkling-2-Mini-GGUF
  5. Start llama-server

    Unsloth's command for macOS, Linux and WSL. It sets a 32K context; lower --ctx-size if you run out of memory.

    ./llama.cpp/llama-server \
        --model Inkling-2-Mini-GGUF/Inkling-2-Mini-UD-Q4_K_XL.gguf \
        --mmproj Inkling-2-Mini-GGUF/mmproj-F16.gguf \
        --model-draft Inkling-2-Mini-GGUF/dspark-Inkling-2-Mini-Q8_0.gguf \
        --spec-type draft-dspark --spec-draft-n-max 3 --n-gpu-layers-draft 99 \
        --jinja --ctx-size 32768 --n-gpu-layers 99 --parallel 1 \
        --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0 \
        --host 127.0.0.1 --port 8080
  6. Or use the Unsloth CLI

    One command from the same guide.

    unsloth run --model unsloth/Inkling-2-Mini-GGUF:UD-Q4_K_XL \
        --temp 1.0 --top-p 1.0 --top-k 0 --min-p 0.0

Sources: Ollama, Hugging Face, Unsloth

Unsloth GGUF quants for Inkling 2 Mini

Sizes from Unsloth's guide. Unsloth recommends UD-Q4_K_XL. Against UD-Q8_K_XL, it measures UD-Q4_K_XL at a mean KL divergence of 0.0107, picking the same top token 98.0% of the time; UD-Q3_K_XL 0.0174 / 96.3%; UD-Q2_K_XL 0.0595 / 91.6%; UD-IQ1_S 0.0911 / 89.4%.

QuantFile sizeNote
UD-IQ1_S7.76 GB-
UD-IQ1_M8.02 GB-
UD-IQ2_XXS8.49 GB-
UD-Q2_K_XL9.14 GB-
UD-IQ3_XXS11.66 GB-
UD-Q3_K_XL13.63 GB-
UD-IQ4_XS15.73 GB-
UD-Q4_K_M16.61 GB-
UD-Q4_K_XL17.63 GBRecommended by Unsloth
UD-Q8_K_XL22.87 GBReference for the KLD numbers

Recommended settings

  • Sampling: Unsloth's guide uses temperature 1.0, top-p 1.0, top-k 0 and min-p 0.0. Thinking Machines' generation_config.json sets only temperature 1.0.
  • Context: Unsloth starts at 32K (--ctx-size 32768) and says to reduce it if memory is tight. The model itself supports up to 1M tokens.
  • Reasoning: the model card says setting reasoning effort to its minimum doesn't fully turn reasoning off.
  • Limits: the card says the model sometimes gets stuck in long reasoning loops, especially when debugging code, and recommends limits on output tokens and agent turns.

Inkling 2 Mini hardware requirements

What each source says. Images, longer context and other apps on the machine use more memory. The card also notes that support for looped models in local runtimes is new and speed varies by runtime and hardware, and that the middle layers running three times make compute per token higher than the active parameter count suggests.

SourceWhat it says
Thinking Machines model cardAbout 20 GB checkpoint. Supported: 1x NVIDIA DGX Spark, or Apple silicon with 32GB+ memory (MacBooks, Mac minis, Studios). Other GPUs and platforms are possible, with 32GB or more of VRAM recommended.
Thinking Machines launch postRuns via Ollama on any Mac with at least 32GB RAM. DGX Spark (128GB) has native NVFP4 support.
OllamaMac with 32GB+ memory; also DGX Spark.
Unsloth (GGUF, RAM + VRAM or unified memory)1-bit 9 GB, 2-bit 10-11 GB, 3-bit 13-15 GB, 4-bit 17-18 GB, 8-bit 24 GB.

Inkling 2 Mini benchmarks (Thinking Machines' numbers)

These are Thinking Machines' own results from its launch post, a selection of its rows. They are self-reported, not independent runs.

BenchmarkInkling 2 MiniQwen3.8-27BGemma 4 31BNemotron 3.5 Super VL
DeepSWE v1.148.2%42.2%0.3%24.7%
SWE-bench Pro v2 (Hard)77.9%73.8%14.2%44.1%
SWE-bench Verified (bash only)79.2%77.8%46.1%71.1%
Terminal Bench v2.171.6%73.0%43.4%60.7%
Vals Index v2.246.5%--29.8%
AA Index v5.020.120.14.413.6
BrowseComp (with compaction)79.0%61.6%37.0%78.9%
MCP Atlas (Public)82.7%77.3%54.2%67.7%
HLE-Diamond15.2%15.3%7.2%8.8%
ARC-AGI v1 / v284.5% / 49.3%87.5% / 42.4%-22.7% / 1.5%
MMMU Pro Standard 1074.9%76.3%73.4%72.3%
AA-Omniscience non-hallucination rate63.4%71.4%14.5%69.5%

Where Thinking Machines says it falls short

  • MultiChallenge 50.0% and ComplexConstraints v1.1 33.4%, both behind Qwen3.8-27B. It also trails larger models on CritPt v2 and HLE-Diamond.
  • Efficiency: on Stanford's intelligence-per-watt measure on a DGX Spark, the post reports 0.703, against 0.430 for Qwen3.6-35B-A3B, 0.159 for Gemma-4-26B-A4B and 0.036 for Qwen3.5-27B.
  • Model card limitations: it's more likely than larger models to state wrong information confidently, it may delete or overwrite files without asking, and output quality is lower outside English.

Inkling 2 Mini on Artificial Analysis (third party)

Artificial Analysis (AA) is an independent benchmark site. These figures are from its Inkling 2 Mini page, checked November 21, 2026; the page shows no last-updated date.

  • Intelligence Index v5.0.1: 20.
  • Output speed: 280 tokens per second.
  • Price: $0.15 per million input tokens and $0.50 per million output tokens.
  • Cost to run the Intelligence Index: $0.59, as AA shows it.
  • Context window: 1M tokens.

Inkling 2 Mini vs Qwen 3.8 27B

Specs come from each model's Hugging Face card, AA rows from AA's two model pages (neither page mentions the other model; the side-by-side is ours), and benchmark rows from Thinking Machines' table. One caveat: Thinking Machines' Qwen numbers aren't always the variant Qwen reports. Its 73.8% is on SWE-bench Pro v2 (Hard) and its 15.3% on HLE-Diamond; Qwen's own card gives 61.7 on SWE-bench Pro and 30.8 on HLE. Don't mix the two. Both report 73.0 on Terminal Bench 2.1.

Inkling 2 MiniQwen3.8-27B
ReleasedNovember 20, 2026August 14, 2026 (per AA)
LicenseApache 2.0Apache 2.0
ArchitectureLooped MoE: 26.4B total, 3.4B active (5.4B effective)Dense 27B, all parameters active, 64 layers
WeightsAbout 20 GB, NVFP4 and MXFP8BF16
Native context1M tokens262,144 tokens, up to 1M with YaRN
InputText, imageText, image, video
AA Intelligence Index2020 (xhigh); 17 medium, 16 low, 10 non-reasoning
AA output speed280 tok/s53 tok/s (xhigh)
AA price in / out per 1M$0.15 / $0.50$0.50 / $3.00 (Alibaba API)
SWE-bench Verified, bash only (TML)79.2%77.8%
SWE-bench Pro v2 Hard (TML)77.9%73.8%
Terminal Bench v2.1 (TML)71.6%73.0%
MCP Atlas (TML)82.7%77.3%
BrowseComp (TML)79.0%61.6%

What that comparison shows

  • Same AA Intelligence Index (20), but AA measures Inkling 2 Mini at about five times the output speed and lists lower per-token prices.
  • In Thinking Machines' table, Inkling leads on the SWE-type benchmarks, BrowseComp, MCP Atlas and ARC-AGI v2, and trails on Terminal Bench, ARC-AGI v1, MMMU Pro, HLE-Diamond (by 0.1), AA-Omniscience, MultiChallenge and ComplexConstraints.
  • Qwen3.8-27B takes video input and has thinking on by default with xhigh, medium and low reasoning effort. Inkling 2 Mini has the longer native context and a smaller download.

What Inkling 2 Mini means for coding agents

  • Thinking Machines lists coding assistants and agentic, tool-use systems among its intended uses, and at about 20 GB it's small enough to run locally on a 32 GB Mac behind an agent harness, with Unsloth's llama-server command serving it on 127.0.0.1:8080.
  • The card is direct about the risks: when using tools it's less reliable than larger models at following detailed instructions and project conventions, it may take destructive actions without confirmation, and it may not report the outcome of its work accurately.
  • Its advice for deployers: run agentic workloads in a sandbox, cap output tokens and agent turns, and keep human review on high-stakes output.

The playable demo: PlaneBench flight simulator

According to vibegamer.io, Thinking Machines published a flight simulator with the launch, which its post calls the PlaneBench flight simulator demo. Inkling 2 Mini built it offline on a MacBook Pro during a flight, in a few minutes: you take off from a runway and fly over procedural hills, mountains and sea. Play it on vibegamer.io.

For other games people make with Inkling 2 Mini, see Inkling 2 Mini games on vibegamer.io.

With Crewmark

A new model is half of it. The other half is a job.

Models keep getting better and cheaper, and the agents around them still wait for the next prompt. Crewmark turns coding agent sessions into AI employees with a role, a goal in numbers, working hours and a heartbeat, so they take the next issue from a board on their own. Claude Code and Codex employees run natively; other agents, such as OpenCode, DeepSeek Harness and Gemini, connect through ACP (acpx). An employee uses whatever model its agent runs.

  1. Pick a role

    From the AI employee roles, such as an AI software engineer.

  2. Put the work on a board

    Assign issues, make the regular ones repeat, and let the heartbeat wake the employee to take the next one.

  3. See what it can do

    Jobs with setup and rules for each agent are in Claude Code use cases and Codex use cases.

FAQ

What is Inkling 2 Mini?

An open-weight, Apache 2.0 model from Thinking Machines Lab, released November 20, 2026. It's a looped Mixture-of-Experts transformer with 26.4B total and 3.4B active parameters (5.4B effective), takes text and images, writes text and supports up to 1M tokens of context. The checkpoint is about 20 GB.

Where is Inkling 2 Mini on Hugging Face?

At thinkingmachines/Inkling-2-Mini, in Thinking Machines' Inkling 2 collection. Unsloth's GGUF quants are at unsloth/Inkling-2-Mini-GGUF.

How do I run Inkling 2 Mini with Ollama?

Install Ollama's pre-release, then run ollama run inkling-2-mini. Ollama's page says it needs a Mac with 32GB+ memory and also runs on a DGX Spark. The tags are 20GB each.

Who made Inkling 2 Mini?

Thinking Machines Lab. It is the smaller model in the Inkling 2 collection; Inkling 2 Small is the larger one, at 594B parameters. Thinking Machines also offers it through its Tinker platform.

Is Inkling 2 Mini any good?

On Thinking Machines' own table it scores 79.2% on SWE-bench Verified (bash only), 71.6% on Terminal Bench v2.1 and 82.7% on MCP Atlas. Its model card warns it can state wrong facts confidently, get stuck in reasoning loops and take destructive actions without confirmation, so run it in a sandbox with limits on turns and output.

What does Artificial Analysis say about Inkling 2 Mini?

On November 21, 2026, Artificial Analysis listed it at 20 on its Intelligence Index v5.0.1, with 280 output tokens per second and $0.15 / $0.50 per million input and output tokens.

Inkling 2 Mini vs Qwen 3.8 27B: which is better?

Artificial Analysis gives both 20 on its Intelligence Index; it measures Inkling 2 Mini about five times faster and lists it cheaper per token. In Thinking Machines' table Inkling leads on SWE-bench and MCP Atlas and trails on Terminal Bench and MMMU Pro. Qwen3.8-27B is dense, takes video input and has 262K native context against Inkling's 1M.

How much memory does Inkling 2 Mini need?

Thinking Machines supports Apple silicon with 32GB+ memory or one DGX Spark, and recommends 32GB or more of VRAM on other GPUs. Unsloth's GGUF quants need about 9 GB at 1-bit up to 24 GB at 8-bit, and 17-18 GB for the recommended 4-bit UD-Q4_K_XL.

Checked against Thinking Machines' launch post and model card, the Hugging Face model pages, Ollama's library page, Unsloth's guide and Artificial Analysis on November 21, 2026. We didn't run the commands.

Put the newest models on a standing job.

Crewmark turns coding agent sessions into AI employees with roles, goals, working hours and a heartbeat.

Crewmark is open source: star us on GitHub