---
license: apache-2.0
base_model: Qwen/Qwen3.8-27B
tags:
- grug
- reasoning
- token-efficient
- agentic
- tool-use
language:
- en
pipeline_tag: text-generation
library_name: transformers
---

# grug-27b-v1.1

**grug think small, answer big.**

normal model think like this:

> Okay, so the user wants me to carefully consider the best approach here. Let me
> think about this step by step. First, I should consider what data structure...

grug think like this:

> Sort numbers once; adjacent differences sufficient. Any diff < threshold -> True; else False. Edge len < 2 -> False.

same reasoning. same steps. same answer quality. grug throw grammar padding in
fire, keep brain meat. **answer come out normal english** — only inside voice is
grug.

new rock under grug: **Qwen3.8-27B**. old grug sit on Qwen3.6.

---

## grug hold quality

![quality](charts/01-quality.png)

## grug spend fewer token to think

![reasoning tokens](charts/02-tokens.png)

base model burn **559 token** thinking about HumanEval. grug burn **79.5**. same
kind of answer. on agent step base burn 108.5, grug burn **20**.

## grug pick right tool

![tool behaviour](charts/03-tools.png)

this is the big one. base model *can* call a tool — it call a valid tool 98.5% of
time. but base pick the **right** tool only **23.5%** of time. grug pick right
tool **97.1%**.

---

## numbers, all of them

medium reasoning effort, full benchmark sets (HumanEval 164, MBPP 100, GSM8K 200,
MATH-500 150, agentic 68, recovery 80, repetition 43). same harness, same
settings, every column.

| benchmark | Qwen3.8 base | grug v1 | **grug v1.1** |
|---|---|---|---|
| HumanEval | 98.2 | 87.8 | **94.5** |
| MBPP | 93.0 | 84.0 | **88.0** |
| GSM8K | 95.5 | 96.5 | **92.5** |
| MATH-500 | 78.0 | 64.7 | **72.7** |
| repetition stress | 76.7 | 81.4 | **88.4** |
| agentic — valid call | 98.5 | 100.0 | **100.0** |
| agentic — right tool | 23.5 | 95.6 | **97.1** |
| agentic — args valid | 98.5 | 100.0 | **100.0** |
| recovery — valid call | 100.0 | 100.0 | **100.0** |
| recovery — right tool | 32.5 | 90.0 | **82.5** |
| loops / unclosed think | — | — | **0 / 0** |

mean reasoning token per answer:

| benchmark | Qwen3.8 base | grug v1 | **grug v1.1** |
|---|---|---|---|
| HumanEval | 559.0 | 42.2 | **79.5** |
| MBPP | 656.4 | 34.6 | **301.2** |
| GSM8K | 204.5 | 76.0 | **64.9** |
| MATH-500 | 750.5 | 163.2 | **190.3** |
| agentic step | 108.5 | 29.4 | **20.0** |
| failure recovery | 78.2 | 33.4 | **24.0** |

## where grug lose

grug not hide bruise.

- **GSM8K 92.5** — base 95.5, old grug 96.5. grug lose 4 point on grade-school
  word problem. real loss, not noise.
- **recovery right-tool 82.5** — old grug 90.0. when tool fail and grug must pick
  next action, old grug pick better.
- **MBPP think 301 token** — old grug spend 34.6. grug think much longer here for
  +4 point. if you want cheapest possible token on MBPP, old grug cheaper.
- **base still better at raw code and math.** grug trade some point for 7-30x
  fewer think token. if token free and you want max score, use base.

## why called v1.1 and not v2

because gain over v1 is honest-small. new base rock, big win on tool choice and
repetition and MATH-500, but GSM8K step back. that is a **point-one**, not a two.
grug not put big number on small step.

## how grug get made

1. base **Qwen/Qwen3.8-27B**
2. SFT on 1M-row grug corpus (grug think, normal answer)
3. corrective LoRA (rank 32) on top, then **applied at 0.5 strength**

step 3 matter more than it sound. at full strength the adapter **overshoot** — it
push so hard toward tool behaviour that it break code:

| adapter strength | HumanEval | right tool |
|---|---|---|
| 1.0x | 84.8 | 88.2 |
| 0.7x | 90.9 | 94.1 |
| **0.5x (shipped)** | **94.5** | **97.1** |

less adapter = better code AND better tool pick, both at once. grug learn: more
push not always more better.

## three bug grug step on, so you not have to

first build of this model score fine on code and then **collapse on tool call —
20.6% valid call**. three rot in training data, none in model:

1. **every agent story end with "all done" speech.** all 19,129 agent row finish
   with assistant turn that make no tool call, just summary sentence. model learn
   "deep in trajectory = time to stop". so when judge ask for next tool call deep
   in hunt, model write essay. fix: re-cut same story so supervised turn IS a tool
   call.
2. **think was english, not grug.** function-word ratio 0.10-0.29 where v1 sit at
   0.01-0.09. that why first build burn 203 token on HumanEval.
3. **double think.** Qwen3.8 template fill own `<think>` block from
   `reasoning_content` field. old data hid think inside `content` as `<think>` tag.
   so every row train as `<think>\n\n</think>` **then second literal `<think>`** —
   empty think, then duplicate. 59% of supervised turn carried empty think. that
   why model sometimes shut reasoning instantly then reason inside answer.

## grug no loop

old 35b brother repeat word until cave fall down. grug train on BOTH world:
think-in-history trajectories AND stripped-history variants (old think gone,
exactly like real agent framework replay). then repetition stress gauntlet before
release: greedy long-form, deep think-stripped agent replay, multi-turn
continuation. **zero loop, 100% think closed.**

## use grug

```python
from transformers import AutoTokenizer, AutoModelForImageTextToText

tok = AutoTokenizer.from_pretrained("ProCreations/grug-27b-v1.1")
model = AutoModelForImageTextToText.from_pretrained(
    "ProCreations/grug-27b-v1.1", dtype="bfloat16", device_map="auto")

messages = [{"role": "user", "content": "write a function that flattens a nested list"}]
ids = tok.apply_chat_template(messages, add_generation_prompt=True,
                              reasoning_effort="medium", return_tensors="pt")
print(tok.decode(model.generate(ids.to(model.device), max_new_tokens=512)[0]))
```

**use `reasoning_effort="medium"`.** every number on this card is medium. grug
tuned there. low and xhigh work but are not what grug measured for release.

GGUF: [ProCreations/grug-27b-v1.1-gguf](https://huggingface.co/ProCreations/grug-27b-v1.1-gguf)
(with `mmproj` for vision).

## honest small print

- tool call use XML `<function=>` shape, same as grug v1.
- agentic and recovery probe sample at temperature 0.6. over three repeat run the
  right-tool number move about 1 point (stdev 0.9). numbers here from one
  complete error-free run each.
- every score on this card come from one open harness, same settings for base, v1
  and v1.1. no cherry-pick between runs.

apache-2.0, like the rock it stand on.