Instructions to use Sparset/Thinklite-27B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use Sparset/Thinklite-27B with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("image-text-to-text", model="Sparset/Thinklite-27B") 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("Sparset/Thinklite-27B") model = AutoModelForMultimodalLM.from_pretrained("Sparset/Thinklite-27B", 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 Sparset/Thinklite-27B with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "Sparset/Thinklite-27B" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "Sparset/Thinklite-27B", "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/Sparset/Thinklite-27B
- SGLang
How to use Sparset/Thinklite-27B 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 "Sparset/Thinklite-27B" \ --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": "Sparset/Thinklite-27B", "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 "Sparset/Thinklite-27B" \ --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": "Sparset/Thinklite-27B", "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 Sparset/Thinklite-27B with Docker Model Runner:
docker model run hf.co/Sparset/Thinklite-27B
Qwen3.8-27B that thinks with half the tokens, with average accuracy within half a point. At
reasoning_effort="xhigh", Thinklite-27B uses 47% less reasoning than Qwen3.8-27B on average over six benchmarks and
writes half as many output tokens, so its time-to-final-output (TTFO) is about 2x shorter, at an average accuracy of
89.8 against the base model's 90.2. At reasoning_effort="low" it uses 28% less reasoning, at an average accuracy 2.2
points below the base model.
| Model | reasoning_effort = xhigh | reasoning_effort = low | ||
|---|---|---|---|---|
| Reasoning vs base | TTFO speed-up | Reasoning vs base | TTFO speed-up | |
| Thinklite-27B | โ 47.0% | 2.0x | โ 28.0% | 1.3x |
| ThinkingCap-Qwen3.8-27B | โ 45.8% | 1.7x | โ 16.4% | 1.2x |
| Swift-1.5-Qwen3.8-27b | โ 35.6% | 1.6x | โ 12.7% | 1.1x |
- Reasoning vs base: the change in mean reasoning tokens per answer against Qwen3.8-27B at the same effort, averaged over the six benchmarks below.
- TTFO speed-up: TTFO (time-to-final-output) is how long a user waits until the model's complete final output is there, thinking included. The speed-up is Qwen3.8-27B's TTFO divided by the model's, over all 4,291 requests for one user. All four models share the Qwen3.8-27B architecture and decode at the same speed (Thinklite-27B 26.3 vs base 26.2 tokens/s for a single user on the same GPU), and the prompts are identical, so TTFO falls in proportion to the tokens a model writes.
Side-by-side comparisons
Debugging
Qwen3.8-27B and Thinklite-27B get the same debugging prompt (retry code plus two logs: find the duplicate charges to refund and the fix) with the same seed, each model on one NVIDIA RTX PRO 6000 serving 20 requests at once. Both answer correctly; Thinklite-27B is done in 2:36.9 with 3,381 tokens, the base model in 11:04.9 with 14,313 tokens (4.2x). The video plays at 22x speed and the clocks show the measured time. This is the largest speed-up of 20 paired runs of this prompt. Thinklite-27B was correct in 19 of the 20 runs and the base model in all 20; over the 19 correct runs the median speed-up was 2.7x.
Coding a game with zero-shot prompting
Both models get the same prompt (shown at the top of the video): write a Minecraft-style browser game in a single HTML
file. Same seed, reasoning_effort="xhigh", one answer each, each model on its own NVIDIA RTX PRO 6000. Both games
run unedited, and the video shows their first 32 seconds of play. Thinklite-27B finished in 33.0 min with 46,820
tokens, the base model in 60.1 min with 81,944 tokens (1.8x). We picked this seed because both games work: over five
paired seeds, Thinklite-27B wrote one fully working game and the base model three.
How it works
Reasoning models spend much of their output on thinking that does not change the answer: restating the question,
repeating a step, re-checking a result that was already checked. Thinklite-27B is fine-tuned from Qwen3.8-27B on its
own verified-correct answers to reach the same answers by a shorter route. Only the thinking gets shorter; the visible
answer keeps its full length and format. It is a drop-in replacement for Qwen3.8-27B with the same chat template,
tokenizer and reasoning_effort control.
Benchmarks
Setup:
We ran all four models ourselves on one frozen suite: identical prompts, chat template, sampling, token caps and scoring. Compared models, both also built on Qwen3.8-27B and run in bf16: bottlecapai/ThinkingCap-Qwen3.8-27B (revision
7891e03) and ukisai/Swift-1.5-Qwen3.8-27b (revisionb4c84d42).vLLM 0.30.0, bf16 weights, FP8 KV cache, temperature 1.0, top_p 0.95, top_k 20, 64 concurrent requests, one NVIDIA RTX PRO 6000 Blackwell (96 GB). All answers were scored together on one machine.
One sample per question (two on AIME 2025). Answers that hit their cap were rerun once with a 131,072-token cap; truncated or unparseable answers count as incorrect.
GSM8K: 1,319 problems
AIME 2025: 30 problems x 2 samples, avg@2
MMLU-Pro: 1,000-question stratified subset
IFEval: 541 prompts, prompt-level strict
LiveCodeBench v6 (LCB): 131 problems (2025-02 to 2025-04), pass@1
BFCL v4: 1,240 non-live function-calling cases
reasoning_effort="xhigh"
| Model | GSM8K | AIME 2025 | MMLU-Pro | IFEval | LCB v6 | BFCL v4 | Average |
|---|---|---|---|---|---|---|---|
| Accuracy (%) | |||||||
| Thinklite-27B | 96.8 | 95.0 | 84.4 | 89.1 | 84.7 | 88.9 | 89.82 |
| ThinkingCap-Qwen3.8-27B | 97.0 | 100.0 | 86.5 | 90.9 | 84.7 | 89.0 | 91.37 |
| Swift-1.5-Qwen3.8-27b | 96.9 | 100.0 | 86.6 | 90.9 | 84.7 | 87.6 | 91.12 |
| Qwen3.8-27B | 97.2 | 93.3 | 86.3 | 91.5 | 84.0 | 88.7 | 90.17 |
| Reasoning tokens vs Qwen3.8-27B | |||||||
| Thinklite-27B | โ 63% | โ 43% | โ 69% | โ 41% | โ 38% | โ 28% | โ 47.0% |
| ThinkingCap-Qwen3.8-27B | โ 68% | โ 33% | โ 58% | โ 51% | โ 20% | โ 44% | โ 45.8% |
| Swift-1.5-Qwen3.8-27b | โ 40% | โ 34% | โ 44% | โ 44% | โ 32% | โ 20% | โ 35.6% |
Mean reasoning tokens per answer
| Benchmark | Thinklite-27B | ThinkingCap-Qwen3.8-27B | Swift-1.5-Qwen3.8-27b | Qwen3.8-27B |
|---|---|---|---|---|
| GSM8K | 163 (-63%) | 141 (-68%) | 267 (-40%) | 443 |
| AIME 2025 | 11,236 (-43%) | 13,228 (-33%) | 12,961 (-34%) | 19,642 |
| MMLU-Pro | 1,343 (-69%) | 1,785 (-58%) | 2,404 (-44%) | 4,295 |
| IFEval | 1,082 (-41%) | 891 (-51%) | 1,031 (-44%) | 1,830 |
| LiveCodeBench v6 | 17,079 (-38%) | 21,936 (-20%) | 18,770 (-32%) | 27,589 |
| BFCL v4 | 143 (-28%) | 113 (-44%) | 159 (-20%) | 200 |
| Average change | -47.0% | -45.8% | -35.6% | - |
| All output tokens, 4,291 requests | 5,822,599 (-50%) | 6,724,080 (-42%) | 7,319,314 (-37%) | 11,533,518 |
reasoning_effort="low"
| Model | GSM8K | AIME 2025 | MMLU-Pro | IFEval | LCB v6 | BFCL v4 | Average |
|---|---|---|---|---|---|---|---|
| Accuracy (%) | |||||||
| Thinklite-27B | 96.7 | 81.7 | 83.3 | 84.3 | 71.0 | 91.2 | 84.70 |
| ThinkingCap-Qwen3.8-27B | 97.2 | 86.7 | 84.8 | 85.8 | 72.5 | 91.5 | 86.40 |
| Swift-1.5-Qwen3.8-27b | 97.1 | 90.0 | 84.7 | 86.0 | 73.3 | 91.2 | 87.04 |
| Qwen3.8-27B | 97.4 | 90.0 | 84.4 | 86.1 | 72.5 | 90.8 | 86.88 |
| Reasoning tokens vs Qwen3.8-27B | |||||||
| Thinklite-27B | โ 21% | โ 46% | โ 23% | โ 41% | โ 17% | โ 19% | โ 28.0% |
| ThinkingCap-Qwen3.8-27B | โ 12% | โ 23% | โ 18% | โ 19% | โ 15% | โ 12% | โ 16.4% |
| Swift-1.5-Qwen3.8-27b | โ 5% | โ 22% | โ 13% | โ 15% | โ 13% | โ 7% | โ 12.7% |
Mean reasoning tokens per answer
| Benchmark | Thinklite-27B | ThinkingCap-Qwen3.8-27B | Swift-1.5-Qwen3.8-27b | Qwen3.8-27B |
|---|---|---|---|---|
| GSM8K | 144 (-21%) | 160 (-12%) | 173 (-5%) | 183 |
| AIME 2025 | 6,521 (-46%) | 9,324 (-23%) | 9,416 (-22%) | 12,125 |
| MMLU-Pro | 854 (-23%) | 908 (-18%) | 963 (-13%) | 1,103 |
| IFEval | 386 (-41%) | 537 (-19%) | 557 (-15%) | 659 |
| LiveCodeBench v6 | 8,882 (-17%) | 9,183 (-15%) | 9,341 (-13%) | 10,741 |
| BFCL v4 | 78 (-19%) | 85 (-12%) | 90 (-7%) | 96 |
| Average change | -28.0% | -16.4% | -12.7% | - |
| All output tokens, 4,291 requests | 3,748,880 (-23%) | 4,121,634 (-16%) | 4,303,835 (-12%) | 4,896,249 |
Usage
vLLM
vllm serve Sparset/Thinklite-27B --reasoning-parser qwen3 --max-model-len 135168 --kv-cache-dtype fp8
from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="-")
reply = client.chat.completions.create(
model="Sparset/Thinklite-27B",
messages=[{"role": "user", "content": "How many primes are there below 100?"}],
temperature=1.0, top_p=0.95,
extra_body={"top_k": 20, "chat_template_kwargs": {"enable_thinking": True, "reasoning_effort": "xhigh"}},
)
print(reply.choices[0].message.content)
Set reasoning_effort to "low", "medium" or "xhigh", exactly as with Qwen3.8-27B. The benchmarks used
temperature 1.0, top_p 0.95 and top_k 20, as recommended for the base model.
Transformers
from transformers import AutoModelForImageTextToText, AutoProcessor
model = AutoModelForImageTextToText.from_pretrained("Sparset/Thinklite-27B", dtype="auto", device_map="auto")
processor = AutoProcessor.from_pretrained("Sparset/Thinklite-27B")
Files
Merged bf16 safetensors with the tokenizer, chat template and processor files of Qwen3.8-27B.
Limitations
- One benchmark run per effort; the small benchmarks (AIME 2025 with 60 answers, LiveCodeBench with 131) carry wide confidence intervals.
- At xhigh, accuracy is below the base model on IFEval (89.1 vs 91.5) and MMLU-Pro (84.4 vs 86.3).
- At low effort, the average accuracy is 2.2 points below the base model, mostly from AIME 2025 (81.7 vs 90.0).
- Long single-answer code was less reliable than the base model's: in the game test above, 1 of 5 games fully worked against 3 of 5.
- The vision encoder is unchanged from Qwen3.8-27B; training data was text only.
- No safety tuning beyond the base model's. Check the model on your own tasks before relying on it.
License
Apache-2.0, the license of the base model Qwen/Qwen3.8-27B.
- Downloads last month
- -
Model tree for Sparset/Thinklite-27B
Base model
Qwen/Qwen3.8-27B