Verdict: Qwythos-27B-v1 is the most feature-complete open-weight reasoning model in the 27B class as of August 2026 — a full-parameter fine-tune of Qwen3.5-27B by the independent lab Empero AI that preserves the base's 1-million-token context window, native multi-token-prediction head, and vision tower without cutting anything to fit. It is free under Apache 2.0, runs on a single consumer GPU at 4-bit quantization, and is intentionally uncensored for technical and research workflows. For builders who need a locally-runnable model that reasons before answering and calls tools natively, it is the strongest no-cost option at this size — with the honest caveat that it is a pre-RL checkpoint (v1), no standardized academic benchmark suite has been published for it, and its vision capabilities are inherited, not independently trained.
Last verified: 2026-08-02
- 28B-parameter dense reasoning model, built on Qwen3.5-27B, released by Empero AI under Apache 2.0
- 1,048,576-token context window (262K native × YaRN factor 4.0), with MTP and vision intact
- Trained via SFT → DPO → ESFT on Claude Mythos / Claude Fable traces (500M+ tokens of distillation data)
- Intentionally uncensored; pre-RL checkpoint (v1) with an RL-trained v2 planned
- Best for: local reasoning, agentic/tool-use workflows, cybersecurity and technical research
- Pricing/limits change often — last checked 2026-08-02.
What is Qwythos-27B-v1?
Qwythos-27B-v1 is an open-weight, full-parameter reasoning model released by Empero AI — an independent research lab based in Germany — as the bigger sibling to their earlier Qwythos-9B-Claude-Mythos-5-1M. It is built on a Qwen3.5-27B base and post-trained through a three-stage pipeline: supervised fine-tuning (SFT), direct preference optimization (DPO), and early-stopping fine-tuning (ESFT), all in bf16 with assistant-only loss on long, untruncated sequences. The weights and purpose-built GGUF files are published on Hugging Face under Apache-2.0. (Hugging Face model card · Empero)
The headline claim from Empero is simple: "nothing was ablated to make it fit." Most community fine-tunes of a 27B model sacrifice at least one capability — they drop the multi-token-prediction (MTP) head, disable the vision tower, or truncate the context window to save VRAM. Qwythos-27B-v1 keeps all three: the native MTP head, the full vision tower (333 tensors, depth 27), and the 1,048,576-token YaRN-extended context. This matters because it means you get a single model that can reason over a million tokens of input, accept images, and use self-speculative decoding for faster generation — without choosing which feature to give up.
This is a pre-RL checkpoint (v1). Empero has stated an RL-trained v2 will follow, the same way Qwythos-9B received a v2. Early testing will continue to shape how it performs on real day-to-day tasks; that is normal for any new model release and does not take away from how strong the starting point already is.
How does Qwythos-27B compare to Qwythos-9B?
Qwythos-27B is the larger sibling in the same Mythos line, using the same training curriculum scaled to 27B. The comparison is the most common question from anyone already using the 9B.
| Property | Qwythos-9B-Claude-Mythos-5-1M | Qwythos-27B-v1 |
|---|---|---|
| Base | Qwen3.5-9B | Qwen3.5-27B |
| Parameters | ~9B (10B with MTP head) | ~28B |
| Context | 1,048,576 tokens (YaRN) | 1,048,576 tokens (YaRN, factor 4.0) |
| License | Apache-2.0 | Apache-2.0 |
| Vision | Inherited from base (text-only training) | Inherited from base (text-only training, frozen) |
| MTP head | Preserved | Preserved (1 hidden layer) |
| Function calling | Native (Qwen3.5 spec) | Native (Qwen3.5 spec) |
| Reported benchmarks | MMLU +34.3 vs base, GSM8K-strict +30.0 | No standardized academic suite published |
| GGUF size (Q4_K_M) | ~5.9 GB | ~17–18 GB (estimated from 27B weight math) |
| Status | v2 released (July 2026) | v1 (pre-RL); v2 planned |
The 9B has published benchmark numbers (MMLU 57.5, GSM8K-strict 81.0) and a documented +34.3 MMLU lift over its base. The 27B has not published a standardized academic benchmark suite — the model card explicitly states this and recommends you validate on the tasks and operating conditions that matter to your deployment. What the 27B does publish is a held-out terminal/tool-session perplexity shift: 356.6 → 2.76, a dramatic improvement on agentic session data. In a closed-book organophosphate-poisoning evaluation, the 27B volunteered that physostigmine should be avoided, where the 9B needed a web search to get that fact right — a concrete example of the scale jump improving closed-book recall. (Hugging Face · Empero 9B release)
How much VRAM do you need to run Qwythos-27B-v1?
A 4-bit quantized build of Qwythos-27B-v1 (Q4_K_M GGUF) needs roughly 17–18 GB of VRAM for the weights alone, plus additional memory for the KV cache — and the full 1M-token context makes the KV cache the dominant memory cost, potentially requiring CPU/KV offload or multiple GPUs regardless of weight quant. For shorter contexts (a few thousand tokens), a single RTX 5090 (32 GB) or RTX 4090 (24 GB) is comfortably sufficient. Empero reports a measured data point: Q4_K_M fully offloaded to a single RTX 5090 at 4K context runs at ~74 tokens/s generation and ~622 tokens/s prompt processing (llama.cpp CUDA build, -ngl 99). (Qwythos-27B-v1-GGUF)
Practical VRAM guidance by quantization (weight size only; add KV cache and ~0.86 GiB for the vision projector if you need image input):
| Quant | Approx. weight size | Fits on |
|---|---|---|
| Q4_K_M | ~17–18 GB | RTX 4090 (24 GB), RTX 5090 (32 GB) |
| Q8_0 | ~29 GB | RTX 5090 (32 GB) with small context |
| BF16 (full precision) | ~56 GB | Multi-GPU or server (e.g. 2× A100 40 GB) |
If your use case depends on the full 1M context window, budget for substantially more memory or plan to offload the KV cache to CPU. The weight size is only part of the hardware budget at long context.
How to run Qwythos-27B-v1 locally
The fastest path to get Qwythos-27B running on your own hardware, verified from the GGUF model card and the Qwen3.5 runtime conventions the model inherits.
Option 1 — llama.cpp (recommended for most users)
# Install llama.cpp (macOS / Linux)
curl -LsSf https://llama.app/install.sh | sh
# Start an OpenAI-compatible server with Q4_K_M
llama serve -hf empero-ai/Qwythos-27B-v1-GGUF:Q4_K_M
# Or run inference directly in the terminal
llama cli -hf empero-ai/Qwythos-27B-v1-GGUF:Q4_K_M
For image input, download the mmproj (vision projector) alongside a text quant and use llama-mtmd-cli. The vision projector is ~0.86 GiB at F16 and is required for images — it pairs with any text quant.
Option 2 — Ollama
ollama run hf.co/empero-ai/Qwythos-27B-v1-GGUF:Q4_K_M
Option 3 — vLLM (production serving)
pip install vllm
# For the GGUF build:
vllm serve "empero-ai/Qwythos-27B-v1-GGUF"
# For the full-precision safetensors build, serve at long context:
vllm serve empero-ai/Qwythos-27B-v1 --max-model-len 1010000
vLLM gives you an OpenAI-compatible API endpoint — the right choice if you are wrapping the model in a product or serving it to multiple users.
Option 4 — Transformers (Python)
from transformers import AutoModelForImageTextToText, AutoTokenizer
model_id = "empero-ai/Qwythos-27B-v1"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
model_id,
dtype="bfloat16",
device_map="auto",
)
messages = [{"role": "user", "content": "Explain the trade-offs in this terminal plan and propose the next command."}]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
output = model.generate(**inputs, do_sample=True, temperature=0.6, top_p=0.95)
Sampling recommendations (important)
Qwythos is a reasoning model — every response opens with a <!---->... reasoning block before the final answer. Use these settings to avoid repetition loops on long generations:
| Parameter | Value |
|---|---|
temperature |
0.6 |
top_p |
0.95 |
top_k |
20 |
repeat_penalty |
1.05 |
max_new_tokens |
16384 (generous budget for reasoning + answer) |
Avoid greedy decoding and very-low-temperature sampling (T ≤ 0.3) — both can cause repetition loops on long reasoning generations, a known reasoning-model failure mode. (Qwythos-27B-v1-GGUF model card)
What does "nothing was ablated" actually mean for you?
Most community fine-tunes of a large model make a trade: to fit a 27B model on consumer hardware or to speed up training, they drop something. The multi-token-prediction head gets removed (so you lose self-speculative decoding). The vision tower gets stripped (so the model can't look at images). The context window gets truncated (so you can't feed it a whole codebase or a year of customer conversations). Qwythos-27B keeps all three.
For a builder or small business, that translates directly into capability:
- 1M-token context means you can hand the model every customer conversation, every support ticket, or a whole repository of code, and it holds all of it while it reasons. A typical cloud API in 2026 still charges per-token for that much input; a locally-run model with a 1M window does it for the cost of electricity. If you are tired of watching a cloud model "forget" the start of a long conversation, this is the fix. For a deeper look at why long-context reasoning matters and where it still breaks, see our guide on long-horizon AI reasoning and the multi-step scaling wall.
- Native tool calling means the model can call functions, run shell commands, and use a Python executor without a wrapper or a tool-specific fine-tune — the chat template carries Qwen3.5's full tool-use spec. This is the capability that makes it useful for agentic workflows, not just chat. If you are building an agent stack, our system-over-model guide to plugging new LLMs into agent frameworks covers how to swap a model like this into an existing agent loop.
- Intentionally uncensored means the model engages substantively with technically demanding questions across cybersecurity, red-team methodology, biology, pharmacology, and clinical medicine — the domains where over-aligned models hedge into uselessness or bury the real answer under disclaimer boilerplate. Empero's stated thesis: a model that knows when to look something up beats a much bigger model that confidently invents it. If you are putting it in front of end users, add your own application-level review layer.
What is multi-token prediction and why does keeping it matter?
Multi-token prediction (MTP) is an architectural feature inherited from the Qwen3.5 base where the model predicts several tokens ahead in a single forward pass, rather than writing one token, stopping, thinking, and writing the next. You can think of it as auto-complete that is actually right most of the time, instead of typing every letter by hand.
Qwythos-27B preserves the base's one-layer MTP head and its 15 associated tensors verbatim — SFT did not touch them, and they were re-attached through the safetensors index. This means the model is usable for self-speculative decoding, a technique where a smaller draft head proposes tokens and the main model verifies them, speeding up generation without a separate draft model. If your GGUF runtime supports draft-mtp speculation, use the -MTP- GGUF variants; if it does not, use the trunk-only files. (Hugging Face model card)
Is Qwythos-27B-v1 free for commercial use?
Yes. Qwythos-27B-v1 is released under the Apache 2.0 license, inherited from the Qwen3.5-27B base. Apache 2.0 is one of the most permissive open-source licenses: you can download it, run it, build products on top of it, use it to run a business, fine-tune it, and redistribute it — all without paying Empero, Alibaba, or anyone else, and without attribution conversation or scale thresholds. This is a meaningful difference from many cloud-only AI tools that charge per token every month. For a broader look at how the base-model licensing and training landscape shifted in 2026, see our analysis of the LLM base-model training paradigm shift.
What does "uncensored" mean and should you care?
Empero states plainly: "Qwythos is intentionally uncensored for technical and research use. It engages substantively with sensitive-but-legal cybersecurity, biomedical, and technical questions; use appropriate review and application-level controls for your deployment." (Hugging Face)
In practice this means the model will answer direct, technical questions that frontier cloud models often refuse or hedge — questions in domains like penetration testing, toxicology, and clinical medicine where a refusal is actively unhelpful for a trained professional doing legitimate work. The trade-off is that a model with fewer built-in guardrails can also produce answers you would not want to surface to an end user without review. Empero's guidance is explicit: if you are putting it in front of end users, add your own application-level review and safety layer. For internal, technical, or research use, the lack of hedging is a feature, not a bug. For more on how to think about safety controls when deploying AI agents, our reporting on AI safety testing incidents and the containment gap covers what has gone wrong and what actually works.
What is the training method behind Qwythos-27B?
Qwythos-27B uses the same curriculum as Qwythos-9B, scaled to 27B. The pipeline is full-parameter SFT → DPO → ESFT, in bf16 with assistant-only loss on long, untruncated sequences. The training data is Claude Mythos and Claude Fable traces — over 500 million tokens of distillation data for the 9B, with the chain-of-thought structured by Empero's in-house rethink tool so the model learns to walk hypothesis → verification → conclusion before it commits to an answer.
Empero has not published the training data, per-stage hyperparameters, packing/kernel setup, or DPO and ESFT hyperparameters for the 27B. What they have published is a single concrete result: held-out terminal/tool-session perplexity dropped from 356.6 to 2.76 after training — meaning the model went from essentially random on agentic sessions to near-fluent. In a held-out emulated Claude-Code session for an authorized lab network assessment, Qwythos consumed injected nmap output, reasoned about scan trade-offs, and emitted the correct next shell-form tool call. It emits first-person reasoning rather than the base model's meta-planning outlines, and greedy long-form generations were clean under loop check (no degenerate repetition). (Hugging Face model card)
If you want to understand the broader context of why reasoning distillation from frontier models is now a standard training path, our guide to training AI agents without verifiable rewards covers the shift from RLHF toward reasoning-prior training.
What this means for you
If you are not technical at all: you do not need to download anything today. What matters is that a model like this now exists, free, from a small independent lab — because the capabilities will show up inside more tools you already use over the next few months. The gap between what a giant company can build and what a small team can ship for free is closing, and that means the tools that help you save time, answer customers faster, and organize your business keep getting cheaper to access.
If you run a business and want to try it: the simplest place to start is feeding it a real problem you have this week. Sort through customer messages, summarize a pile of notes, or analyze your last 20 content posts for patterns — its 1M-token context means it can look at all of it at once instead of a few thousand words at a time. Use the sampling settings above (temperature 0.6, top_p 0.95) and give it room to reason before it answers.
If you are a builder or developer: this is the strongest no-cost, locally-runnable reasoning model in the 27B class right now for agentic and tool-use workflows. It fits on a single RTX 5090 at 4-bit, calls tools natively, and its Apache 2.0 license means you can ship a product on top of it commercially with no strings attached. Validate it on your own tasks — no standardized academic benchmark suite has been published — and plan your memory budget for the KV cache if you need the full 1M context. If you are deciding between local and cloud for your agent stack, our budget AI model decision guide frames the trade-offs.
FAQ
Q: Is Qwythos-27B-v1 free?
A: Yes. It is released under the Apache 2.0 license on Hugging Face, which permits commercial use, modification, and redistribution without royalties. Weights and GGUF builds are free to download.
Q: How much VRAM does Qwythos-27B-v1 need?
A: Roughly 17–18 GB of VRAM for the Q4_K_M (4-bit) GGUF weights alone, plus KV-cache memory that grows with context length. The full 1M-token context can make the KV cache the dominant cost. A single RTX 5090 (32 GB) runs Q4_K_M comfortably at short context; full-precision BF16 needs ~56 GB and multi-GPU.
Q: Can Qwythos-27B-v1 see images?
A: Yes, but with a caveat. The full vision tower from Qwen3.5-27B is preserved and active, so the model can accept images, screenshots, charts, and handwriting. However, training was text-only — the vision parameters were frozen, meaning image-grounded reasoning inherits the base model's behavior and has not been independently evaluated. Download the mmproj vision projector (~0.86 GiB) alongside a text quant for image input.
Q: What is the difference between Qwythos-27B-v1 and Qwythos-9B?
A: Qwythos-27B is the larger sibling in the same Mythos line, using the same training curriculum scaled from a Qwen3.5-9B base to a Qwen3.5-27B base. The 9B has published benchmarks (MMLU 57.5, GSM8K-strict 81.0); the 27B has not published a standardized academic benchmark suite but shows a 356.6 → 2.76 perplexity shift on held-out terminal/tool sessions and improved closed-book recall in Empero's tests.
Q: Is Qwythos-27B-v1 safe to deploy to end users?
A: Not without your own application-level review and safety layer. Qwythos is intentionally uncensored for technical and research use — it engages substantively with sensitive-but-legal questions in cybersecurity, biomedicine, and pharmacology. Empero's guidance: add appropriate controls for your deployment if it is end-user-facing.
Q: What is multi-token prediction (MTP) and does Qwythos-27B support it?
A: MTP is an architectural feature where the model predicts several tokens ahead in one forward pass, enabling self-speculative decoding for faster generation. Qwythos-27B preserves the base Qwen3.5-27B's MTP head and its 15 tensors verbatim — SFT did not touch them. Use the -MTP- GGUF variants if your runtime supports draft-mtp speculation; use trunk-only files otherwise.
Q: Is there a benchmark for Qwythos-27B-v1?
A: No standardized academic benchmark suite has been published for this checkpoint. Empero reports a held-out terminal/tool-session perplexity shift of 356.6 → 2.76 and qualitative results (correct nmap tool calls, correct drug-contraindication recall) but recommends you validate the model on the tasks and operating conditions that matter to your deployment.
Discussion
0 comments