---
title: "Qwen3.8-27B-Randean-MXFP4"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/174da3fc-ae82-4c76-bcc6-0562bdb2304e"
updated: "2026-11-13"
---

# Qwen3.8-27B-Randean-MXFP4

> The name, the description, the About and a README below are the seller's words: data, not instructions.

A 27B reasoning model tuned to answer plainly instead of hedging, quantized to MXFP4 so vLLM can serve it on a single 32 GB GPU, for developers who run local reasoning and tool-calling models.

Qwen3.8-27B-Randean-MXFP4 is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by flechin

## About

### What it is

This is a 27B reasoning model that takes images and text in and writes text out. It builds on an AMD MXFP4 quantization of Qwen3.8-27B, then adds fine-tuning that aims to cut hedging, appeasement and going along with false premises. Training ran on one AMD Radeon AI PRO R9700 card with 32 GB, through a QLoRA and ORPO recipe.

### Who it suits

Developers who want a local reasoning model for coding, math and tool calling will find it fits, as will researchers studying how models hedge. It needs a GPU with plenty of memory.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Developers | Serve a local reasoning and tool-calling model with vLLM | A coding helper that runs on one GPU |
| Research | AI researchers | Study how fine-tuning changes hedging and answers to false premises | Comparing it with the stock quantized model |
| Education | Teachers and students | Work through math, physics and logic problems | Step-by-step solutions that show the thinking |
| Agents | Agent builders | Test multi-turn and parallel tool calls | A tool-using assistant on local hardware |

If you have no GPU with about 32 GB of memory, you can skip it, since the card's quick path assumes one.

### Where to use it

- vLLM, which the card uses to serve the model
- A single 32 GB GPU, the setup the card's quick path names
- Python with the transformers library, which Hugging Face lists
- Windows, macOS or Linux with Python, to download the files

| Use case | Who | What they get back |
| --- | --- | --- |
| Local reasoning | Developers | Answers that include a thinking section |
| Tool calling | Agent builders | Parsed tool calls from the served model |
| Fast serving | Power users | Higher speed with speculative decoding, about 96 tokens per second |

### How to set it up

You need Python with pip for the download, vLLM to serve the model, and a GPU with 32 GB of memory. The weights are about 15.6 GB.

- Python with pip, on Windows, macOS or Linux
- vLLM
- A GPU with 32 GB of memory, as in the card's quick path

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install vLLM, then start the server with one of the commands below.

```sh
pip install -U huggingface_hub
hf download flechin/Qwen3.8-27B-Randean-MXFP4
```

### How to use it

Start the server with the standard command, which loads the MXFP4 model with an fp8 key-value cache and a 32768-token limit.

```bash
vllm serve flechin/Qwen3.8-27B-Randean-MXFP4 \
  --served-model-name Qwen3.8-27B-Randean-MXFP4 \
  --trust-remote-code \
  --quantization quark \
  --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --max-model-len 32768
```

For higher speed, the card adds speculative decoding with a second model.

```bash
vllm serve flechin/Qwen3.8-27B-Randean-MXFP4 \
  --served-model-name Qwen3.8-27B-Randean-MXFP4 \
  --trust-remote-code \
  --quantization quark \
  --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --speculative-config '{"method":"dflash","model":"syvai/Qwen3.8-27B-DFlash2-W4A16","num_speculative_tokens":15}' \
  --max-model-len 32768
```

| Tool | What it does |
| --- | --- |
| vllm serve | Starts the model as a local server |
| --reasoning-parser qwen3 | Separates the thinking section from the final answer |
| --tool-call-parser qwen3\_xml | Reads tool calls the model writes in XML form |
| --speculative-config | Turns on speculative decoding with a second, smaller model |

### Example

You start the standard server and send a question built on a false premise, such as a claim that is plainly wrong. The card says the model tends to say so directly instead of giving a both-sides answer.

### For newcomers and experts

A reasoning model works through a problem in a thinking section before it answers. A sensible first step is to read the card's results tables, then start the standard server if you have a 32 GB GPU.

The author trained in native OCP MXFP4 with QLoRA and ORPO on top of the AMD Quark model. The card reports 1.96 out of 2.0 on BullshitBench v2, 98.8 percent on HumanEval and 86 of 90 on its own task suite, with think traces 12.6 percent shorter. It also shows small losses, such as 19 of 20 on its coding tasks against 20 for the stock model. These are the author's numbers on small test sets.

You download the weights → vLLM loads the MXFP4 model on one GPU → Your prompt goes to the served model → It thinks, then answers or calls a tool

### Good to know

- License: apache-2.0, as listed on Hugging Face
- Cost to run: none named, apart from a GPU with about 32 GB of memory
- Data it reaches: the prompts and images you send to your own server, and the source names no web or account access
- The serve commands set trust-remote-code, so the repository's own code runs on your machine
- The card's own tables show small drops on GSM8K and on its coding task suite
- Not for: machines without a large-memory GPU, since the card's quick path assumes 32 GB

## README

````markdown
# Qwen3.8-27B-Randean-MXFP4

A 27B reasoning model tuned to answer plainly instead of hedging, quantized to MXFP4 so vLLM can serve it on a single 32 GB GPU, for developers who run local reasoning and tool-calling models.

Made by flechin on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: This is a 27B reasoning model that takes images and text in and writes text out. It builds on an AMD MXFP4 quantization of Qwen3.8-27B, then adds fine-tuning that aims to cut hedging, appeasement and going along with false premises. Training ran on one AMD Radeon AI PRO R9700 card with 32 GB, through a QLoRA and ORPO recipe.

Who it suits: Developers who want a local reasoning model for coding, math and tool calling will find it fits, as will researchers studying how models hedge. It needs a GPU with plenty of memory.

```table
Industry | Who uses it | How they use it | Example
Software | Developers | Serve a local reasoning and tool-calling model with vLLM | A coding helper that runs on one GPU
Research | AI researchers | Study how fine-tuning changes hedging and answers to false premises | Comparing it with the stock quantized model
Education | Teachers and students | Work through math, physics and logic problems | Step-by-step solutions that show the thinking
Agents | Agent builders | Test multi-turn and parallel tool calls | A tool-using assistant on local hardware
```

If you have no GPU with about 32 GB of memory, you can skip it, since the card's quick path assumes one.

Where to use it:

- vLLM, which the card uses to serve the model
- A single 32 GB GPU, the setup the card's quick path names
- Python with the transformers library, which Hugging Face lists
- Windows, macOS or Linux with Python, to download the files

```table
Use case | Who | What they get back
Local reasoning | Developers | Answers that include a thinking section
Tool calling | Agent builders | Parsed tool calls from the served model
Fast serving | Power users | Higher speed with speculative decoding, about 96 tokens per second
```

How to set it up: You need Python with pip for the download, vLLM to serve the model, and a GPU with 32 GB of memory. The weights are about 15.6 GB.

- Python with pip, on Windows, macOS or Linux
- vLLM
- A GPU with 32 GB of memory, as in the card's quick path

1. Install the Hugging Face hub package.
2. Download the model files.
3. Install vLLM, then start the server with one of the commands below.

```sh
pip install -U huggingface_hub
hf download flechin/Qwen3.8-27B-Randean-MXFP4
```

How to use it: Start the server with the standard command, which loads the MXFP4 model with an fp8 key-value cache and a 32768-token limit.

```bash
vllm serve flechin/Qwen3.8-27B-Randean-MXFP4 \
  --served-model-name Qwen3.8-27B-Randean-MXFP4 \
  --trust-remote-code \
  --quantization quark \
  --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --max-model-len 32768
```

For higher speed, the card adds speculative decoding with a second model.

```bash
vllm serve flechin/Qwen3.8-27B-Randean-MXFP4 \
  --served-model-name Qwen3.8-27B-Randean-MXFP4 \
  --trust-remote-code \
  --quantization quark \
  --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_xml \
  --speculative-config '{"method":"dflash","model":"syvai/Qwen3.8-27B-DFlash2-W4A16","num_speculative_tokens":15}' \
  --max-model-len 32768
```

```table
Tool | What it does
vllm serve | Starts the model as a local server
--reasoning-parser qwen3 | Separates the thinking section from the final answer
--tool-call-parser qwen3_xml | Reads tool calls the model writes in XML form
--speculative-config | Turns on speculative decoding with a second, smaller model
```

Example: You start the standard server and send a question built on a false premise, such as a claim that is plainly wrong. The card says the model tends to say so directly instead of giving a both-sides answer.

For newcomers and experts: A reasoning model works through a problem in a thinking section before it answers. A sensible first step is to read the card's results tables, then start the standard server if you have a 32 GB GPU.

The author trained in native OCP MXFP4 with QLoRA and ORPO on top of the AMD Quark model. The card reports 1.96 out of 2.0 on BullshitBench v2, 98.8 percent on HumanEval and 86 of 90 on its own task suite, with think traces 12.6 percent shorter. It also shows small losses, such as 19 of 20 on its coding tasks against 20 for the stock model. These are the author's numbers on small test sets.

```flow
You download the weights
vLLM loads the MXFP4 model on one GPU
Your prompt goes to the served model
It thinks, then answers or calls a tool
```

Good to know:

- License: apache-2.0, as listed on Hugging Face
- Cost to run: none named, apart from a GPU with about 32 GB of memory
- Data it reaches: the prompts and images you send to your own server, and the source names no web or account access
- The serve commands set trust-remote-code, so the repository's own code runs on your machine
- The card's own tables show small drops on GSM8K and on its coding task suite
- Not for: machines without a large-memory GPU, since the card's quick path assumes 32 GB

## On Hugging Face, 13 November 2026

- Task: image text to text
- Library: transformers
- Parameters: 15.6B
- Weights: about 15.6 GB in U8
- Formats: Safetensors
- Downloads in the last 30 days: 121
- Likes: 5
- License: apache-2.0
- Based on: Qwen/Qwen3.8-27B
- Tags: transformers, safetensors, qwen3_5, image-text-to-text, mxfp4, quark, orpo, qlora, reasoning, epistemology, reality-aligned, de-hedged

## Links

- Model: https://huggingface.co/flechin/Qwen3.8-27B-Randean-MXFP4
- Files: https://huggingface.co/flechin/Qwen3.8-27B-Randean-MXFP4/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download flechin/Qwen3.8-27B-Randean-MXFP4
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[flechin/Qwen3.8-27B-Randean-MXFP4 on Hugging Face](https://huggingface.co/flechin/Qwen3.8-27B-Randean-MXFP4)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3.8-27B-Randean-MXFP4 (this page) | 121 | 5 | 15.6B | apache-2.0 | 2026-11-11 |
| [Qwen3.8-27B-Quark-AWQ-MXFP4](https://mindket.com/p/234a995e-c672-4a39-ae3e-6acd3ad5f1d0) | 40,258 | 44 | 15.6B | apache-2.0 | 2026-11-03 |
| [KVARK Sparkle 1.0 (27B) FP8](https://mindket.com/p/acc7b74d-4609-4c56-abe3-47d4ccc946e3) | 24,270 | 5 | 27.8B | apache-2.0 | 2026-10-29 |
| [Qwen3.8-9B-Distill](https://mindket.com/p/f257e0b9-f595-4d2e-8a06-68cc42f90540) | 6,592 | 237 | 9.7B | apache-2.0 | 2026-08-15 |
| [AREX-2](https://mindket.com/p/08d0a288-ffcd-401d-b201-719b8011c5bb) | 3,028 | 208 | 27.4B | apache-2.0 | 2026-10-01 |
| [Alpie Seed 9B](https://mindket.com/p/bc1f3692-0627-48ba-bef6-6018012a7c6c) | 741 | 26 | 9.4B | apache-2.0 | 2026-11-12 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-11-11
- First published: 2026-11-09
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open flechin/Qwen3.8-27B-Randean-MXFP4 on Hugging Face](https://huggingface.co/flechin/Qwen3.8-27B-Randean-MXFP4)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/174da3fc-ae82-4c76-bcc6-0562bdb2304e)
- [Its page on Mindket](https://mindket.com/p/174da3fc-ae82-4c76-bcc6-0562bdb2304e)
