Instructions to use bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8")
model = AutoModelForMultimodalLM.from_pretrained("bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8

SGLang

How to use bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 with Docker Model Runner:
```
docker model run hf.co/bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8
```

bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8

FP8 quantization of bottlecapai/ThinkingCap-Qwen3.8-Flash-Next, the ThinkingCap finetune of Qwen3.8-Flash-Next (Qwen Team, 2026) that reasons in fewer tokens.

➡️ Full model description, evaluation results, recommended sampling params, and citation: see the main model card at bottlecapai/ThinkingCap-Qwen3.8-Flash-Next.

About this quantization

The same layout as Qwen's own FP8 build, Qwen/Qwen3.8-Flash-Next-FP8, so it loads wherever that one does:

the routed experts, in every layer and in the MTP head, in FP8 (E4M3) with 128×128 block scales (weight_scale_inv, weight_block_size: [128, 128]) and dynamic activation scaling;
the n-gram embedding table in FP8 with one per-tensor scale (quantization_config.modules_to_convert);
everything else in bf16: attention and linear attention, the shared experts and router, the vision tower, embeddings and lm_head.

It is built with Qwen's arithmetic as well: run on the stock base model, our quantizer reproduces Qwen's FP8 file exactly on every tensor we compared. ≈186 GB instead of ≈360 GB in bf16.

Publish-time checks

Layout: the tensor inventory is identical to Qwen/Qwen3.8-Flash-Next-FP8 (152,089 tensors), with the same modules_to_convert entry, and every module Qwen keeps in bf16 is kept in bf16 here.
Accuracy and thinking length against the bf16 model, served on two H200s (tensor parallel 2, vLLM 0.31.0, no speculative decoding). Seeds are averaged within a question, and the 95% interval comes from resampling questions:

Benchmark	Questions × seeds (bf16 / FP8)	bf16	FP8	Δ accuracy	Δ mean thinking tokens
AIME 2026	30 × 32 / 8	97.19%	97.92%	+0.73 pp [−1.35, +2.60]	+3.3% [−1.6, +8.8]
RealWorldQA	765 × 8 / 2	84.67%	83.99%	−0.69 pp [−1.70, +0.31]	−0.1% [−10.8, +11.9]

Neither difference is distinguishable from zero, and no generation hit the token cap. On the two H200s the server decoded about 1,900 output tokens/s with 48 or more requests in flight.

MTP speculative decoding on the same two H200s (3 draft tokens, probabilistic drafting, AIME 2026 and RealWorldQA): 2.77 tokens accepted per decoding step on average, the same as the bf16 model. vLLM issue #55357, MTP draft acceptance dropping to zero with repetition inside the thinking on this architecture, is still open; it did not reproduce in our test.

Usage (vLLM)

Requires vLLM 0.31.0 or newer.

vllm serve bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 --tensor-parallel-size 2 --max-model-len 262144 \
  --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_xml

Use the sampling settings from the main model card. The checkpoint keeps the MTP head; to serve with MTP speculative decoding:

vllm serve bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8 --tensor-parallel-size 2 --max-model-len 262144 \
  --reasoning-parser qwen3 --enable-auto-tool-choice --tool-call-parser qwen3_xml \
  --speculative-config '{"method":"mtp","num_speculative_tokens":3,"draft_sample_method":"probabilistic"}'

License

Released under the base model's own license, the Qwen Community License 1.0 (full text in LICENSE). Its conditions carry over to this model, including the separate license from Qwen that Model-as-a-Service and AI work-assistant businesses need for commercial use.

Downloads last month: -

Safetensors

Model size

180B params

Tensor type

I64

BF16

F8_E4M3

Model tree for bottlecapai/ThinkingCap-Qwen3.8-Flash-Next-FP8

Base model

Qwen/Qwen3.8-Flash-Next

Finetuned

bottlecapai/ThinkingCap-Qwen3.8-Flash-Next

Quantized

(3)

this model