ThinkingCap: gemma-4-26B-A4B-it

ThinkingCap brings our shorter-thinking post-training to gemma-4-26B-A4B-it (Google DeepMind, 2026), a mixture-of-experts model with image input. ThinkingCap gemma-4-26B-A4B-it cuts reasoning tokens by 38.9% on average (14% to 69% depending on the benchmark) at an average accuracy of 75.0% against the base model's 75.2%.

As in the base model, thinking is off unless the request turns it on with enable_thinking=True; every number on this card was measured with it on.

The base model and ThinkingCap answering the same prompts side by side, with each answer's token count and time; playback is sped up. Also in 4K.

Token efficiency and benchmark performance

Evaluation details

Models

Base google/gemma-4-26B-A4B-it against bottlecapai/ThinkingCap-gemma-4-26B-A4B-it, shown as Ours.

Metrics

• Accuracy (Base / Ours) — fraction of correct answers. The τ²-bench score is an unweighted mean over its three domains (airline, retail, telecom), not pooled over tasks.
• Thinking tokens (Base / Ours) — mean length of the thinking trace, answer excluded. τ²-bench is a multi-turn agentic episode, so for that row the count is the thinking summed over every turn of the episode, not a single trace.
• (Thinking token) Reduction — the relative change between the two mean columns beside it, (Ours − Base) / Base, where each mean is taken over every question and seed of the benchmark. A saving is shown as a green ↓ percentage.
• Macro average (bottom row) — equal-weight mean across benchmarks of each column, including the reduction: it is the mean of the per-benchmark reductions, not the ratio of the two token figures beside it.

We also track two ways a thinking trace can fail:

• Truncation — the trace never closes, because the model hits the generation cap or stops while still reasoning, so there is no answer. On τ²-bench, an episode counts if any of its turns hits the per-turn cap. Base 4.35%, ours 0.72%.
• Looping — the model repeats the same reasoning and never finishes, detected with a compression-ratio test on each trace. Base 3.64%, ours 0.76%.

Both rates are equal-weight means across benchmarks, and they are highly correlated.

Serving

Hardware: one NVIDIA GB300 per server, without tensor parallelism. vLLM 0.26.0 with DFlash speculative decoding: draft model z-lab/gemma-4-26B-A4B-it-DFlash, 15 draft tokens.

Thinking is on (enable_thinking=True), with the base model's recommended sampling — temperature=1.0, top_p=0.95, top_k=64 — used unchanged for Ours.

The generation cap is 65,536 tokens on every benchmark, per turn on τ²-bench. The context window is 73,728 tokens on the single-turn benchmarks, 131,072 on τ²-bench and 262,144 on AA-LCR and LongBench v2. The cap was carefully selected to bite in the cases where the base model is looping, to speed up the evals while not affecting the measured accuracy.

Benchmarks

Twelve benchmarks: AIME 2026 (30 problems), HMMT Feb 2026 (33), HMMT Nov 2025 (30), GPQA-Diamond (198), LiveCodeBench v6 (175), MMLU-Pro (12,032), MMMLU (a fixed subset of 714 questions in each of its 14 languages, 9,996 in all), IFBench (300), RealWorldQA (765), AA-LCR (100), LongBench v2 (the 370 of its 503 questions whose prompt fits in 196,000 tokens; longer prompts are left out, not truncated) and τ²-bench (278 tasks across airline, retail and telecom).

Seeds and intervals

Independent runs per benchmark: 64 seeds on AIME 2026, HMMT (Feb 2026) and HMMT (Nov 2025); 32 seeds on GPQA-Diamond and LiveCodeBench v6; 16 seeds on RealWorldQA, IFBench and τ²-bench; 8 seeds on AA-LCR and LongBench v2; 4 seeds on MMLU-Pro and MMMLU. Accuracy cells show the 95% t-interval across seeds — how much the answer moves when only the sampling seed changes, at Google's recommended temperature of 1.0.

Usage

The bf16 weights take about 52 GB. Apart from the weights, every file matches the base model, so the base model's usage examples apply with this repo's id; they include image input.

HuggingFace Transformers

from transformers import AutoModelForMultimodalLM, AutoProcessor
processor = AutoProcessor.from_pretrained("bottlecapai/ThinkingCap-gemma-4-26B-A4B-it")
model = AutoModelForMultimodalLM.from_pretrained("bottlecapai/ThinkingCap-gemma-4-26B-A4B-it", dtype="auto", device_map="auto")

messages = [{"role": "user", "content": "How many prime numbers are there below 100?"}]
inputs = processor.apply_chat_template(
    messages, tokenize=True, return_dict=True, return_tensors="pt",
    add_generation_prompt=True, enable_thinking=True,
).to(model.device)
input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=65536, do_sample=True,
                         temperature=1.0, top_p=0.95, top_k=64)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
processor.parse_response(response, prefix=inputs["input_ids"])   # splits thinking from answer

vLLM

The reasoning parser returns the thinking in a separate reasoning field, and the tool-call parser turns the model's tool calls into structured tool_calls. Both commands below run on a single 141 GB H200 at the full 262,144-token window.

vllm serve bottlecapai/ThinkingCap-gemma-4-26B-A4B-it --max-model-len 262144 \
  --reasoning-parser gemma4 --enable-auto-tool-choice --tool-call-parser gemma4

Our evaluation servers ran DFlash speculative decoding, which also needs the triton attention backend on the model itself:

vllm serve bottlecapai/ThinkingCap-gemma-4-26B-A4B-it --max-model-len 262144 --attention-backend triton_attn \
  --reasoning-parser gemma4 --enable-auto-tool-choice --tool-call-parser gemma4 \
  --speculative-config '{"method":"dflash","model":"z-lab/gemma-4-26B-A4B-it-DFlash","num_speculative_tokens":15,"attention_backend":"triton_attn"}'

Over every decoding step of our evaluation runs (vLLM 0.26.0, one GB300 per server), DFlash accepted on average 4.5 tokens per step of the 15 drafted with this model: 3.0 on RealWorldQA and τ²-bench, up to 6.0 on HMMT Feb 2026.

Querying the server

The server speaks the OpenAI Chat Completions API. Thinking is turned on per request:

from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="-")
r = client.chat.completions.create(
    model="bottlecapai/ThinkingCap-gemma-4-26B-A4B-it",
    messages=[{"role": "user", "content": [
        {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}},
        {"type": "text", "text": "What is happening in this picture?"},
    ]}],
    temperature=1.0, top_p=0.95,
    extra_body={"top_k": 64, "chat_template_kwargs": {"enable_thinking": True}},
)
print(r.choices[0].message.reasoning)               # the thinking
print(r.choices[0].message.content)                 # the answer

A text-only request is the same call with a plain string as content.

Quantized versions

Same checkpoint, chat template and license, quantized for smaller footprints:

• GGUF — bottlecapai/ThinkingCap-gemma-4-26B-A4B-it-GGUF — llama.cpp; MXFP4_MOE (16.6 GB), with the vision projector

Where to find us

Need even more efficiency? Our enterprise versions go further — fewer thinking tokens still, tuned to your workload, at matched accuracy on your own tasks. Built for AI labs, inference providers and enterprises running models at scale. Deployed on your infrastructure, or in the cloud and region you choose. Talk to our team

License

Released under the base model's own license, Apache 2.0 (see the Gemma 4 license page).

Citation

If you use this model, please cite:

@misc{ThinkingCap-gemma-4-26B-A4B-it,
  title     = {bottlecapai/ThinkingCap-gemma-4-26B-A4B-it},
  author    = {Osusky, Adam and Lindauer, Jan and Jirkovsky, Adam and Mihal, Filip and Platek, Ondrej and Herel, David and Ihnatchenko, Luka and Bartek, Vojtech and Jirak, Jiri and Kubista, Daniel and Krus, Frantisek and Mikolov, Tomas},
  year      = {2026},
}