The short version
Swift-Qwen3.8-27B is UkisAI’s fine-tune of Qwen3.8-27B aimed at one specific annoyance: reasoning models that keep re-checking answers they have already found. UkisAI’s headline claim is 58.3% fewer thinking tokens — a median reduction on GPQA-Diamond, and the largest cut in their suite — with under 1% accuracy loss and up to a 1.95× speed-up on several tasks (UkisAI’s Swift model card). Those are the vendor’s numbers, not ours.
Disclosure, up front: this is a documentation-based review. We did not run Swift-Qwen3.8-27B, we did not benchmark it, and we have no test-rig results to show you. Everything below comes from the official model card, UkisAI’s own write-up, Qwen’s base model card, and a community packaging page. Where a number is vendor-reported, we say so.
Try it if you want a Qwen-family model with shorter reasoning traces on a 24 GB-class GPU. Skip it if your work depends on peak competition-math accuracy — the drops are real, and they land in math. The zero-risk test is the free, no-key API, which needs about ten lines of Python.
What is Swift-Qwen3.8-27B?
Reasoning models “think” before they answer, and a lot of that thinking is redundant — the model re-derives a result it already had, or double-checks a step that was fine. UkisAI’s fix is a fine-tune that penalizes the reasoning-marker tokens that trigger that overthinking, plus a transfer component derived from BottleCap AI’s ThinkingCap-Qwen3.6-27B (UkisAI technical report). That is the whole method at the level a beginner needs.
It inherits its shape from the base model: a 262,144-token native context window, extensible to 1,000,000, native image and video understanding, and thinking on by default with reasoning_effort and preserve_thinking controls (Qwen3.8-27B model card). Swift was trained on 8× NVIDIA H100 GPUs supplied by the NVIDIA Innovation Lab (Swift model card).
The headline numbers — and who measured them
The headline is a real measurement by a competent team, but it is their measurement, on their harness. Read it as “the fine-tune changed something,” not as “this beats stock Qwen” — the two baselines in the table and on Qwen’s own card are not the same experiment.
| Benchmark | Base accuracy | Swift accuracy | Base mean tokens | Swift mean tokens |
|---|---|---|---|---|
| GPQA-Diamond | 88.38% | 88.28% | 15,014 | 8,855 |
| MMLU-Pro | 85.47% | 84.95% | 2,980 | 1,603 |
| C-Eval | 90.00% | 90.62% | 1,492 | 804 |
| IFBench | 73.53% | 71.80% | 8,052 | 4,657 |
| AIME 2026 | 98.67% | 94.00% | 22,014 | 16,143 |
| HMMT Nov 2025 | 99.33% | 96.00% | 22,032 | 15,189 |
| ERQA | 67.45% | 66.30% | 4,137 | 2,045 |
| Terminal-Bench 2.1 | 66.74% | 65.84% | 37,086 | 27,272 |
| LiveCodeBench v6 | 76.76% | 81.55% | 11,374 | 8,615 |
UkisAI’s own re-runs, temp 1.0, xhigh effort, five seeds, BF16. Source: UkisAI technical report.
Note the word median in the 58.3% claim — the table reports mean tokens, a different statistic, so do not expect the percentages to line up.
The caveat that matters more than any single cell: that “base” column is UkisAI’s own re-evaluation of Qwen3.8-27B, not Qwen’s published results. Qwen’s official card reports GPQA Diamond 89.2, LiveCodeBench v6 90.3, IFBench 79.5 and Terminal Bench 2.1 73.0 for the base model (Qwen3.8-27B model card) — all higher than the base column UkisAI reports. Different harness, different settings, different scoring. Never lay the two sets of figures side by side as if comparable.
The real trade-off: math takes the hit
Swift buys speed on reasoning tokens and pays for it on the hardest math. Most rows barely move, but the two olympiad-style benchmarks lose multiple points, so the trade only pays off if your workload looks like the intact rows rather than the damaged ones.
GPQA-Diamond slips 0.10 points, C-Eval actually gains, and Terminal-Bench 2.1 loses less than a point. Then you hit AIME 2026, which falls from 98.67% to 94.00%, and HMMT Nov 2025, from 99.33% to 96.00% (UkisAI technical report). Those are the biggest losses in the table and they are not rounding noise.
The counterexample is LiveCodeBench v6, which improves from 76.76% to 81.55% (UkisAI technical report). Fewer thinking tokens did not hurt code generation. If you are doing coding work rather than olympiad math, the trade looks much better than the headline suggests; our Qwen3.8-Flash vs Gemini 3.8 Flash vs MiMo comparison covers the neighbouring models.
The savings also scale with effort. UkisAI reports mean thinking-token reductions of 41.0% at xhigh, 22.7% at medium and 25.8% at low (UkisAI technical report). At xhigh, Swift held 88.28% on GPQA-Diamond against base xhigh at 88.38%, while the base model at medium effort scored 84.14% on 4,451 tokens (UkisAI’s FP8 model card).
Quantized results behave the same way. On W4A16 / AWQ INT4, GPQA moved from 88.69% to 88.38%, IFBench from 72.58% to 71.25%, AIME 2026 held flat at 84.00%, and AWQ AIME went from 82.67% to 84.00% — with Swift cutting AIME output-cap failures by 31-33% (Swift model card). Fewer runaway loops means fewer answers that die at the token limit.
Try it free: the no-key API
You do not need a GPU to judge this model. UkisAI runs a free, no-key OpenAI-compatible endpoint, so the entire test is ten lines of Python and a question you already know the answer to.
The endpoint is https://ukisai.com/api/swift/v1, the model id is literally swift, there is no API key, and it is free for research purposes (Swift model card).
from openai import OpenAI
client = OpenAI(
base_url="https://ukisai.com/api/swift/v1",
api_key="none",
)
response = client.chat.completions.create(
model="swift",
messages=[{"role": "user", "content": "Explain a KV cache to a beginner."}],
)
print(response.choices[0].message.content)
That is the whole setup — no signup, no card, no install. Ask it something you already know, then ask a normal reasoning model the same question and compare how long the reasoning trace runs. Note only that it is licensed for research purposes, and usage limits are not documented on the model card.
Run it locally: the honest hardware bar
Local is cheap to describe and expensive to run. The everyday quant is an 18 GB file, and once you add KV cache it wants a 24 GB-class card, so most laptops should stay on the free API.
The model card ships a long GGUF ladder — UkisAI added a batch of new tiers on 13 September 2026 — and these are the rungs a beginner actually chooses between (Swift model card):
| Quant | File size |
|---|---|
| IQ2_XXS | 9.09 GB |
| Q2_K | 11.0 GB |
| Q3_K_M | 13.6 GB |
| Q4_K_M | 18.0 GB |
| Q5_K_M | 20.2 GB |
| Q6_K | 22.9 GB |
| Q8_0 | 29.1 GB |
| F16 | 54.7 GB |
UkisAI’s guidance is blunt: 24 GB cards for everyday use take Q4_K_M, long agentic runs with strict tool-call formatting go Q6_K or higher, and maximum fidelity means Q8_0 (Swift model card).
File size is not the whole VRAM bill. This is a hybrid-attention architecture where only 16 of 64 blocks use full attention, which brings the KV cache to 64 KiB per token — roughly 0.5 GB at 8k context, 2.0 GB at 32k, 4.0 GB at 64k and 8.0 GB at 128k (Swift model card). So the practical statement is: an 18.0 GB Q4_K_M file plus a modest context window is a 24 GB-card job. Working with less? What fits in 16 GB of VRAM will save you a wasted download, and the GPU VRAM benchmark guide shows how to check your own headroom.
Which quant should you download?
Take Q4_K_M at 18.0 GB unless you have a reason to go higher. Its KL divergence against BF16 is 0.0120 (Swift model card) — the number to quote when someone tells you 4-bit means broken output.
We make no quality claims about the smaller quants below Q4_K_M; they are listed above as facts, and UkisAI’s guidance does not recommend them for everyday use. Those tiers were built with bartowski’s quantization-config rather than llama.cpp’s built-in heuristic, which is why the ladder has so many rungs.
How to serve it: Ollama, llama.cpp, vLLM — and one catch
Start with llama.cpp through the one-line llama.app installer, or use vLLM with the official Qwen3.8 recipe if you already run a GPU server; the SGLang cookbook is the equivalent path there.
The Ollama route works too, but read the label. Stock Ollama runs the clean Q4_K_M baseline tag and does not activate the custom speculative-decoding routes — those need a custom build (community Ollama page). That packager recommends a map-k4v tag, citing a 3.61× median speed-up at +276 MiB of VRAM from its own 22-cell measurement at 32K/f16 context. That is a community packager’s local measurement, not a vendor guarantee, and not something we have reproduced. Still choosing how to run local models at all? Ollama vs LM Studio and our beginner’s guide to Ollama are the two places to start.
Fine print before you commit
Three things to know. The GGUF files were only smoke-tested, the weights are gated under a revenue-threshold licence, and a newer Swift 1.5 release already exists — so the version most write-ups describe is not the one you should download today.
The GGUF files were only smoke-tested. UkisAI says the converted files passed a finite-tensor check and a CPU text-generation smoke test, but multimodal generation and the full benchmark suite were not re-evaluated on the GGUF release (Swift model card). Treat image and video understanding on the GGUF build as unverified, whatever the base card promises.
The weights are gated. Swift is distributed through gated access under the Swift Open License v1.0 (Swift model card). Personal, research, educational, evaluation and commercial use are free for individuals and organizations with gross annual revenue, including affiliates, up to US$1,000,000 (UkisAI technical report). Above that you need a paid Swift Enterprise License, and that price is not publicly listed (enterprise contact). The base Qwen3.8-27B remains Apache 2.0 (Qwen3.8-27B model card), so if licensing friction is a dealbreaker, the base model is still there.
A newer version exists. Swift 1.5 Qwen3.8-27B shipped on September 21, 2026, claiming 58.5% fewer thinking tokens and scoring 0.35% higher than base (UkisAI product page). UkisAI lists 6,104,539 total Swift downloads, of which Swift 1.0 accounts for 1,172,439 and Swift 1.5 for 3,318,764. Start with 1.5; this review is about 1.0 and does not cover 1.5 beyond those figures.
Every way to run it — and what it costs
There are five realistic routes: the free research API, llama.cpp or llama.app, Ollama, vLLM or SGLang, and GGUF files on a local GPU. All are free under the Swift Open License apart from enterprise use above the revenue threshold — you pay in hardware and setup time, not licence fees.
| Method | What you need | Cost | Key caveat |
|---|---|---|---|
Free no-key API, ukisai.com/api/swift/v1, model swift (card) | any device | Free for research, no key | Research terms; limits undocumented |
| llama.cpp / llama-server via llama.app (card) | CPU or GPU + GGUF | Free under the license | GGUF suite not re-evaluated |
| Ollama community build, stock tag (page) | 24 GB-class GPU | Free under the license | Plain Q4_K_M, no spec-decode |
Ollama custom build, map-k4v (page) | custom build, +276 MiB VRAM | Free under the license | 3.61× is the packager’s measurement |
| vLLM / SGLang (card) | server-class GPU | Free, self-hosted | Server-oriented, not beginner-first |
| GGUF Q4_K_M, 18.0 GB (card) | 24 GB VRAM | Free under the license | Everyday pick; KL div 0.0120 |
| GGUF Q6_K, 22.9 GB (card) | higher VRAM | Free under the license | Pick for agentic runs |
| GGUF Q8_0, 29.1 GB (card) | highest VRAM | Free under the license | Maximum-fidelity pick |
| Smaller quants: Q3_K_M 13.6 GB, Q2_K 11.0 GB, IQ2_XXS 9.09 GB (card) | smaller GPUs | Free under the license | Below vendor guidance; no claims from us |
| Swift Enterprise License (card) | orgs above US$1M gross revenue | Price not publicly listed | Required above the threshold; base stays Apache 2.0 |
All GGUF rows need KV-cache headroom on top of file size — about 0.5 GB at 8k rising to 8.0 GB at 128k (Swift model card).
Swift-Qwen3.8-27B vs alternatives: which should you pick?
Pick Swift-Qwen3.8-27B if reasoning-token spend is your bottleneck and you want a free, low-risk test. Pick stock Qwen3.8-27B if peak math accuracy or Apache 2.0 licensing matters more. Start with Swift 1.5 if you are beginning today.
- Base model — when the math rows must stay intact, or your legal team will not sign a revenue-threshold licence.
- Swift 1.0 — only if you are following documentation that names it, or want the version most write-ups describe.
- Something else — if you need a small download; the smallest quant UkisAI recommends is still 13.6 GB.
ToolBrain score
The score rates what we could actually check: a free no-key API and a clear quant ladder push ease and docs up, while the reported math losses and the unverified GGUF suite pull performance down. Features and support stay unscored because no source supports a number.
| Dimension | Score | Basis |
|---|---|---|
| Ease of use | 8/10 | Free no-key API, one-line llama.app installer; gated weights cost points |
| Performance | 7/10 | Vendor-reported benchmarks, not our testing — real savings, real math losses |
| Docs | 8/10 | Quant guidance and KV-cache math unusually clear; GGUF not re-benchmarked |
| Value | 8/10 | Free research API, free licence below the threshold, Apache 2.0 base as fallback |
| Support | Not rated | Undocumented |
| Features | Not scored | Capability claims unverified on the GGUF release |
| Overall Score | 7.8/10 | Mean of the four scored dimensions |
This review is based on official documentation, model cards and vendor benchmark tables. We did not run the model.
Final verdict
Swift-Qwen3.8-27B does one thing well and is honest about the price. If your bottleneck is reasoning-token spend — long agentic loops, tool-calling runs, anything where the model burns thousands of tokens double-checking itself — the savings are worth testing. If your bottleneck is the hardest math questions, this is the wrong model, and the vendor’s own table says so. For agent-heavy work, read up on agent development at NiteAgent before you settle on a serving setup.
Start with the free API, decide in an afternoon, and only then download an 18.0 GB Q4_K_M file (Swift model card). Keep the tools directory and comparison database open while you decide — and check Swift 1.5 before you commit.
Back to all posts