UkisAI's Swift family cuts thinking tokens three ways, and only UkisAI has measured any of them
UkisAI shipped a three-model Swift family sold on fewer thinking tokens, with three different accuracy costs and no measurement by anyone but the seller.
Vlad Makarovreviewed and published
UkisAI released a Swift family on Hugging Face on September 24: Swift 1.5 27B, Swift Flash Next and Swift Bonsai 2, three post-trained derivatives of Qwen base weights sold on one promise, that they think for fewer tokens. The collection holds 11 repositories, and the announcement, signed "Jovan from UkisAI," adds GSQ-RCO quantizations for two of the models. Every number behind the family was produced by the seller.
Three variants, three sizes of the same cut
The figures below are vendor-stated, self-reported, and averaged over five runs with five seeds per model across general reasoning, coding, vision and agentic suites. No third party has published a measurement of any of these three checkpoints.
| Model | Thinking-token claim | Accuracy reported | Status |
|---|---|---|---|
| Swift 1.5 27B | -58.5% | +0.35% | released |
| Swift Flash Next | -63.4% | -0.20 points at xhigh | released |
| Swift Bonsai 2 | -39.8% | +0.19% | experimental |
The trade is the story. Flash Next takes the deepest token cut and the only negative accuracy line, which UkisAI states at 0.20 percentage points against the base at xhigh. The 27B takes the shallowest cut of the two production builds and reports a gain, which is how a family reads as an upgrade rather than a compromise. Bonsai 2, built on Prism ML's ternary weights rather than on Qwen directly, is flagged "experimental" in the vendor's own product listing, and its 39.8% is again a median on one benchmark rather than a mean, the pattern the September 16 release already covered.
The method is published, the target is not
The announcement describes Swift as "a family of efficient reasoning LLMs based on Qwen, trained by penalizing tokens related to pathological overthinking patterns and restoring accuracy via RL (GSPO) and OPD (on-policy distillation)." GSPO is group sequence policy optimization, a reinforcement-learning variant that clips at the sequence level instead of the token level to keep training stable. On-policy distillation, from Thinking Machines, samples rollouts from the student and grades every token with a teacher. Both are published methods with public write-ups. The list of tokens the penalty is built on is not published. UkisAI says it identified the overthinking markers through its own analysis, so an outside reader can check the recipe and not the ingredient.
A lower score, explained downward
The Terminal Bench 2.1 row carries a footnote the release asks you to read. The 27B's score is "misleadingly low at first glance. It is not a bug, but a simple matter of the Swift models not falling into overthinking loops and failing the task, rather pursuing it until the end." The note attributes that to higher average token usage, and says the token reduction "still falls in the -38.7% range when compared apples-to-apples." Three things are checkable in the vendor's own table. The score printed there is 72.13 against the base's 69.21, so it is not low against the thing it is compared with, only against the margin Swift wins elsewhere. The mean token column falls 16.3%, from 52,265 to 43,733, so it is not higher either. The median column falls 0.1%. The one row where Swift 1.5 saves no tokens at the midpoint is the row with a paragraph explaining that the number looks worse than it is, and a request to accept a 38.7% figure drawn from a different comparison.
The speed-up changed between two of the vendor's pages
The 27B product page sells "58.5% fewer thinking tokens while scoring 0.35% higher than the base, for a 9.18x speed-up on several tasks." UkisAI's own model card for the same BF16 weights prints 1.95x in that same clause. The 9.18x is one demo prompt: a card video in which the base model spends 104.6 minutes and Swift 1.5 spends 11.39 building a single 3D browser game. That is a demonstration, not several tasks, and both multipliers are live on UkisAI's own properties for one model.
Quantization first, which is where the release points
Counting artifacts is the fastest way to see who the family is for. The 27B ships BF16 weights plus GGUF, GSQ-RCO GGUF tiers from 8.42 GB to 11.77 GB, W4A16 AWQ, AutoRound INT4, AWQ with GPTQ INT4, NVFP4, AMD Quark FP8, and MLX builds at 3, 4 and 5 bits, the smallest of which drops vision. Flash Next gets its own GGUF, GSQ-RCO, NVFP4 and INT4 exports at roughly 66 to 76 GB. GSQ-RCO reuses per-tensor allocations from ISTA-DASLab's release with Swift-specific refinement on top. That is a distribution built for downloads rather than API calls, and the Hugging Face API agrees: the 27B's inference-provider mapping is empty, while the base model it derives from lists five live providers. Per-repository downloads, one trailing month: 3,303 for the standard GGUF, 1,115 for GSQ-RCO, 217 for 5-bit MLX, 185 for 3-bit, 117 for BF16. The "350k+ downloads in 13 days" the announcement repeats sits on a counter UkisAI runs; Hugging Face's own all-time counters across UkisAI's Swift 1.0 repositories add to about 214,000. None of this is aimed at a hosted endpoint, and a 100K-context local build is the shape of machine it is priced against.
The license carried over
The new weights keep the Swift Open License v1.0 that covered the September 16 release: free for personal, research, educational and commercial use by entities under one million dollars of gross annual revenue including affiliates, with a separate enterprise license above that line. The Qwen base remains Apache 2.0, and UkisAI's terms do not reach it. This is weights-available on custom terms rather than open source, and the threshold is a sales funnel.
What would settle it
Three things would move this from a vendor table to a result: an independent re-run of the three token claims at matched effort, the Terminal Bench 2.1 run published with its median column intact, and a third party measuring the 1.5 checkpoints at all. The closest thing to outside evidence is a hands-on test of the earlier Swift 1.0 on a single agentic coding prompt, which counted about 60,572 output tokens against 11,744 for the base, found the Swift build stalling partway through the task it was asked to finish, and credited Swift's faster wall clock to less strategic hesitation rather than to a shorter trace. One prompt, one model, no error bars, and the only measurement in this family that UkisAI did not run. The counterexample in practice arrived the same week: a practitioner running the official Qwen weights at home accepts the verbosity and works around it with a cheaper cache rather than paying a derivative to shorten it.
