---
license: apache-2.0
language:
- en
- zh
- multilingual
tags:
- gguf
- qwen3
- qwen3.6
- reasoning
- coding
- coding-agent
- academic-writing
- uncensored
- rys
- lora
- iq4_nl
- bf16
base_model:
- jackasda211233/Qwen3.6-27B-AEON-RYS-SignalLatch-GGUF
- jackasda211233/Qwen3.6-27B-AEON-RYS-15-20-GGUF
- AEON-7/Qwen3.6-27B-AEON-Ultimate-Uncensored
---

# Qwen3.6 AEON RYS Agentic-Coder PatchCode GGUF

> **⚠️ Required runtime — read first.** This model **must be used with** the custom AEON ik-llama fork:
>
> **https://github.com/noonr48/qwen36-aeon-ik-llama**
>
> Use that fork with Jinja and DeepSeek reasoning formatting. This is **not** a stock `llama.cpp` or `vLLM` GGUF — the Qwen3.6 hybrid/recurrent (`qwen3_5`) architecture will fail to load on stock runtimes (`missing tensor blk.N.ssm_conv1d.weight`).

This is a merged fine-tuned GGUF upgrade candidate for the existing AEON RYS SignalLatch release. PatchCode adds an agentic-coder behaviour distil on top of SignalLatch: an action-first, verify-before-claim execution style for coding agents — minimal preamble, claims backed by an actual run, systematic diagnose→fix loops, and stable multi-turn tool use.

The main project here is the `IQ4_NL` GGUF: a practical small-form-factor release aimed at pulling as much useful coding-agent performance as possible out of the AEON RYS line without asking people to run a huge source-quality file. The `BF16` artifact is included for people who want to inspect, re-quantize, or continue work from the merged fine-tuned model.

PatchCode is distilled around an `Investigate → Act → Verify → Repair → Confirm` loop for coding agents. It promotes reading the real context first, acting with a concrete patch, **claiming nothing without a run**, repairing from evidence when a check fails, and confirming through validation.

Full testing/process write-up (quant bake-off):
`https://github.com/noonr48/qwen36-aeon-ik-llama/tree/main/docs` *(PatchCode bake-off record)*

Upgrade target:
- existing repo: `https://huggingface.co/jackasda211233/Qwen3.6-27B-AEON-RYS-SignalLatch-GGUF`
- existing file: `Qwen3.6-27B-AEON-RYS-SignalLatch-ckpt386-s010-IQ4_NL.gguf`

SignalLatch was already close to its BF16 source on the mixed probe snapshot. PatchCode keeps that small-form-factor Q4_NL path as the main deployment target and tests whether the agentic-coder distil improves practical coding-agent behaviour on top of it.

Practical eval: under a hardened 5-seed, same-condition bake-off (160k-token real-world multi-file build as the discriminator — single-shot coding gates saturate and were rejected), PatchCode `IQ4_NL` tied `BF16` within noise on build, long-context, discipline, and autonomous-loop convergence, at ~⅓ the size. See the eval snapshot below.

Release files:
- `Qwen3.6-27B-AEON-RYS-Agentic-Coder-PatchCode.IQ4_NL.gguf`
- `Qwen3.6-27B-AEON-RYS-Agentic-Coder-PatchCode.BF16.gguf`
- `qwen36-mtp-rys_delta.patch` (optional ik-llama MTP speed patch — **not** required to load/serve)

Use these as merged GGUF files. They are not intended to be loaded as live LoRAs at inference time.

The recommended practical deployment file is the `IQ4_NL` GGUF. The `BF16` GGUF is provided as a single source-quality exploration artifact, not the normal runtime target.

## Which file should I use?

Most people should start with:

`Qwen3.6-27B-AEON-RYS-Agentic-Coder-PatchCode.IQ4_NL.gguf`

That file is the intended release artifact. It is the continuation of the AEON RYS → SignalLatch → PatchCode line: keep the model small enough to be practical, then tune and test the stack until the small file gives the strongest useful behaviour we can get from it.

Use the single-file `BF16` GGUF only if you want to explore the merged model directly, make your own quant, compare conversion settings, or continue downstream work from the fine-tuned merge.

## At a glance

- base line: `Qwen3.6-27B-AEON-RYS-SignalLatch-ckpt386-s010` (SignalLatch)
- upstream AEON source: `AEON-7/Qwen3.6-27B-AEON-Ultimate-Uncensored`
- fine-tune: agentic-coder joint behaviour LoRA, checkpoint `3661`, one epoch
- merge strength: `0.5` (effective alpha/r = 1.0)
- main release artifact: `IQ4_NL` GGUF
- goal: maximum practical coding-agent behaviour in a small-form-factor GGUF
- recommended runtime file size: about `16.6 GB`
- companion source-quality artifact: single-file `BF16` GGUF, about `57.6 GB`
- intended runtime: `https://github.com/noonr48/qwen36-aeon-ik-llama`
- focus: practical coding-agent and tool-use behaviour
- public name: `PatchCode`
- behaviour loop: `Investigate → Act → Verify → Repair → Confirm`
- not a general chat benchmark claim
- not a stock `llama.cpp` / `vLLM` release

## What changed vs the SignalLatch release

The previous SignalLatch file is the base deployment target this is meant to improve:

`Qwen3.6-27B-AEON-RYS-SignalLatch-ckpt386-s010-IQ4_NL.gguf`

hosted at `https://huggingface.co/jackasda211233/Qwen3.6-27B-AEON-RYS-SignalLatch-GGUF`.

This upload merges an agentic-coder joint behaviour LoRA into that already-strong SignalLatch line before exporting to `IQ4_NL`. The goal is not to make a new general-purpose model family. The goal is to improve practical code-agent behaviour while preserving the practical small-file deployment path: following repo-edit instructions, handling tool-shaped context, finishing concrete patches, and avoiding repeated timeout-like failures.

Training summary:
- dataset: ~`58.5k` agentic-coding behaviour examples (coding execution traces + action-first style traces)
- training completion: checkpoint `3661`, one epoch
- LoRA rank: `32`
- LoRA alpha: `64`
- LoRA dropout: `0.05`
- target modules: all-linear, incl. the hybrid self-attn + linear-attn/SSM + MLP projections
- selected merge strength: `0.5`

## Recommended runtime

Use the custom AEON ik-llama fork:

`https://github.com/noonr48/qwen36-aeon-ik-llama`

Tested server shape (single GPU / single slot):

```bash
./build/bin/llama-server \
  -m /path/to/Qwen3.6-27B-AEON-RYS-Agentic-Coder-PatchCode.IQ4_NL.gguf \
  -c 65536 \
  -ngl 999 \
  -np 1 \
  -fa on \
  -sm none \
  --temp 0.7 \
  --jinja \
  --reasoning-format deepseek \
  --reasoning-budget 0
```

Long-context single-slot reference:

```bash
./build/bin/llama-server \
  -m /path/to/Qwen3.6-27B-AEON-RYS-Agentic-Coder-PatchCode.IQ4_NL.gguf \
  -c 163840 \
  -np 1 \
  -ngl 999 \
  -b 512 \
  -ub 128 \
  -fa on \
  -sm none \
  -ctk f16 \
  -ctv f16 \
  --temp 0.7 \
  --jinja \
  --reasoning-format deepseek \
  --reasoning-budget 0
```

Runtime notes:
- `<think>` is emitted as a separate `reasoning_content` field. Use `--reasoning-format deepseek` (or fold `reasoning_content` back into `<think>…</think>` in your harness) so tool-action parsing sees the action, not the chain-of-thought.
- use the merged GGUF as the deployment artifact
- prefer the `IQ4_NL` file for practical deployment
- use the single-file `BF16` GGUF as the source-quality merged artifact for downstream quantization or further work
- the tested profile uses flash attention; `-sm none` for one visible GPU, `-sm layer` for multi-GPU RAM-cache parallel lanes
- live LoRA loading is not the production path for this release
- the chat/runtime format should use Jinja plus DeepSeek reasoning formatting
- for one visible GPU use `-sm none`. `-sm graph` requires at least two visible GPU devices and will fail during model load if the process is pinned to one GPU.

## Practical eval snapshot — quant bake-off (5-seed, same-condition)

These numbers are from an internal practical coding-agent build matrix. This is not an academic benchmark. The discriminator is a 160k-token real-world multi-file build, scored multi-seed (single-shot coding gates saturate on this model family and were rejected).

| candidate | build (KritaLite) | long-context | discipline (style) | autonomy-loop | size |
|---|---:|---:|---:|---|---:|
| **PatchCode IQ4_NL (reasoning imatrix)** | `0.920` (±0.067) | `0.975` | `0.842` (±0.333) | 100% / 0% halluc | `16.6 G` |
| BF16 (control) | `0.867` | `0.942` | `0.931` | — | `57.6 G` |
| Q8_0 | `0.867` | `0.969` | `0.742` | 100% | `29 G` |
| mixed-recipe (promoted attn) | `0.907–0.933` | `0.935` | `0.69–0.90` | 100% | `20–24 G` |

Read:
- PatchCode `IQ4_NL` ties `BF16` within noise on build, long-context, discipline, and autonomous-loop convergence (8 held-out agentic tasks × 5 seeds: 100% convergence, 0% hallucinated-success, 0% stall for every quant).
- Near-lossless `Q8_0` and promoted-attention mixed recipes bought **no measurable edge** and cost 2–6× the size.
- This is a tentative long-term default, not a claim that the fine-tune is solved. Build has ±0.067–0.13 run-to-run variance and discipline ±0.3 on this suite; a 3-seed single-condition run shipped a *false* winner (a mixed recipe scored 0.933 once, never reproduced). Only 5+ seed same-condition head-to-heads + non-noise axes (size, recipe safety) reliably tiebreak. `IQ4_NL` wins on size + the plain-quant recipe (no promotion risk).

Autonomy-loop detail (`agent_loop_eval`, 8 held-out tasks × 5 seeds):

| quant | convergence | mean turns | recovery | halluc-success | stall |
|---|---:|---:|---:|---:|---:|
| PatchCode IQ4_NL | 100% (40/40) | 7.2 | 0.4 | 0% | 0% |
| Q8_0 | 100% (40/40) | 7.0 | 0.5 | 0% | 0% |
| mixed (c76) | 100% (40/40) | 6.6 | 0.4 | 0% | 0% |

Non-discriminating (0pp spread): the action-first, verify-before-claim discipline is preserved across all quants.

## IQ4_NL vs BF16 — head-to-head (5-seed, same-condition)

The released `IQ4_NL` is what most people should run. It was confirmed against the `BF16` control on the same harness, same seeds:

| axis | **PatchCode IQ4_NL** | BF16 (control) | read |
|---|---:|---:|---|
| build (KritaLite, 5-seed) | `0.920` (±0.067) | `0.867` | IQ4_NL nominally higher; gap `0.053` ≈ within the ±0.067 noise floor |
| long-context (4 tasks) | `0.975` | `0.942` | both near ceiling; IQ4_NL marginally higher |
| discipline (action-first style, 5-seed) | `0.842` (±0.333) | `0.931` | BF16 nominally higher; gap `0.089` ≪ ±0.333 spread → within noise |
| autonomous-loop convergence | `100%` (40/40), 0% halluc/stall | — | preserved |
| **size on disk** | **`16.6 G`** | `57.6 G` | **IQ4_NL is ~71% smaller** |

Read:
- On every behavioural axis the two are **tied within run-to-run noise** (build ±0.067–0.13, discipline ±0.3 on this suite). IQ4_NL is **not** a quality cliff below BF16 — it tracks or edges it within noise.
- Since behaviour is tied, the decision falls to non-noise axes, where IQ4_NL wins decisively: ~71% smaller, and the plain-quant recipe (no promotion risk).
- Use `BF16` only as the source-quality reference for re-quantization or downstream work, not as the runtime target.

## Why there is no Q8 release

A near-lossless `Q8_0` was built and tested head-to-head (5-seed, same-condition) against the released IQ4_NL. It showed **no advantage on any axis** and is ~2× the size, so it was **not released**.

| axis | Q8_0 (5-seed) | PatchCode IQ4_NL (released) | size |
|---|---:|---:|---:|
| build (KritaLite) | `0.867` (±0.133) | `0.920` (±0.067) | — |
| long-context | `0.969` | `0.975` | — |
| discipline (style) | `0.742` (±0.292) | `0.842` (±0.333) | — |
| autonomous-loop convergence | `100%` (40/40) | `100%` (40/40) | — |
| **size on disk** | `29 G` | `16.6 G` | Q8 is ~1.7× larger |

Read:
- Q8_0 is **at or below** the released IQ4_NL on build, long-context, and discipline (all within noise), with zero autonomy edge — and it costs ~75% more disk.
- Near-lossless precision buys nothing measurable on this suite (consistent with the finding that build here is **not** precision-limited — it's ceiling-limited and noisy). Releasing a 29 G file that ties a 16.6 G file would be wasted bytes.
- Attention-promotion mixed recipes were tested for the same reason and ruled out: promotion destroyed discipline for no build gain. Only `IQ4_NL` and `BF16` are released.

## Why no stock `llama.cpp` / `vLLM` file

We are not publishing a separate standard `llama.cpp` or `vLLM` model file as part of this release.

Why:
- the model needs the forked `ik-llama` runtime (Qwen3.6 hybrid/recurrent loader + graph-split long-context fixes + the custom mixed GGUF tensor layout)
- stock upstream runtimes hit real load failures on the `qwen3_5` triple-hybrid architecture
- because a special runtime was required either way, we did not think it was worth presenting a second public file as if plain `llama.cpp` / `vLLM` support were the point of the project

So the intended path is:
- use the fork: `https://github.com/noonr48/qwen36-aeon-ik-llama`
- use the released `IQ4_NL` GGUF (or the `BF16` source artifact)
- do not present these as stock `llama.cpp` / `vLLM` targets

## Optional MTP speed patch

The bundled `qwen36-mtp-rys_delta.patch` is an optional ik-llama MTP speculative-decoding **speed** patch.

- it is **not** required to load or serve the model — without it the server uses normal autoregressive decode
- in our tests the MTP path was technically interesting but **not** the better default (the non-MTP file was faster and cleaner in practical evals)
- use it only if you are testing MTP behaviour or want the experimental decode speed-up on the fork

## Hyper-focused project

This was a deliberately narrow project.

The target was not "best general chat model". The target was:
- strongest Q4-class English-first model we could get for coding, reasoning, and academic work
- derived from the AEON uncensored branch
- distilled/calibrated toward agentic coding execution and tool use

## License

Apache-2.0, inherited from `Qwen/Qwen3.6-27B` via the AEON-RYS abliteration. The base license permits derivative redistribution; attribute the base model and the AEON-RYS abliteration.

> Uncensored / abliterated: this derivative has had refusal/safety steering removed at the base. Use responsibly and in accordance with your local laws and platform policies.