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.
from transformers import AutoModelForMultimodalLM, AutoProcessorprocessor = 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 OpenAIclient = 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 thinkingprint(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:
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},}