Qwen3.6-27B · GGUF Q4_K_M

Quantized, converted, and evaluated by PBH Applied Systems, LLC — Applied AI/ML Consulting · LLM Optimization & Deployment · Quantized AI Infrastructure

🔬 This repository is part of a production-oriented evaluation series. Every model published under pbhappliedsystems has been independently evaluated using quant_eval v7.21 — a proprietary behavioral evaluation harness developed by PBH Applied Systems. Scores measure real agent-adjacent task performance across structured output, tool dispatch, multi-turn state retention, and multi-step planning families — not perplexity or benchmark leaderboard proxies.

🆕 First Qwen3-series model in the evaluated series. Qwen3.6-27B is the first model from Alibaba Cloud's Qwen3 generation to be evaluated in this series. Its hybrid (adaptive) thinking mode — where the model generates extended chain-of-thought reasoning on harder problems — is the defining behavioral characteristic of this evaluation and is documented in detail below.

⚠️ Single-runner evaluation. The F16 GGUF (53.8 GB) exceeds the VRAM capacity of the evaluation hardware (NVIDIA RTX 4090, 24 GB). All behavioral data comes from the Q4_K_M quantized_llama_cpp runner only. The F16 artifact is documented for provenance at pbhappliedsystems/qwen3.6-27B-gguf-F16.

---

Model Description

This repository contains the 4-bit quantized (Q4_K_M) GGUF of Qwen/Qwen3.6-27B, a 27-billion parameter model from Alibaba Cloud's Qwen3 generation. Qwen3 introduces a hybrid thinking mode — the model can generate extended internal chain-of-thought reasoning (enclosed in <think> blocks) before producing its final response, with reasoning depth adapting to task complexity.

This adaptive behavior is the single most consequential characteristic for structured task evaluation, and its interaction with the quant_eval v7.21 harness is documented in detail in the Key Findings section below.

Key Characteristics

• Parameters: 27B
• Architecture: Qwen3 (hybrid thinking / non-thinking mode)
• Format: GGUF Q4_K_M
• File size: 16.5 GB
• SHA256: c863357b1b532a02c47ca363ab666dd623470a152a291dac6619ed7ce751d8c8
• Minimum VRAM (GPU inference): ~22 GB
• Recommended GPU tier: RTX 4090 24 GB · A10G 24 GB · A100 40 GB
• Context window: 32,768 tokens (check model config for extended context options)
• Inference speed (eval hardware): avg 1.938 sec/case on RTX 4090
• License: Apache 2.0

---

PBH Applied Systems Evaluation — quant_eval v7.21

Evaluation conducted by PBH Applied Systems, LLC using quant_eval v7.21 Run ID: 20260426_163540 · Fixtures: golden_oracle_fixtures_v7_21 (SHA256: 6d71a0b9147c...) · Seed: 42 Hardware: NVIDIA RTX 4090 · Runner: quantized_llama_cpp (Q4_K_M only) · Total rows: 42

Per-Family Pass Rates (Q4_K_M)

---

Key Findings

Finding 1: Adaptive Thinking Mode — The Defining Behavioral Characteristic

Qwen3 uses hybrid thinking mode: for simpler tasks, the model responds directly; for harder tasks, it generates an extended <think> block before the final response. This adaptive behavior is the primary driver of the json_multistep results.

Easy cases pass cleanly and quickly:

Both easy cases produce direct JSON output. All three gating signals pass (schema_ok=1, checks_consistent_ok=1, oracle_equiv_ok=1).

Medium and hard cases fail with all four signals simultaneously:

The all-four-signals failure pattern is the signature of a root-level extraction failure — when schema_ok=0, the downstream signals (checks_consistent_ok, stop_semantics_ok, oracle_equiv_ok) cannot be evaluated. The model generates a <think> reasoning block on the harder cases; when the extractor receives the full output including the think block, the JSON schema object is not found at the expected location or the content before the JSON causes the schema validator to fail.

The timing confirms this: ms_easy cases take ~5s while medium/hard cases take ~6.6–6.8s — the extra ~1.7s represents the thinking token generation overhead. At F16 precision this overhead would be substantially larger.

What this means for production deployment: Qwen3's thinking mode requires pipeline-level handling. The <think> block must be stripped before extraction, or the inference configuration must set /no_think or equivalent parameters to disable thinking mode when structured output is required. Without this, the model may produce correct reasoning internally while the extractor fails to locate the final answer. See the Usage section for configuration guidance.

Finding 2: toolcall_only — Closest Schema Vocabulary in the Evaluated Series

Every Qwen2.5 model in the series uses incorrect argument container keys. Qwen3.6-27B produces the most schema-accurate bare tool call of any model evaluated:

Qwen3.6-27B is the only model in the evaluated series to produce "tool_name" as the outer key without system-prompt schema enforcement. Argument value names ("a", "b") are also correct. The only error is "arguments" instead of "args" as the container key — a single field name away from a fully correct schema. Explicit key-name instructions in the system prompt should fully resolve this.

Finding 3: MCQ and Fuzz — Perfect at 27B

5/5 perfect MCQ at 0.16 sec/case average — single letter, no contamination, no A-bias. All 20 fuzz cases pass at bucket=10. These families benefit from the model's size while being fast enough that thinking mode does not appear to activate.

Finding 4: toolcall — Correct Arithmetic, EOS Contamination

Both toolcall cases pass stage-1 and produce the correct final answer with EOS tokens — the standard Qwen Q4_K_M series pattern:

Note that in the toolcall family (where a schema is provided in context), the model uses the correct "tool_name" and "args" keys — confirming that in-context schema examples fully resolve the vocabulary issue observed in toolcall_only. Strip <|im_end|> before downstream processing.

Finding 5: Stateful and Hybrid — Clean at 27B

Both stateful and mixed_brief_json families produce clean correct outputs with strippable EOS:

These short-context, two-turn tasks complete in under 0.75 seconds each — fast enough that thinking mode does not activate.

---

Signal-Level Diagnostics (Q4_K_M)

json_multistep

stateful_followup

toolcall_only

mixed_brief_json

---

Series Context

The json_multistep result of 0.400 is not a straightforward capability regression from the Qwen2.5 series. It is a pipeline compatibility finding: the evaluation harness was not configured to strip <think> blocks from Qwen3 responses on harder tasks. The two passing cases demonstrate the model is capable of correct structured multi-step planning output. The three failing cases are those where the model's adaptive thinking mode activates and the extraction layer fails — not where the model's reasoning is incorrect. With proper pipeline configuration (think-block stripping or /no_think mode), the json_multistep pass rate would be expected to improve.

---

Recommended Use Cases

✅ Deploy with Confidence (Q4_K_M)

• Stateful multi-turn agents — 1.000 at both turns, clean JSON state with strippable EOS at 0.685 sec/case.
• Hybrid brief + JSON responses — mixed_brief_json 1.000 in 0.705 sec.
• MCQ and single-choice extraction — 5/5 perfect at 0.16 sec/case.
• Structured JSON (single-step) — json and fuzz both bucket=10.000. All 20 fuzz cases pass.
• Scaffolded tool-calling — toolcall stage-1 passes; strip EOS from final answer.

✅ Deploy with Think-Block Stripping (Q4_K_M)

• Multi-step structured planning — ms_easy cases pass cleanly. Medium and hard cases require <think> block stripping or /no_think configuration before the extraction layer receives the model's output. See Usage section for implementation.

⚠️ Use with Guardrails (Q4_K_M)

• Bare tool-call dispatch — toolcall_only fails only on "arguments" vs "args". Provide the exact key name in system prompt; the model already produces correct "tool_name" and value names without enforcement.

---

Hardware Requirements

---

Usage

Installation

pip install llama-cpp-python huggingface_hub

For GPU acceleration (CUDA):

CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python --force-reinstall --no-cache-dir

Python — Disabling Thinking Mode for Structured Output

For structured output tasks where <think> block extraction is not desired, disable thinking mode via the chat template or system prompt:

from huggingface_hub import hf_hub_download
from llama_cpp import Llama
import re, json

model_path = hf_hub_download(
    repo_id="pbhappliedsystems/qwen3.6-27B-gguf-Q4-K-M",
    filename="qwen3.6-27B-gguf-Q4-K-M.gguf"
)

llm = Llama(
    model_path=model_path,
    n_ctx=8192,
    n_gpu_layers=-1,
    verbose=False,
)

# Option 1: Add /no_think to the user message to suppress thinking mode
response = llm.create_chat_completion(
    messages=[
        {
            "role": "system",
            "content": "You are a precise assistant. Return structured JSON only when asked."
        },
        {
            "role": "user",
            "content": "Return a JSON object with keys: summary, risk_level, action_items. /no_think"
        }
    ],
    temperature=0.15,
    max_tokens=1024,
)
print(response["choices"][0]["message"]["content"])

For post-processing that strips <think> blocks if present:

def strip_thinking(raw: str) -> str:
    """
    Strip <think>...</think> blocks from Qwen3 output.
    quant_eval v7.21: medium/hard json_multistep cases fail when think blocks
    are not stripped before extraction. Easy cases pass without stripping.
    """
    # Remove think blocks (handles both complete and truncated blocks)
    clean = re.sub(r'<think>.*?</think>', '', raw, flags=re.DOTALL).strip()
    # Also strip residual EOS tokens
    clean = re.sub(r'<\|im_end\|>', '', clean).strip()
    return clean

response = llm.create_chat_completion(
    messages=[{"role": "user", "content": "Your prompt here"}],
    temperature=0.15,
    max_tokens=2048,  # Allow space for thinking tokens
)
raw = response["choices"][0]["message"]["content"]
clean = strip_thinking(raw)
print(clean)

For tool-calling with schema enforcement and EOS stripping:

def call_tool(prompt: str) -> dict:
    """
    Tool dispatch for Qwen3.6-27B.
    quant_eval v7.21: model uses correct 'tool_name' key without enforcement.
    Only 'arguments' vs 'args' needs correction. EOS stripping required.
    """
    response = llm.create_chat_completion(
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a tool-calling assistant. Output ONLY a JSON object "
                    "using EXACTLY these keys: "
                    '{"tool_name": "<name>", "args": {"a": <n>, "b": <n>}}\n'
                    "Then on the next line output the numeric result. /no_think"
                )
            },
            {"role": "user", "content": prompt}
        ],
        temperature=0.0,
        max_tokens=128,
    )
    raw = response["choices"][0]["message"]["content"]
    clean = strip_thinking(raw)
    return {"clean": clean, "raw": raw}

result = call_tool("Use the add tool to compute 10 minus 4.")
print(result["clean"])

CLI — llama-cli

llama-cli \
  --model qwen3.6-27B-gguf-Q4-K-M.gguf \
  --chat-template qwen3 \
  --system-prompt "You are a precise assistant. Return structured outputs when requested." \
  --prompt "Return a JSON object with keys: summary, risk_level, action_items. /no_think" \
  --n-predict 1024 \
  --ctx-size 8192 \
  --n-gpu-layers -1 \
  --temp 0.15

For server deployment:

llama-server \
  --model qwen3.6-27B-gguf-Q4-K-M.gguf \
  --chat-template qwen3 \
  --ctx-size 8192 \
  --n-gpu-layers -1 \
  --port 8080 \
  --host 0.0.0.0

Query via the OpenAI-compatible API with think-block stripping:

from openai import OpenAI
import re

client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-required")

response = client.chat.completions.create(
    model="qwen3.6-27B-gguf-Q4-K-M",
    messages=[{"role": "user", "content": "Your prompt here /no_think"}],
    temperature=0.15,
)
raw = response.choices[0].message.content
clean = re.sub(r'<think>.*?</think>', '', raw, flags=re.DOTALL)
clean = re.sub(r'<\|im_end\|>', '', clean).strip()
print(clean)

---

Evaluation Artifacts

The full per-case evaluation CSV (comparison_results_v7_21_Qwen3.6_27B_20260426_163540.csv) and rollup.json are published in this repository for independent verification.

---

Artifact Provenance

Both artifacts were produced from Qwen/Qwen3.6-27B using a custom-built llama.cpp conversion and quantization pipeline developed by PBH Applied Systems.

---

Evaluation Methodology

quant_eval v7.21 — proprietary behavioral evaluation harness, PBH Applied Systems.

Fixture set: golden_oracle_fixtures_v7_21 (SHA256: 6d71a0b9147c079371b02a94f3c149eb78a6adc03dc16ff6833b964fbf4174f0)

Evaluation hardware: NVIDIA RTX 4090 · Evaluation date: April 26, 2026 · Seed: 42

---

🔬 About quant_eval & This Evaluation Series

quant_eval is a proprietary behavioral evaluation harness developed by PBH Applied Systems, LLC. It measures real agent-adjacent task performance across structured output, tool dispatch, multi-turn state retention, and multi-step planning — not perplexity or leaderboard proxies. Every model published under pbhappliedsystems has been independently evaluated using quant_eval before being recommended for any production role.

See it in action: Live AI Agent Demo → The demo runs production-style agent workflows powered by open-weight models selected through the quant_eval evaluation pipeline.

Need a deployment recommendation? Not sure which quantization level is right for your hardware, latency target, or agent type? → pbhappliedsystems.com

---

Evaluated and published by PBH Applied Systems, LLC · patrick@pbhappliedsystems.com

---

About PBH Applied Systems

PBH Applied Systems, LLC is an Oklahoma City–based applied machine learning and AI systems company specializing in production-grade model evaluation, quantization pipelines, agentic AI infrastructure, and scalable AI-driven application development.

Patrick Hill — Founder & Principal AI/ML Systems Architect · Author of Applied Machine Learning: Concepts, Tools, and Case Studies (required reading, UAT CSC 373)

Core Service Areas: LLM Optimization & Deployment · AI Evaluation Frameworks · Agentic AI Infrastructure · Scalable AI Application Development · ML Pipeline Design & Analytics · Model & Agent Cataloging

---

📞 Work With PBH Applied Systems

Qwen3.6-27B is the first Qwen3-series model in the evaluated series, and its adaptive thinking mode introduces a new class of pipeline configuration requirement that doesn't apply to any Qwen2.5 model. The json_multistep result is not a capability score — it's a deployment readiness finding: structured output pipelines targeting Qwen3 models need think-block stripping. The toolcall_only result tells a different story: Qwen3 has learned the tool_name key convention without being told, which is a genuine capability improvement over the entire Qwen2.5 series. Both findings are only visible through systematic evaluation.

👉 Book a Scoping Call · 👉 Request an Evaluation Report — from $2,500

Connect

---

License

This GGUF repository inherits the license of the base model: Apache 2.0 — Qwen/Qwen3.6-27B

The quant_eval evaluation methodology, fixture set, and scoring framework are proprietary to PBH Applied Systems, LLC and are not included in this repository.

---

GGUF conversion, quantization, and behavioral evaluation performed by PBH Applied Systems, LLC · quant_eval v7.21 · Run ID: 20260426_163540