ThinkingCap is a retrained version of Google’s Gemma 4 26B-A4B that uses, on average, 38.9 percent fewer reasoning tokens with nearly the same accuracy: 75.0 versus 75.2 of the base model across twelve benchmarks. BottleCap AI published it on October 23, 2026 under the Apache 2.0 license, with full weights and GGUF versions on Hugging Face.
It’s a drop-in replacement: only the weights change. The chat template, tokenizer, and recommended sampling configuration are those of the base model. All figures are measurements from BottleCap itself: they’re well done, but no one has independently reproduced them yet. And, as shown by the GGUF card from the same team, the savings don’t carry over intact to the files most people run locally.
What are reasoning tokens and why should you reduce them?
Reasoning tokens (or thinking tokens) are the text a model writes to itself before responding: the draft where it solves the problem step by step. You almost never read it, but you pay for all of it in time, energy, and context window.
On hard math problems, Gemma 4 26B writes between 15,000 and 22,000 reasoning tokens per question. Cutting a third of that changes how long you wait for each answer and how many requests a single machine can handle. BottleCap’s proposal is exactly that: the same answers, with less thinking along the way.
What is Gemma 4 26B-A4B?
gemma-4-26B-A4B-it is the intermediate model in Google DeepMind’s Gemma 4 family, with a mixture of experts (MoE) architecture. It stores around 26 billion parameters but activates only about 4 billion per token: at each step, 8 of its 128 experts run. That gives it the knowledge of a large model with compute costs close to a small one. It also accepts images as input.
Its reasoning mode is off by default: each request has to enable it with enable_thinking. All ThinkingCap figures were measured with reasoning enabled, so if you run the model without it, there’s nothing to save.
How many reasoning tokens does ThinkingCap save?
On average, 38.9 percent across twelve benchmarks. But the savings vary greatly depending on the task:
| Benchmark | Base Accuracy | ThinkingCap Accuracy | Base Tokens | ThinkingCap Tokens | Reduction |
|---|---|---|---|---|---|
| LongBench v2 | 59.43 | 60.88 | 9,486 | 2,934 | 69.1% |
| AA-LCR | 64.62 | 60.62 | 6,519 | 2,655 | 59.3% |
| MMLU-Pro | 84.55 | 84.64 | 3,907 | 1,989 | 49.1% |
| GPQA-Diamond | 79.92 | 78.96 | 7,699 | 4,284 | 44.4% |
| AIME 2026 | 86.20 | 86.72 | 14,766 | 8,963 | 39.3% |
| HMMT (Feb. 2026) | 72.92 | 74.20 | 22,005 | 14,717 | 33.1% |
| LiveCodeBench v6 | 76.98 | 76.96 | 11,560 | 8,375 | 27.6% |
| τ²-bench | 64.25 | 63.73 | 4,374 | 3,466 | 20.8% |
| IFBench | 76.83 | 78.67 | 6,470 | 5,585 | 13.7% |
| Average (12 benchmarks) | 75.2 | 75.0 | 8,773 | 5,398 | 38.9% |
Selection of rows; the full table of twelve benchmarks is on the model card.
Long-context and knowledge tasks see the most reduction; code cuts less. Instruction following and tool use in agent mode barely change. BottleCap’s explanation is that those tasks aren’t about thinking much, but about following a list of constraints or a fixed policy.
The second improvement is less obvious and perhaps more useful in practice: fewer loops. The base model gets stuck repeating the same reasoning in 3.64 percent of its responses; ThinkingCap, in 0.76 percent. On the hardest math set (HMMT from February 2026), loops drop from 17.0 to 4.5 percent. A looped response is a wasted response: it runs to the token limit and returns nothing.
Does ThinkingCap lose accuracy compared to Gemma 4?
On average, almost nothing: 0.15 points. Five of the twelve benchmarks even come out slightly ahead. But “no quality loss” is an average, not a guarantee. Four benchmarks move more than noise between runs would explain:
- AA-LCR (reasoning on long context): −4.00 points. BottleCap acknowledges this as the only real cost in the set. If your work involves reasoning over very long documents, test it before switching.
- GPQA-Diamond: −0.96 points, and MMLU (multilingual): −0.66 points.
- IFBench (instruction following): +1.83 points, this time in ThinkingCap’s favor.
As for method, the evaluation is more solid than most self-reported figures:
- Both models measured by them. BottleCap ran the base model rather than citing Google’s figures, using the same evaluation harness, same hardware, and same sampling config for both.
- Many seeds per benchmark. Each ran between 4 and 64 times, with 95 percent confidence intervals.
- The serving environment: vLLM 0.26.0 on an NVIDIA GB300 per server, with full weights in bf16.
That last detail matters if you think about running it on your own machine.
Does the savings hold with GGUF quantization in llama.cpp?
Only partly, according to BottleCap’s own numbers. The team tested their recommended GGUF file (MXFP4_MOE, 16.6 GB) in llama.cpp against ThinkingCap in bf16, on nine of the twelve benchmarks. With quantization, reasoning length shifts in both directions:
- AIME 2026: 15.5 percent more reasoning tokens than the bf16 version
- IFBench: 6.9 percent more
- GPQA-Diamond: practically the same
- MMLU-Pro: 8.0 percent less
- HMMT (Feb. 2026): 25.0 percent less
The card adds that even the unquantized GGUF (BF16) in llama.cpp thinks more than the original checkpoint served with vLLM: 6.1 percent more on AIME and 14.7 percent more on GPQA. That is, the runtime itself changes reasoning length, regardless of quantization.
What hasn’t been published is the comparison that really matters to anyone working locally: base Gemma 4 in GGUF versus ThinkingCap in GGUF, on the same machine. At the time this note was published (October 24, 2026), neither BottleCap nor anyone else had published that measurement. Expect real savings locally, but don’t count on the full 38.9 percent.
How to use ThinkingCap with llama.cpp or Ollama?
BottleCap documents llama.cpp. These commands come from their GGUF card:
# serve an OpenAI-compatible endpoint, thinking on, with the base model's recommended sampling
llama-server -hf bottlecapai/ThinkingCap-gemma-4-26B-A4B-it-GGUF:MXFP4_MOE \
--jinja --chat-template-kwargs '{"enable_thinking":true}' --reasoning-format deepseek \
--temp 1.0 --top-p 0.95 --top-k 64 -ub 2048 -b 2048
With --reasoning-format deepseek, the server returns reasoning in reasoning_content and the answer in content, so you can count reasoning tokens yourself. BottleCap makes two warnings:
- Keep temperature at 1.0. Greedy decoding can make the model loop.
- Keep
-ub 2048 -b 2048if you send images. With llama.cpp’s default batch size, a large image can crash the server.
Ollama, LM Studio, and Jan load the same GGUF files. The Hugging Face page generates this command for Ollama:
ollama run hf.co/bottlecapai/ThinkingCap-gemma-4-26B-A4B-it-GGUF:Q4_K_M
Keep two things in mind. That command downloads Q4_K_M, which according to BottleCap performed worse on math than MXFP4_MOE. And BottleCap’s card doesn’t explain how to enable reasoning in Ollama, LM Studio, or Jan; without reasoning on, ThinkingCap has nothing to save. If you want to measure the difference, use llama.cpp.
Which GGUF file should you download?
| File | Size | Notes |
|---|---|---|
MXFP4_MOE |
16.6 GB | Recommended by BottleCap; it’s what they evaluated |
Q4_K_M |
17.0 GB | Performed worse on their math benchmarks than MXFP4_MOE |
IQ4_XS |
13.6 GB | The smallest; not evaluated by BottleCap |
Q6_K / Q8_0 |
23.3 / 26.9 GB | More precision, more memory |
mmproj-…-f16 |
1.19 GB | Vision projector, needed to send images |
On machines with tight memory, IQ4_XS is what fits, but it’s also the only one without published figures. If you already run Gemma 4 locally, our guide on which Gemma 4 variant to choose based on your Mac’s RAM covers the memory part.
For GPU servers, the main card documents vLLM, with reasoning and tool call parsers:
vllm serve bottlecapai/ThinkingCap-gemma-4-26B-A4B-it --max-model-len 262144 \
--reasoning-parser gemma4 --enable-auto-tool-choice --tool-call-parser gemma4
Full weights in bf16 take up around 52 GB.
Who’s behind ThinkingCap?
BottleCap AI. It’s the fifth model in their ThinkingCap series, after two variants of Qwen3 27B, NVIDIA’s Nemotron 3.5 Lightning, and Qwen3.8-Flash-Next, and the first built on a Google model. Among the authors listed in the model citation is Tomas Mikolov, known for word2vec.
BottleCap also sells a commercial “PRO” version that, according to the company, cuts reasoning by 62 percent on average. There’s nothing public about it, so take that as a sales pitch. At the time this note was published, the free model page on Hugging Face still didn’t show download counts: it’s very new.
When should you use ThinkingCap?
- Should use it: work with long context, math and knowledge questions where Gemma 4 thinks a lot, and any environment where loops cost you time or GPU.
- Makes no difference: instruction following and tool use in agent mode, where savings are small (between 14 and 21 percent).
- Test first: reasoning over long documents (the AA-LCR drop) and any GGUF setup locally, where the main figure hasn’t been measured.
Since it’s a drop-in replacement with the same license, the cheapest way to clear up doubts is to run your own prompts through both models with reasoning on and compare the length of reasoning_content.
What about you? Do you turn on reasoning mode when you run models locally, or leave it off for speed?
- llama.cpp
- Ollama
- LM Studio
- I prefer another option (tell us which)
Comment below or, if this article reached you by email, reply directly to the email: your reply gets published here.
Related: LM Studio, Ollama, or llama.cpp: what actually runs on your machine