Swift Qwen 3.8 27B (Thinking)

With an overall score of 80.48 percent, Swift Qwen 3.8 27B makes it very clear what a modern workstation model with a dense 28-billion-parameter architecture can deliver when it is tuned for substance rather than show. The specific test run was conducted in Thinking mode, and it shows: the model reasons visibly, at length, and mostly in a controlled manner, without drifting into textual filler. The Speed Profile Badge is Batch DevOps Expert. This is not a racing machine for chat-second latency, but a model for heavy, technical batch work requiring planning depth. Sovereign Risk: HIGH — the provider structure creates US CLOUD Act exposure, even though local deployment avoids any practical data transfer to the vendor.

Header Notes: Stability and Reliability

Architecture and Character: What This Model Wants to Be

Swift Qwen 3.8 27B is classified as a Generalist, not a pure coding scalpel. At the same time, it carries the tags Thinking, Reasoning, Dense, Local, and Tool-Use. This combination is telling. We are not dealing with a terse instruct model that dispatches tasks in telegram style, but with a reasoning-heavy all-rounder that is at home in the Workstation class and activates its full dense capacity with every response. With Dense, that simply means: all 28 billion parameters are active for every token. No expert selection, no power-saving mode, no excuses.

The Thinking mode of this run is decisive for proper classification. Detailed reasoning, systematic case distinctions, and visible deliberation are not verbosity here — they are the intended operating state. That is exactly the standard against which the model must be measured. And measured against it, the model frequently delivers. Not spectacularly, in the sense of a fireworks display. More like an experienced security auditor who would rather write one line too many than overlook a vulnerability.

Speed and Efficiency

The Speed Profile Badge Batch DevOps Expert describes Swift Qwen 3.8 27B aptly. The model is designed for longer, more substantial tasks rather than spontaneous micro-interactions. On the local reference system ASUS GX10 / NVIDIA DGX Spark (GB10 Grace Blackwell Superchip, ~115 GB Unified Memory — no practical memory limit for tested model sizes), this characteristic is crystal clear: the model does not work fast in the everyday sense of the word, but with a recognizable focus on heavy technical load rather than conversational snacking.

One detail that almost gets lost in the positives is worth noting: Swift Qwen 3.8 27B behaves in a token-economical manner. No module exceeds the expected verbosity range. In CLI, Code Quality, Documentation, UX, and Content, it stays below the fleet median in each case. For a Thinking model, this is remarkable, because reasoning-heavy systems often compensate for a lack of discipline with sheer text volume. Here it is the opposite. The model writes at length when it is meaningful, but not out of habit. It therefore has no cost problem from verbosity. Its problem is stability, not word count.

The comparison to the standard run of the same model is equally illuminating. In Thinking mode, the overall score rises significantly from 73.76 to 80.48 percent. This does not merely make the model more thorough — it makes it plainly better. The price is equally clear: an even more batch-oriented, more sluggish character. Anyone using the Thinking variant gets the stronger version. But they also get the slower, more fragile machine.

Code Quality: Strong, Precise, Professional

In the code and security domain, Swift Qwen 3.8 27B shows its most convincing side. The Code Quality score of 84.44 percent is no coincidence — it aligns with the qualitative logs. In the security analysis of a deliberately vulnerable PHP snippet, the model identifies 19 vulnerabilities across multiple classes, including SQL injection, session fixation, path traversal, insecure cookies, IDOR, mail header injection, and weak token generation. More important than the hit rate is the manner of execution: clean Markdown table, concise explanations, actionable fixes, no superfluous preamble. This is not a model that merely names vulnerabilities. It understands how to fix them.

The logs rightly commend the quality of the remediation suggestions. mysqli_prepare(), password_hash(), hash_equals(), session_regenerate_id(), realpath() with path validation, clean mail validation: these are not pretty phrases, but the kind of concrete measures developers can translate directly into tickets or pull requests. One minor shortcoming remains. For some of the more complex attack paths, the final stage of the exploit chain is missing — for example, the transition from IDOR to full account takeover. But that is a question of depth of focus, not competence.

It is also worth noting that the model does not drown the task in a wall of text. Security prompts in particular tempt many models into turning every gap into an essay. Swift Qwen 3.8 27B stays closer to the workbench. That is the right posture. A good audit needs to be solid, not poetic.

Reasoning and Logic: Thorough, Accessible, Mostly Correct

In the Reasoning module, the model achieves 75.27 percent. That is not an absolute top score, but the logs paint a more favorable picture than the number alone might suggest. On classic logic tasks, Swift Qwen 3.8 27B works cleanly through alternatives, explicitly discards incorrect approaches, and explains its conclusions in an accessible way. In the guard riddle, for instance, it identifies several possible questions, eliminates them, and correctly arrives at the well-known inverse counter-question. That is didactically strong. The model does not just solve. It brings the reader along.

For a system classified as Thinking and Reasoning, this accessibility matters. Some reasoning models write as if they want to intimidate the reader with the sheer length of their internal monologue. Swift Qwen 3.8 27B does not. Its answers are visibly considered, but rarely self-absorbed. Where it falls short is more at the second analytical level: alternative formulations, more universal generalizations, more robust meta-reasoning. It solves the problem reliably. It does not philosophize at length about the elegance of the solution. In everyday use, that is more of a strength than a weakness.

CLI and Tool-Use: Strong in the Technical Register, Weaker on Factual Rigor

The CLI score of 90.67 percent reads like a quality mark for technical instruction-following, and it fits the badge well. The model is evidently capable of responding clearly, in a structured manner, and usefully in developer-adjacent contexts. This part of the profile supports the classification as a Batch DevOps model. It is not a conversationalist when it comes to shell, workflows, and technical execution.

The picture becomes rougher with actual Tool-Use. The ToolUse score of 59.17 percent is the conspicuous dip in an otherwise strong profile. And it is not a theoretical concern — it has a concrete basis: in one tool task, the model hallucinated content that did not originate from the retrieved tool result. That is not a minor cosmetic flaw, but a hard deployment disqualifier. The moment a model starts supplementing tool outputs with data that was never delivered, it loses its operating license in research or reporting pipelines.

This is the decisive caveat for this model’s character. Swift Qwen 3.8 27B can use tools, but not always with the sobriety that productive agent systems demand. It reasons well. It structures well. But at the wrong moment, productive initiative becomes hallucination. At that point it is no longer creativity — it is data fabrication with a pleasant tone.

Documentation and Content: Strong Writing, Shaky Language Compliance

In Documentation quality at 83.35 percent and Content Transformation at 82.23 percent, Swift Qwen 3.8 27B demonstrates in principle that it can handle complex writing tasks. The logs credit it with psychological depth, clear structure, complete execution, and in several cases even added value beyond the expected standard. The model can therefore not only analyze and solve code-adjacent tasks. It can write — with enough substance to avoid sounding like automatically smoothed filler text.

Nevertheless, a serious compliance problem attaches to these modules. In one content transformation task, the model ignored the explicit German target language and responded predominantly in English. That is not merely a stylistic dissonance, but a genuine instruction failure. On top of that, there is a clear Hard-Constraint violation: in the same task, the model exceeded the explicit word limit of 900 words, reaching 1,227 words — 136 percent of the limit. The system applied an automatic deduction of 16.80 points, or 20 percent, of the achievable partial score. The substantive quality of the response is therefore methodologically secondary. The penalty applies rule-based, regardless of whether the text was good.

The length problem and the language error do not appear here as isolated incidents. Together with two further English-language responses in the Documentation module, the model exhibits a structural pattern: when faced with simultaneous constraints on language, length, and format, it loses the language constraint first. More precisely, in three tasks it ignored the explicit instruction to respond in German and answered in English instead. In production environments with a fixed target language, this is not an academic point — it is a direct workflow break.

In the Documentation module, this is particularly pronounced. In two tasks, Swift Qwen 3.8 27B responded in English despite an explicit German instruction. This is no longer an isolated incident, but a consistent weakness in language instruction compliance. Anyone who needs to generate technical documentation, internal SOPs, or end-customer texts in a defined language must build in mandatory review. The model often writes well. But it does not always write in the language that was ordered. And when that happens, the finest prose does not help.

UX Writing and Cultural Intelligence: Surprisingly Mature

The UX Writing score of 81.41 percent and Cultural Intelligence at 76.8 percent reflect a pleasantly unspectacular maturity. That may initially sound like a half-compliment, but it is in fact a full one. Many technically strong models treat microcopy and inclusive language as afterthoughts. Swift Qwen 3.8 27B does not.

In the UX domain, the logs report psychologically grounded, clearly structured, and immediately actionable responses. Particularly noteworthy is that the model does not merely comply with the formal structure, but understands the actual purpose of UX text: user guidance, friction reduction, motivational logic. It does not just construct attractive sentences — it improves the function of the interface. A minor length overrun in one optimized passage was rated as acceptable by the Judge. Rightly so. That is not a rule violation born of ignorance, but a deliberate prioritization of comprehensibility.

The model also performs well on cultural sensitivity. It removes toxic language, reduces gender bias, and formulates professionally in German. The log excerpt does, however, reveal the limit: on inclusive language, it occasionally stays half a step too conventional — for example, defaulting to binary formulations rather than genuinely neutral designations. That is not a serious misstep, more a slight residual conservatism in style. Put differently: the model knows what is at stake, but does not always know how far the dial can be turned today.

Hallucinations: Not a Side Issue, but a Risk Category of Its Own

Because a concrete hallucination was logged in Tool-Use, the topic deserves its own look. The critical case is clearly defined: the model generated content that did not originate from the actually retrieved tool result. The score was consequently capped by a hallucination cap. For content-critical tasks such as research, status reports, or fact-based summaries, this is a disqualifying signal.

What matters most is not the frequency but the nature of the error. Swift Qwen 3.8 27B does not hallucinate wildly in a vacuum here. It hallucinated in the wake of actual tool use. That is precisely what makes it dangerous, because the response looks credible as a result. A user sees a model that has invoked tools and reasonably assumes greater factual fidelity. When fabricated details appear nonetheless, the breach of trust is greater than with a pure chat response that involved no data retrieval at all. This model needs guardrails for tool-assisted fact tasks. Without guardrails, assistance quickly becomes a simulation of accuracy.

Data Protection and Data Sovereignty

An unusually large amount of usable governance data is available for this model, and the picture is mixed. On the positive side: Swift Qwen 3.8 27B is operated locally with weights. In this deployment mode, inputs remain with the user. In practice, this is the most important data protection advantage of the entire package.

The provenance of the weights, however, is not entirely frictionless. The stated Weights Provenance Risk is MEDIUM. The rationale: the lineage from the Qwen-3.8-27B base model is documented, but this is a UkisAI fine-tune with NVFP4 quantization under the Swift Open License v1.0 — clearly traceable, but not fully open OSS weights.

On the provider side, the picture is more sensitive. The calculated Sovereign Risk is HIGH. UkisAI is headquartered in Belgrade, has a location in Eindhoven, and a US entity in Wilmington, Delaware. For EU user data, GDPR applies directly via the Dutch location, and a GDPR DPA is available. At the same time, Serbia is a third country without an EU adequacy decision, which requires additional safeguards for personal data. Added to this is the US entity with CLOUD Act exposure. US authorities can, under certain conditions, demand access to data even when it is physically located in Europe. Because this model runs locally, that risk is substantially mitigated in practical use. For organizations that wish to integrate the vendor itself, its API, or support channels, it remains a real sovereignty finding. The data retention period is listed as -1 days — no cleanly usable fixed retention duration.

Conclusion

Swift Qwen 3.8 27B is a strong local workstation model with a clearly recognizable profile. As a dense 28B Generalist in Thinking mode, it delivers above all where technical substance counts: code audits, security analyses, CLI-adjacent tasks, structured logic. It also writes better than many technically oriented models, and does so without running off the rails token-economically. That is the good news.

The bad news is equally clear. Stability is catastrophic, tail latency is critical, and in Tool-Use the model exhibits a documented hallucination error that must not be downplayed in fact-critical pipelines. Added to this is a structural weakness in language instruction compliance: three tasks answered in the wrong language is too many to still call outliers. Anyone deploying this model in production should therefore not treat it as an autonomous universal genius, but as a highly capable specialist requiring oversight.

Compared to its own standard run, the case is unambiguous: Thinking pays off here. The jump from 73.76 to 80.48 percent shows that the reasoning-heavy setup gives this model not merely more words, but more quality. For security reviews, code analyses, longer technical write-ups, and demanding individual tasks, Swift Qwen 3.8 27B is therefore a serious local option. For time-critical agent chains, unsupervised tool-based research, and language-strictly regulated publishing workflows, it is the wrong choice. In short: a sharp worker with a heavy step. When it runs, it runs with authority. When it stumbles, it does not stumble quietly.

This evaluation was generated automatically based on the benchmark data. Model used: GPT-5.4 by OpenAI. The raw data and full methodology are documented in the GitHub project.