release 0.7.0: reverse the rebase — back to the Qwen 3.6 35B-A3B MoE

Releases 0.2.0 through 0.6.5 shipped a dense Qwen 3.8 27B under this slug.
That rebase is reversed: the model is llmfan46/Qwen3.6-35B-A3B-uncensored-heretic
again — ~34.7B total / ~3B active, 40 layers (10 full-attention + 30 Gated
DeltaNet), 256 experts with 8 routed per token plus a shared expert, arch
qwen35moe. Display name Janus-27B -> Janus-35B, so the Hub slug names the model
correctly again.

- Blob: Janus-35B-A3B.Q4_K_M.gguf restored as a pointer-only commit
(21,233,608,512 B, sha256 b82f9f21…), byte-identical to upstream's Q4_K_M and
to what this repo shipped until da34705. HF still holds that LFS object for
this repo, so nothing is re-uploaded. No re-quantization, no MTP strip (this
quant has no NextN block), no template restamp.
- chat_template.jinja is deleted: it was a patch of the dense base's 3.8
template, and Qwen 3.6's own template — which the GGUF carries — has no
reasoning_effort, tool_call_format or preserve_reasoning to patch. The card's
llama.cpp sections were rewritten from what that template actually does,
including that string tool-call arguments are emitted as-is rather than
raising. check_chat_template.py and check.sh's check 8 go with it.
- Every measured figure taken on the dense 27B is deleted, not rescaled. Memory
totals are now derived from GGUF geometry and labelled as such (KV is
20,480 B/token — 0.625 GiB per 32K f16, ~5.0 GiB at the 262144 default); no
tok/s figures are published at all.
- verify_arch.py rewritten for the MoE claims; check 5's MTP grep, which would
have been permanently vacuous against 3.6 filenames, replaced by a check that
the Modelfile's FROM is the bundled GGUF *and* that it is tracked by git;
check.sh now reports "N of M checks passed, K skipped" instead of a green
"all passed" over a skipped check.
- moe-routing.svg restored verbatim, banner wordmark back to JANUS-35B, and
banner.png restored byte-for-byte to avoid re-rasterization drift.
- Fixed while auditing: front-matter claimed library_name transformers and
pipeline_tag image-text-to-text on a GGUF-only repo (now gguf /
text-generation); .gitignore's !Janus-27B.*.gguf whitelist would have silently
dropped the new blob; the undated "Ollama 0.24+" floor is replaced by the
versions actually checked in source.

Not done here: no live run of any kind — live_check.sh, a tool-call round-trip,
verify_arch.py and every memory measurement need the 21 GB blob on disk. The
card says so wherever it matters.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.gitignore

@@ -7,13 +7,13 @@ venv/
 
 # Local model weights. We don't redistribute the upstream Qwen GGUFs
 # here — scripts/build.sh fetches one from
-# llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF
-# locally. The single Janus-27B.*.gguf we DO ship backs the HF/Ollama
+# llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF
+# locally. The single Janus-35B-A3B.*.gguf we DO ship backs the HF/Ollama
 # "Use this model" widget (ollama run hf.co/FoolDev/Janus-35B-HERETIC).
 *.gguf
-!Janus-27B.*.gguf
+!Janus-35B-A3B.*.gguf
 # scripts/strip_mtp.py + build.sh intermediates — local only, never tracked.
-Janus-27B.*.stripped.gguf
+Janus-35B-A3B.*.stripped.gguf
 *.safetensors
 *.bin
 

CHANGELOG.md

@@ -8,6 +8,106 @@ track the **tooling and documentation**, not the underlying base model.
 
 ## [Unreleased]
 
+## [0.7.0] — 2026-09-18
+
+### Changed (reversal → Qwen 3.6 35B-A3B MoE)
+
+- **This repo is the 35B-A3B MoE again.** Releases 0.2.0 through 0.6.5 carried a
+  dense Qwen 3.8 27B under the `Janus-35B-HERETIC` slug; that rebase is reversed.
+  The model is `llmfan46/Qwen3.6-35B-A3B-uncensored-heretic` — ~34.7B parameters
+  total, ~3B active per token, 40 layers (10 full-attention + 30 Gated DeltaNet),
+  256 experts with 8 routed per token plus a shared expert, hidden 2048, 16 Q /
+  2 KV heads at head_dim 256, vocab 248,320, 262,144 native context. Display name
+  `Janus-27B` → **`Janus-35B`**, and the Hub slug now matches the model again.
+- **The bundled blob is upstream's own Q4_K_M, byte-for-byte.**
+  `Janus-35B-A3B.Q4_K_M.gguf`, 21,233,608,512 bytes, sha256
+  `b82f9f2155eb9c07139d48cc3a37880cf9d0edcca345ef6ad829b62941ccbb82` — identical to
+  `llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF`'s Q4_K_M and to the blob this
+  repo shipped until `da34705`. HF still holds that LFS object for this repo (checked
+  against the LFS batch API), so it was restored as a pointer-only commit: no
+  re-quantization, no re-upload. `Janus-27B.Q4_K_M.gguf` is no longer published and
+  remains in git history.
+- **The MTP narrative inverts.** 0.2.0 made the MTP strip "a required build step, not
+  a safety net" because the dense 3.8 base was MTP-preserved. This quant has no NextN
+  block at all — `block_count` 40, `blk.0`…`blk.39`, 733 tensors, no `nextn` key, read
+  from the published file's header by range request — so `scripts/strip_mtp.py` is a
+  defensive no-op here and stays in the build path only for anyone pointing it at
+  llmfan46's separate `…-Native-MTP-Preserved-GGUF` variant (whose Q4_K_M has
+  `block_count` 41 with a NextN block at index 40, not 64).
+- **The GGUF arch stamp widens back to `qwen35moe`** — llama.cpp's MoE entry
+  (`src/models/qwen35moe.cpp`, `case 40: LLM_TYPE_35B_A3B`), handled through Ollama's
+  llama.cpp compat shim at v0.33.3, v0.34.0 and v0.34.2 (source, 2026-09-18). 0.2.0's
+  claim that `qwen35moe` "no longer appears in any live file" is superseded.
+- **`moe-routing.svg` is back**, restored verbatim from `7ed28e6`: the 16×16 grid of
+  256 expert dots with 8 lit at a time is literally this model's routing again. The
+  banner wordmark is `JANUS-35B` with the `Qwen 3.6 Heretic · MoE 35B/3B · Fable 5`
+  subtitle, and `banner.png` is the pre-rebase raster byte-for-byte, so there is no
+  re-rasterization drift.
+
+### Removed (`chat_template.jinja`, and the behaviour that lived in it)
+
+- **This repo no longer ships a Jinja chat template.** The file was created *after*
+  the rebase as a patch of the dense base's own `qwen3.8-safe-v3.1` template; Qwen 3.6's
+  template has no `reasoning_effort`, no `tool_call_format` and no `preserve_reasoning`
+  to patch, so there was nothing to carry across. The GGUF keeps the base model's own
+  embedded template (11,793 chars), which is what llama.cpp, LM Studio and KoboldCpp
+  now render. `scripts/verify_arch.py` gates its embedded-template comparison on the
+  repo file existing, so that check correctly skips.
+- **Gone with it on the llama.cpp path:** the `reasoning_effort` tier table (Ollama
+  still has it, via the Go template and Ollama's think levels), the `tool_call_format`
+  JSON opt-in, and the "conflicting `preserve_thinking` / `preserve_reasoning` raises
+  HTTP 500" failure mode — Qwen 3.6's template has no such check and cannot raise that
+  way. What is unchanged: the XML tool-call wire format (its instruction literal is
+  byte-identical to 3.8's) and reasoning replay, which is that template's own default
+  (`preserve_thinking` defaults true, reading `message.reasoning_content`).
+- **One behaviour gets quieter, and worse.** Handed `function.arguments` as a JSON
+  string, the 3.8 template raised; Qwen 3.6's emits the string as-is inside
+  `<function=…>` with an upstream comment telling you to normalise first. llama-server,
+  KoboldCpp and LM Studio all convert to a mapping before rendering, so in practice the
+  XML form still renders — but a loader that passes the string through now produces a
+  malformed prompt instead of an error.
+- `scripts/check_chat_template.py` and check.sh's check 8 are removed with the file.
+
+### Changed (every measured number on the card)
+
+- **All memory and throughput figures measured on the dense 27B are deleted, not
+  rescaled.** The geometry moves in both directions — weights 16.1 → 19.78 GiB, but KV
+  from 16 full-attention layers × 4 KV heads to 10 × 2 — so the KV cache is 20,480
+  B/token at f16 (0.625 GiB per 32K, ~5.0 GiB at the 262144 default), under a third of
+  the dense figure, and the derived total at the default window is ~25 GiB f16 /
+  ~22.4 GiB q8_0 against the 27B's measured ~34/~26. Those totals are **derived from
+  GGUF geometry and explicitly labelled as such**; the recurrent state and compute
+  buffer are not derivable and are not yet measured on this blob.
+- **No tok/s figures are published at all.** A 35B-A3B MoE touches ~3B parameters per
+  token instead of 27B; rescaling the 4.97 tok/s CPU measurement or the Strix Halo
+  offload series would be invention. The iGPU *mechanism* (mmap off, GTT is system RAM,
+  `LLAMA_ARG_NO_HOST=1`) is loader-side and is kept.
+- The native context window is unchanged at 262,144 / 1,010,000 with YaRN, so every
+  window figure and the `--rope-scale 3.853` recipe survive verbatim.
+
+### Fixed (found while auditing the card, unrelated to the swap)
+
+- **Front-matter routed the repo wrongly.** `library_name: transformers` and
+  `pipeline_tag: image-text-to-text` were inherited verbatim from `64b629a` and never
+  revisited, while the repo has never contained a `config.json`, tokenizer or
+  safetensors — so HF offered a Transformers snippet that cannot resolve. Now
+  `library_name: gguf` and `pipeline_tag: text-generation`, with `qwen36`, `moe` and
+  `ollama` added to the tags.
+- **`.gitignore` would have silently dropped the new blob**: the whitelist was
+  `!Janus-27B.*.gguf` against a `*.gguf` rule. Now `!Janus-35B-A3B.*.gguf`, verified
+  with `git check-ignore`.
+- **The loader table's `Ollama 0.24+` floor** was the card's only undated, unsourced
+  version claim and predates the arch change. Replaced with the three versions actually
+  checked in source (0.33.3, 0.34.0, 0.34.2).
+
+### Not done in this release
+
+- No live run. `scripts/live_check.sh`, a tool-call round-trip, `verify_arch.py` and
+  any memory measurement all need the 21 GB blob on disk; none has been executed
+  against this model since the reversal, and the card says so wherever it matters.
+- The local `janus` Ollama tag on the maintainer's host still holds the dense 27B
+  bundle until it is rebuilt.
+
 ## [0.6.5] — 2026-09-17
 
 ### Documentation (upstream claims re-checked against Ollama 0.34.2)

CITATION.cff

@@ -1,7 +1,7 @@
 cff-version: 1.2.0
-version: 0.6.5
-date-released: "2026-09-17"
-title: "Janus-27B: A Dense Distillation Wrapper for llmfan46's Qwen 3.8 27B Ultra-Uncensored Heretic"
+version: 0.7.0
+date-released: "2026-09-18"
+title: "Janus-35B: A Sparse Distillation Wrapper for llmfan46's Qwen 3.6 35B-A3B Uncensored Heretic"
 message: "If you use this model card or its accompanying files, please cite as below."
 type: software
 authors:
@@ -10,22 +10,26 @@ authors:
 repository-code: "https://huggingface.co/FoolDev/Janus-35B-HERETIC"
 url: "https://huggingface.co/FoolDev/Janus-35B-HERETIC"
 abstract: >-
-  Janus-27B is a personal repackaging of llmfan46's Ultra-Uncensored
-  Heretic abliteration (MPOA-style, MTP-preserved) of the dense Qwen 3.8
-  27B base (27B parameters, all active, 64 layers, gated DeltaNet linear
-  attention with full attention every 4th layer) with Claude Fable 5 in
-  the reasoning teacher slot. The repository ships an Ollama Modelfile,
-  the HF Ollama-bridge files (template / system / params), sampling
-  defaults, and a bundled Q4_K_M GGUF (~17 GB, MTP / NextN block stripped
-  so stock llama.cpp and Ollama can load it) so the HF "Use this model"
-  widget surfaces a one-liner Ollama snippet. Other quants and the Heretic
-  safetensors (llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved),
-  which keep the MTP head for vLLM / SGLang, are pulled from upstream on
-  demand rather than redistributed.
+  Janus-35B is a personal repackaging of llmfan46's uncensored Heretic
+  abliteration of the Qwen 3.6 35B-A3B mixture-of-experts base (~34.7B
+  parameters total, ~3B active per token, 40 layers, 256 experts with 8
+  routed per token plus a shared expert, gated DeltaNet linear attention
+  with full attention every 4th layer) with Claude Fable 5 in the
+  reasoning teacher slot. The repository ships an Ollama Modelfile, the HF
+  Ollama-bridge files (template / system / params), sampling defaults, and
+  a bundled Q4_K_M GGUF (21.23 GB) so the HF "Use this model" widget
+  surfaces a one-liner Ollama snippet. That GGUF is upstream's own Q4_K_M
+  byte-for-byte: it carries no MTP / NextN block to strip and keeps the
+  base model's own embedded chat template. Other quants, the BF16 vision
+  projector, and the Heretic safetensors
+  (llmfan46/Qwen3.6-35B-A3B-uncensored-heretic), which keep the MTP layer
+  for vLLM / SGLang, are pulled from upstream on demand rather than
+  redistributed.
 keywords:
   - qwen
-  - qwen3.8
-  - dense
+  - qwen3.6
+  - moe
+  - mixture-of-experts
   - abliteration
   - distillation
   - reasoning
@@ -35,17 +39,17 @@ keywords:
 license: Apache-2.0
 references:
   - type: software
-    title: "Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved (immediate base)"
+    title: "Qwen3.6-35B-A3B-uncensored-heretic (immediate base)"
     authors:
       - name: llmfan46
-    url: "https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved"
+    url: "https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic"
   - type: software
-    title: "Qwen3.8-27B (upstream base)"
+    title: "Qwen3.6-35B-A3B (upstream base)"
     authors:
       - name: Alibaba Qwen Team
-    url: "https://huggingface.co/Qwen/Qwen3.8-27B"
+    url: "https://huggingface.co/Qwen/Qwen3.6-35B-A3B"
   - type: software
-    title: "Thanatos-27B (sibling, ARA abliteration)"
+    title: "Thanatos-27B (sibling, dense Qwen 3.8 ARA abliteration)"
     authors:
       - name: FoolDev
     url: "https://huggingface.co/FoolDev/Thanatos-27B-HERETIC"

Janus-27B.Q4_K_M.gguf → Janus-35B-A3B.Q4_K_M.gguf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:07e6aa5317eb0309863da78d3ae387362239fde220d3d5a081e41723814a6d85
-size 17314193760
+oid sha256:b82f9f2155eb9c07139d48cc3a37880cf9d0edcca345ef6ad829b62941ccbb82
+size 21233608512

Makefile

@@ -1,4 +1,4 @@
-# Janus-27B convenience Makefile.
+# Janus-35B convenience Makefile.
 #
 # All work is delegated to scripts/* — this file just gives common
 # operations short, discoverable names.
@@ -11,9 +11,9 @@
 #   MODEL     model tag for smoke     (default: $(TAG))
 #
 # Examples:
-#   make build                          # Q4_K_M from the Heretic GGUF repo (MTP-stripped on the way in)
+#   make build                          # Q4_K_M from the Heretic GGUF repo (the MTP strip no-ops on these quants)
 #   make build QUANT=Q5_K_M             # higher-quality quant
-#   make build GGUF_PATH=~/models/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-Q4_K_M.gguf
+#   make build GGUF_PATH=~/models/Qwen3.6-35B-A3B-uncensored-heretic-Q4_K_M.gguf
 #   make load-bundle                    # this repo's bundled GGUF -> local Ollama tag (smudge LFS if needed)
 #   make smoke
 #   make check
@@ -39,7 +39,7 @@ ifdef GGUF_PATH
 	@echo "  GGUF_PATH=$(GGUF_PATH)"
 endif
 
-build:  ## Download a Heretic GGUF, strip the MTP block, and run 'ollama create'.
+build:  ## Download a Heretic GGUF, run the MTP strip (a no-op on these quants), and run 'ollama create'.
 	GGUF_PATH=$(GGUF_PATH) TAG=$(TAG) ./scripts/build.sh $(QUANT)
 
 load-bundle:  ## Load THIS repo's bundled GGUF into a local Ollama tag (smudge LFS + ollama create).
@@ -60,7 +60,7 @@ bench:  ## Measure tok/s using Ollama's eval timing (3 prompts).
 mmproj:  ## Fetch the vision projector for llama.cpp (Ollama vision is broken upstream).
 	./scripts/fetch_vision.sh $(PRECISION)
 
-check:  ## Lint, bridge-file sync, chat-template render checks and the Go-template guard; block the unstripped-MTP footgun.
+check:  ## Lint, bridge-file sync, the Go-template guard, and that the Modelfile's FROM is the GGUF this repo ships.
 	./scripts/check.sh
 
 live-check:  ## Live end-to-end checks in an isolated Ollama (GGUF=path or GGUF_PATH=path; tens of minutes on CPU).
@@ -74,6 +74,6 @@ hooks:  ## Install scripts/check.sh as the git pre-commit hook.
 
 clean:  ## Remove local GGUF copies and ephemeral caches in this repo.
 	@echo "[*] removing local GGUFs and ephemeral caches in $$PWD"
-	@rm -f ./Qwen3.8-27B-Ultra-Uncensored-*.gguf ./mmproj-*.gguf ./*.stripped.gguf
+	@rm -f ./Qwen3.6-35B-A3B-uncensored-*.gguf ./mmproj-*.gguf ./*.stripped.gguf
 	@rm -rf ./.cache __pycache__ examples/__pycache__
 	@echo "[+] clean"

Modelfile

@@ -1,23 +1,25 @@
-FROM ./Janus-27B.Q4_K_M.gguf
+FROM ./Janus-35B-A3B.Q4_K_M.gguf
 
-# The bundled GGUF is MTP-stripped. The base
-# (llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) keeps its
-# MTP head, so the source quant carries a NextN block at index 64 that stock
-# llama.cpp and Ollama cannot load — scripts/strip_mtp.py drops it and takes
-# block_count back to 64. That strip is a required build step here, not a safety
-# net. If you want the MTP head, run the upstream safetensors under vLLM/SGLang,
-# or pull the unstripped GGUF from
-# llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF.
+# The bundled GGUF carries no MTP / NextN block. The base
+# (llmfan46/Qwen3.6-35B-A3B-uncensored-heretic) publishes its GGUFs already
+# MTP-clean — blk.0…blk.39 only, block_count 40, no nextn_predict_layers key
+# (read from the bundled file's own header, 2026-09-18) — so scripts/strip_mtp.py
+# is a defensive no-op here, not a required build step. The separate
+# llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-Native-MTP-Preserved-GGUF variant
+# does keep the MTP head (its Q4_K_M has block_count 41, NextN block at index
+# 40) and would need the strip; this repo does not ship it. If you want the MTP
+# head, run the upstream safetensors under vLLM/SGLang, or take that variant's
+# GGUF.
 
-# Chat template — Qwen 3.8 ChatML in Ollama Go-template form, with the
+# Chat template — Qwen 3.6 ChatML in Ollama Go-template form, with the
 # tool-calling blocks Ollama's capability detector looks for. Without a
 # TEMPLATE that references .Tools and .ToolCalls, an Ollama that uses this
 # template anyway (OLLAMA_GO_TEMPLATE=1 - per Ollama's source, not tested live -
 # or one that predates the template comparison described below) rejects any
 # request carrying a `tools` array with `<model> does not support tools`;
-# Ollama 0.33.3 would instead switch to the GGUF's embedded template. Same template as the sibling
-# (FoolDev/Thanatos-27B-HERETIC) — both are dense Qwen 3.8 27B and share the
-# same chat format.
+# Ollama 0.33.3 would instead switch to the GGUF's embedded template. Same template as the dense
+# 27B sibling (FoolDev/Thanatos-27B-HERETIC) — the ChatML wire format is
+# identical across Qwen 3.6 and 3.8.
 #
 # Thinking IS replayed across turns: every assistant message that carries
 # reasoning renders <think>...</think>, earlier turns included, where Qwen's
@@ -25,9 +27,10 @@ FROM ./Janus-27B.Q4_K_M.gguf
 # The client must send the reasoning back - per Ollama's source, /api/chat reads
 # each assistant message's `thinking` field and /v1/chat/completions reads only
 # `reasoning` (it drops `reasoning_content` and `thinking` silently). Every
-# retained trace stays in the prompt - measured at 181 prompt tokens without /
-# 464 with on a 3-message conversation - and prefill grows to match, which is
-# the slow part on a CPU-only host.
+# retained trace stays in the prompt and prefill grows to match, which is the
+# slow part on a CPU-only host. The prompt-token counts that used to sit here
+# were measured on the dense 27B this repo shipped in the interim; they are
+# removed rather than carried over, pending re-measurement.
 #
 # The thinking block in the assistant branch is load-bearing for a second
 # reason. Ollama infers a Go template's "thinking" capability from a `.Thinking` field inside
@@ -35,7 +38,8 @@ FROM ./Janus-27B.Q4_K_M.gguf
 # the selection code is unchanged through 0.34.2, checked in source)
 # compare that capability list with the GGUF's embedded Jinja template at load
 # time, switching to the embedded template if that one advertises more. Delete
-# the block and Ollama switches: in one test on this model a single tool call then came back twice
+# the block and Ollama switches: in one test on the dense 27B this repo shipped
+# in the interim a single tool call then came back twice
 # (a separate raw generation showed the model drafting the call inside <think>
 # first; that the parser matched such a draft is inferred, not confirmed). Per Ollama's source (not tested live), a
 # setup forcing this template (OLLAMA_GO_TEMPLATE=1) would also reject thinking
@@ -45,9 +49,12 @@ FROM ./Janus-27B.Q4_K_M.gguf
 # $lastUserIdx loop at the top of the template is kept for it; do not delete the
 # block.
 #
-# Reasoning effort: the block at the top of the template adds the instruction
-# chat_template.jinja adds, keyed on Ollama's think level ($.ThinkLevel), not the
-# request value. Ollama folds `reasoning_effort` into four levels first:
+# Reasoning effort: the block at the top of the template injects an effort
+# instruction keyed on Ollama's think level ($.ThinkLevel), not the request
+# value. It is Ollama-only now — this repo no longer ships chat_template.jinja,
+# and the Qwen 3.6 base's own embedded template, which governs the llama.cpp
+# path from here on, has no reasoning_effort handling at all.
+# Ollama folds `reasoning_effort` into four levels first:
 # high/xhigh/max/ultra -> high or max (xhigh line), low/minimal -> low (low
 # line), medium and unset -> medium (no line), none -> thinking off. The
 # outer `if $.ThinkLevel` keeps the template rendering on Ollama builds that
@@ -150,47 +157,49 @@ Behavior rules:
 
 # Hardware notes
 # --------------
-# This Q4_K_M is ~17 GB on disk. Measured on Ollama 0.33.3, CPU backend
-# (2026-09-14; llama.cpp's own log lines):
-#   weights               16.1 GiB (6.3 GiB mapped + 9.8 GiB repacked for CPU)
-#   recurrent state       0.15 GiB (48 linear-attention layers, fixed size)
-#   KV cache              16 of 64 layers, 4 KV heads x 256 dims: exactly
-#                         2 GiB per 32K tokens at f16 (Ollama's default),
-#                         1.06 GiB per 32K at q8_0 -> at 262144: 16 GiB f16,
-#                         8.5 GiB q8_0; at 1010000: 61.6 / 32.7 GiB
-#   compute buffer        0.3-0.8 GiB measured at 8K-65K with flash attention
-#                         (Ollama's default is auto, which enabled it); ~1-1.5 GiB
-#                         projected at 262144 by llama.cpp's llama-fit-params.
-#                         Forcing flash attention off grows it to ~25 GiB there.
-#   total                 ~34 GiB at the 262144 default with the f16 cache,
-#                         ~26 GiB with OLLAMA_KV_CACHE_TYPE=q8_0 and
-#                         OLLAMA_FLASH_ATTENTION=1; at num_ctx 65536 ~21 GiB f16 /
-#                         19.2 GiB q8_0 (measured). 1010000 needs ~80 / ~50 GiB.
+# This Q4_K_M is 21,233,608,512 bytes on disk — 21.23 GB decimal, 19.78 GiB.
+# No runtime memory figures for this build yet: the ones that used to sit here
+# were measured on the dense 27B this repo shipped in the interim and do not
+# transfer to a 35B-A3B MoE, so they are removed rather than rescaled. What
+# follows is derived from the bundled GGUF's own header (read 2026-09-18),
+# not measured on a running model:
+#   weights               19.78 GiB on disk
+#   KV cache              only 10 of the 40 layers are full-attention (indices
+#                         3, 7, ... 39); 10 layers x 2 KV heads x (256 + 256)
+#                         dims x 2 bytes = 20,480 B/token, i.e. 0.625 GiB per 32K
+#                         at f16 (Ollama's default) and about 0.33 GiB per 32K at
+#                         q8_0 -> ~5.0 GiB at the 262144 default with f16,
+#                         ~2.66 GiB with q8_0
+#   recurrent state       fixed-size, for the 30 Gated-DeltaNet layers; not
+#                         measured on this build
+#   compute buffer        not measured on this build
+#   floor                 ~24.8 GiB at the 262144 default with the f16 cache
+#                         (19.78 weights + 5.0 KV), ~22.4 GiB with
+#                         OLLAMA_KV_CACHE_TYPE=q8_0 — a floor, before the
+#                         recurrent state and compute buffer.
 #                         No YaRN rope-scaling is baked in this GGUF, so output
 #                         past ~262K degrades; treat 1.01M as an advertised
 #                         ceiling.
 #
-# This is a dense 27B across 64 layers — every parameter runs on every token.
-# There is no routing to offload selectively and no active-parameter discount:
-# budget for the whole ~16 GiB of weights in the hot path.
+# This is a 35B-A3B MoE across 40 layers: 256 experts, 8 routed per token plus
+# one shared expert, ~34.7B parameters total and ~3B active per token (derived
+# from the same header). The active count cuts compute per token, not the memory
+# floor — every expert has to be resident, so budget for the whole 19.78 GiB of
+# weights.
 #
-# Working configurations (rows assume the 262144 default: ~34 GiB with the f16
-# cache, ~26 GiB with q8_0; the 1.01M ceiling fits only 64 GB+ hosts with q8_0):
+# Working configurations (rows assume the 262144 default: a ~24.8 GiB floor with
+# the f16 cache, ~22.4 GiB with q8_0):
 #   ✓ Single H100 80GB / A100 80GB              — full GPU offload
 #   ✓ RTX 5090 32GB / RTX 4090 24GB + 32GB RAM  — partial offload
 #   ✓ Mac Studio M2/M3 Ultra 64GB+              — unified memory
-#   ✓ Linux box with 48GB+ RAM (CPU-only)       — CPU inference (~34 GiB at the default)
+#   ✓ Linux box with 48GB+ RAM (CPU-only)       — CPU inference
 #   ⚠ 32GB hosts (e.g. ASUS ROG Flow Z13)       — set OLLAMA_KV_CACHE_TYPE=q8_0
-#                                                 (~26 GiB, tight) or lower num_ctx
-#                                                 (65536 is ~19-21 GiB)
+#                                                 or lower num_ctx
 #
-# Throughput, measured 2026-09-11 on CPU only (Ryzen AI Max+ 395, Ollama 0.33.3
-# CPU backend, OLLAMA_FLASH_ATTENTION=1, OLLAMA_KV_CACHE_TYPE=q8_0, bench.sh's
-# num_ctx 4096 / num_batch 256): Q4_K_M -> 4.97 tok/s aggregate (1802 tokens /
-# 362.3 s; 5.18 / 5.03 / 4.96 short/medium/long). Partial GPU offload (Vulkan,
-# LLAMA_ARG_NO_HOST=1, num_ctx 4096): 5.7 tok/s at num_gpu 24 - see the README.
-# The measurements that used to sit here were taken on this repo's previous base
-# and do not transfer to a dense 27B, so they are removed rather than restated.
+# Throughput: no tok/s figures for this build yet. The measurements that used to
+# sit here were taken on the dense 27B and do not transfer to an MoE with ~3B
+# active parameters per token, so they are removed rather than rescaled —
+# pending re-measurement.
 #
 # To run on a 32 GB unified-memory laptop, override these in your local
 # Modelfile copy (or via `/set parameter` in the interactive `ollama run` REPL):
@@ -198,4 +207,4 @@ Behavior rules:
 #   PARAMETER num_batch 256
 #
 # If you have ≥48 GB RAM but want partial GPU offload, set:
-#   PARAMETER num_gpu 40    # offload most layers (model has 64)
+#   PARAMETER num_gpu 24    # offload most layers (model has 40)

README.md

@@ -1,7 +1,7 @@
 ---
 license: apache-2.0
 base_model:
-  - llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved
+  - llmfan46/Qwen3.6-35B-A3B-uncensored-heretic
 base_model_relation: quantized
 datasets:
   - Crownelius/Creative_Writing_ShareGPT_Enhanced
@@ -34,41 +34,44 @@ language:
   - fi
   - el
 tags:
-  - qwen38
+  - qwen36
+  - moe
   - conversational
   - multimodal
   - agent
   - gguf
+  - ollama
   - heretic
   - uncensored
   - reasoning
   - distillation
-library_name: transformers
-pipeline_tag: image-text-to-text
+library_name: gguf
+pipeline_tag: text-generation
 ---
 
-<img src="https://huggingface.co/FoolDev/Janus-35B-HERETIC/resolve/main/banner.svg" alt="Janus-27B banner" width="100%" />
+<img src="https://huggingface.co/FoolDev/Janus-35B-HERETIC/resolve/main/banner.svg" alt="Janus-35B banner" width="100%" />
 
 [![License](https://img.shields.io/badge/License-Apache_2.0-7aa2f7?style=flat&labelColor=1a1b26)](https://opensource.org/licenses/Apache-2.0)
-[![Base Model](https://img.shields.io/badge/Base-Heretic-bb9af7?style=flat&labelColor=1a1b26)](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved)
-[![Architecture](https://img.shields.io/badge/Arch-Dense_27B-ff9e64?style=flat&labelColor=1a1b26)](#architecture)
+[![Base Model](https://img.shields.io/badge/Base-Heretic-bb9af7?style=flat&labelColor=1a1b26)](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic)
+[![Architecture](https://img.shields.io/badge/Arch-MoE_35B/3B_active-ff9e64?style=flat&labelColor=1a1b26)](#architecture)
 [![Quant](https://img.shields.io/badge/GGUF-Q4__K__M-9ece6a?style=flat&labelColor=1a1b26)](#whats-here)
 [![Sibling](https://img.shields.io/badge/Sibling-Thanatos--27B-7dcfff?style=flat&labelColor=1a1b26)](https://huggingface.co/FoolDev/Thanatos-27B-HERETIC)
 
-<a href="https://buymeacoffee.com/cardoffoolm"><img src="https://huggingface.co/FoolDev/Janus-35B-HERETIC/resolve/main/bmc-banner.svg" alt="Buy me a coffee — support Janus-27B" width="320" /></a>
+<a href="https://buymeacoffee.com/cardoffoolm"><img src="https://huggingface.co/FoolDev/Janus-35B-HERETIC/resolve/main/bmc-banner.svg" alt="Buy me a coffee — support Janus-35B" width="320" /></a>
 
-# Janus-27B
+# Janus-35B
 
-> **Flagship Reasoning. Dense 27B. Uncensored.**
-> *llmfan46's Heretic abliteration of Qwen 3.8 27B, repackaged with Claude Fable 5 in the teacher slot.*
+> **Flagship Reasoning. Sparse Footprint. Uncensored.**
+> *llmfan46's Heretic abliteration of Qwen 3.6 35B-A3B, repackaged with Claude Fable 5 in the teacher slot.*
 
-**`Architecture:`** `Qwen 3.8 27B (dense)` | **`Parameters:`** `27B (all active)` | **`Context:`** `262,144 native / 1,010,000 extensible` | **`Base:`** `Heretic (llmfan46)` | **`Teacher:`** `Claude Fable 5` | **`Type:`** `Distilled + Abliterated Dense LLM`
+**`Architecture:`** `Qwen 3.6 35B-A3B (MoE)` | **`Total Params:`** `~34.7B` | **`Active Params:`** `~3B` | **`Context:`** `262,144 native / 1,010,000 extensible` | **`Base:`** `Heretic (llmfan46)` | **`Teacher:`** `Claude Fable 5` | **`Type:`** `Distilled + Abliterated MoE LLM`
 
-A personal fork of [`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved`](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) — an uncensored Heretic-style (MPOA, MTP-preserved) abliteration of [Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B), the dense 27B multimodal base — repackaged as Janus-27B with Claude Fable 5 reasoning data in the teacher slot. Refusal-trained behavior is dialed back at the base layer.
+A personal fork of [`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic`](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic) — an uncensored Heretic-style abliteration of [Qwen/Qwen3.6-35B-A3B](https://huggingface.co/Qwen/Qwen3.6-35B-A3B), the 35B-total / 3B-active mixture-of-experts multimodal base — repackaged as Janus-35B with Claude Fable 5 reasoning data in the teacher slot. Refusal-trained behavior is dialed back at the base layer.
 
-> **Provenance.** This repo repackages and quantizes — **no training is performed
-> here.** What ships is [`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved`](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) converted to GGUF and MTP-stripped so stock
-> llama.cpp and Ollama can load it. The `Teacher:` field above and the `datasets:`
+> **Provenance.** This repo repackages — **no training and no quantization is
+> performed here.** What ships is `llmfan46`'s own Q4_K_M of
+> [`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic`](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic),
+> byte-for-byte, with this repo's Ollama wrapper around it. The `Teacher:` field above and the `datasets:`
 > list in the frontmatter are carried over from earlier revisions of this card.
 > **The current base does not claim them** — its card lists no datasets and names
 > no teacher — and nothing in this repo reproduces or measures them. One listed
@@ -77,10 +80,11 @@ A personal fork of [`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Pr
 > attribution, not as a training record.
 > `base_model_relation` is `quantized` for the same reason.
 
-> **On the repo name:** the model is **Janus-27B**, but the Hub slug stays
-> `FoolDev/Janus-35B-HERETIC` — renaming it would break every existing link and
-> `ollama run hf.co/…` pull. Use the URLs exactly as written below. The Ollama
-> tag (`janus`) is unchanged too.
+> **On the repo name:** the model is **Janus-35B** and the Hub slug
+> `FoolDev/Janus-35B-HERETIC` names it correctly again. Between releases 0.2.0 and
+> 0.6.5 this repo shipped a dense Qwen 3.8 27B under the same slug; that blob is no
+> longer published and remains in git history. Every URL and `ollama run hf.co/…`
+> pull below is unchanged, as is the Ollama tag (`janus`).
 
 ## TL;DR
 
@@ -104,11 +108,13 @@ ollama create janus -f Modelfile && ollama run janus
 
 After either path, `ollama show janus` lists `completion`, `tools`,
 and `thinking` under Capabilities. Hardware: the default `num_ctx` is the full
-**262,144** native window — ~34 GiB with Ollama's default f16 KV cache, ~26 GiB
-with `OLLAMA_KV_CACHE_TYPE=q8_0` — so on a smaller host use the q8_0 cache or
-lower it (65536 is ~21 GiB), or raise it on to 1,010,000 with YaRN (not baked
-in, so context past ~262K degrades). See
-[Hardware requirements](#hardware-requirements).
+**262,144** native window — about **25 GiB** with Ollama's default f16 KV cache
+and about **22.4 GiB** with `OLLAMA_KV_CACHE_TYPE=q8_0`. Those two totals are
+*derived from the GGUF's own geometry, not measured on this blob*, and they do not
+include the recurrent state or compute buffer (see
+[Hardware requirements](#hardware-requirements)). Lower `num_ctx` on a smaller host
+(65536 is about 21 GiB), or raise it to 1,010,000 with YaRN (not baked in, so
+context past ~262K degrades).
 
 To halve the KV cache, start the Ollama server with the q8_0 cache and flash
 attention (for a systemd install, add them as `Environment=` lines with
@@ -122,74 +128,80 @@ OLLAMA_KV_CACHE_TYPE=q8_0 OLLAMA_FLASH_ATTENTION=1 ollama serve
 
 | File | Use |
 |---|---|
-| `Janus-27B.Q4_K_M.gguf` | Recommended default, ~17 GB. MTP-stripped so stock llama.cpp / Ollama can load it (see [Architecture](#architecture)). |
+| `Janus-35B-A3B.Q4_K_M.gguf` | Recommended default, 21.23 GB. Upstream's Q4_K_M byte-for-byte — no re-quantization and no MTP strip needed (see [Architecture](#architecture)). |
 | `Modelfile` | Ollama wrapper for **local** builds (`ollama create janus -f Modelfile`) — carries the Go template that Ollama runs in preference to the GGUF's embedded one (see [Which template Ollama runs](#which-template-ollama-runs)). |
 | `template`, `system`, `params` | Used by HF's Ollama bridge when users `ollama run hf.co/FoolDev/Janus-35B-HERETIC` directly. The bridge does **not** read `Modelfile` (see [HF Ollama docs](https://huggingface.co/docs/hub/en/ollama)); it ingests these three root-level files instead. Kept in sync with the `Modelfile`'s `TEMPLATE` / `SYSTEM` / `PARAMETER` directives. |
-| `chat_template.jinja` | Chat template for **llama.cpp / llama-server**, already stamped into the bundled GGUF (pass `--chat-template-file` only for an unstamped quant). The base model's own embedded template with two changes: `preserve_thinking` and `preserve_reasoning` never raise when they disagree (`preserve_thinking` wins), while earlier turns' reasoning is replayed by default, as upstream does; and `reasoning_effort` is normalised instead of validated. Tool calls keep upstream's XML default, the form llama-server's parser reads. Also stamped into the GGUF by `scripts/build.sh`. See [Tool / function calling](#tool--function-calling). |
-| `scripts/build.sh` | Pulls a GGUF from `llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF` (default Q4_K_M), runs it through `strip_mtp.py`, then runs `ollama create janus`. Quants published there: BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S, Q5_K_M, Q5_K_S, Q6_K, Q8_0. The bundled Q4_K_M is already this Heretic quant (stripped); use this to build the others locally. |
+| `scripts/build.sh` | Pulls a GGUF from `llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF` (default Q4_K_M), runs it through `strip_mtp.py` (a no-op for these quants, kept as a guard), then runs `ollama create janus`. Quants published there: BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S, Q5_K_M, Q5_K_S, Q6_K, Q8_0. The bundled Q4_K_M *is* that repo's Q4_K_M; use this to build the others locally. |
 | `scripts/check_bridge_sync.py` | Run before pushing a `Modelfile` / `template` / `system` / `params` edit to verify the four configurations remain in sync. Exits 0 if in sync, 1 with a per-key diff if not. |
-| `scripts/check.sh` | Local lint: `bash -n`, `shellcheck`, `py_compile`, footgun-grep, `Modelfile`-vs-bridge-files sync, the `chat_template.jinja` render checks and the Go `template` guard (`make check`) |
-| `scripts/check_chat_template.py` | Renders `chat_template.jinja` with jinja2 and asserts the tool-call, thinking, reasoning-replay (default, opt-outs, conflicting kwargs, live tool chain) and `reasoning_effort` behaviour (check 8 in `check.sh`) |
-| `scripts/check_go_template.py` | Guards the Go `template`: Ollama's thinking detection, the condition that replays earlier turns' reasoning, the tool round trip and JSON tool signatures (check 9 in `check.sh`) |
+| `scripts/check.sh` | Local lint: `bash -n`, `shellcheck`, `py_compile`, footgun-grep, `Modelfile`-vs-bridge-files sync and the Go `template` guard (`make check`) |
+| `scripts/check_go_template.py` | Guards the Go `template`: Ollama's thinking detection, the condition that replays earlier turns' reasoning, the tool round trip and JSON tool signatures (check 8 in `check.sh`) |
 | `scripts/live_check.sh` | Live end-to-end checks in an isolated, CPU-only Ollama (own port and model store; it refuses to run if Ollama reports a GPU): template selection, one tool call, string-argument replay, an earlier turn's reasoning replayed and a live tool chain's kept, every `reasoning_effort` value and the effort lines — 17 checks (`make live-check`) |
-| `scripts/verify_arch.py` | Cross-checks the README Architecture bullets (layer count, hidden size, dense FFN width, native context, vocab) plus the underlying forward-pass structure (Gated Attention + Gated DeltaNet head dims, partial RoPE, full-attention interval) against the bundled GGUF's `qwen35` metadata. Run on demand (`python3 scripts/verify_arch.py`); loads the ~17 GB GGUF (LFS smudge required) and exits non-zero on any mismatch. `block_count` is checked against **64** — the MTP-stripped value — so an unstripped bundle reports 65 and fails. |
-| `scripts/strip_mtp.py` | Drops the MTP / NextN layer from a `qwen35` GGUF (`python3 scripts/strip_mtp.py IN.gguf OUT.gguf`): removes the extra `blk.<last>.*` block, decrements `block_count`, drops `nextn_predict_layers`. Kept tensors are copied byte-for-byte (no re-quant); a conditional no-op (hardlink) on already-clean quants. **Required, not optional:** the base is MTP-preserved, so quants from the source repo carry a NextN block at index 64 that stock llama.cpp / Ollama cannot load. With `--chat-template FILE` it also restamps the GGUF's embedded chat template in the same pass (see [Tool / function calling](#tool--function-calling)). `build.sh` runs this on every fetched quant, and the bundled Q4_K_M ships already stripped (`block_count` 64). Parity with the dense sibling `FoolDev/Thanatos-27B-HERETIC`. |
+| `scripts/verify_arch.py` | Cross-checks the README Architecture bullets (layer count, hidden size, expert counts and widths, native context, vocab) plus the underlying forward-pass structure (Gated Attention + Gated DeltaNet dims, partial RoPE, full-attention interval) against the bundled GGUF's `qwen35moe` metadata. Run on demand (`python3 scripts/verify_arch.py`); reads the 21 GB GGUF (LFS smudge required) and exits non-zero on any mismatch. `block_count` is checked against **40**, this model's natural depth — the MTP-Preserved variant this repo does not ship reports 41. |
+| `scripts/strip_mtp.py` | Drops an MTP / NextN layer from a Qwen 3.x GGUF (`python3 scripts/strip_mtp.py IN.gguf OUT.gguf`): removes the extra `blk.<last>.*` block, decrements `block_count`, drops `nextn_predict_layers`. Kept tensors are copied byte-for-byte (no re-quant); a conditional no-op (hardlink) on already-clean quants — **which is what it is for the quants this repo ships**, since llmfan46's plain `…-heretic-GGUF` files carry no NextN block. It stays in the build path as a guard for anyone pointing `build.sh` at the `…-Native-MTP-Preserved-GGUF` variant instead. Parity with the dense sibling `FoolDev/Thanatos-27B-HERETIC`, where the strip *is* required. |
 | `scripts/smoke_test.sh` | Integration smoke test against a running Ollama daemon: server reachable, model loaded, `tools` capability present, chat round-trip, and no control-token leakage. `TOOLS_TEST=1` adds a tool-call round-trip. Defaults to `MODEL=janus`. |
 | `scripts/bench.sh` | Measures tok/s from Ollama's `eval_count` / `eval_duration` over a short/medium/long prompt mix (with a discarded warmup). Defaults to `MODEL=janus`. |
-| `scripts/load_bundle.sh` | Loads the bundled `Janus-27B.Q4_K_M.gguf` into Ollama as a local `janus` tag without an upstream pull (if the working-tree file is still an LFS pointer it downloads the real blob into `.cache/` — it does not smudge in place — then checks the arch is `qwen35`). |
+| `scripts/load_bundle.sh` | Loads the bundled `Janus-35B-A3B.Q4_K_M.gguf` into Ollama as a local `janus` tag without an upstream pull (if the working-tree file is still an LFS pointer it downloads the real blob into `.cache/` — it does not smudge in place — then checks the arch is `qwen35moe`). |
 | `scripts/cap_ctx.sh` | Bakes a small-`num_ctx` local `janus` tag (bundled blob + this repo's Modelfile, `num_ctx`→4096, `num_batch` 256) for OpenAI `/v1` clients — which can't override the baked `num_ctx` and OOM on small hosts (see [Inference examples](#inference-examples)). Run `./scripts/cap_ctx.sh` (or `CTX=8192 ...`). |
-| `scripts/fetch_vision.sh` | Downloads the vision projector (`Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf`) from the Heretic GGUF repo for llama.cpp image input (Ollama vision is broken upstream — see [Vision](#vision)). |
+| `scripts/fetch_vision.sh` | Downloads the vision projector (`Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf`, 902 MB) from the Heretic GGUF repo for llama.cpp image input (Ollama vision is broken upstream — see [Vision](#vision)). |
 | `examples/` | Ready-to-run Python clients for Ollama, Transformers, and llama-cpp-python (text, tools, and vision — see `examples/README.md`) |
 
-GGUF-only release. Pull the Heretic safetensors from [`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved`](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) if you need the `transformers` tree (or the vanilla pre-Heretic base from [`Qwen/Qwen3.8-27B`](https://huggingface.co/Qwen/Qwen3.8-27B)). The safetensors also keep the MTP head that the bundled GGUF has stripped — that's the path to speculative decoding under vLLM / SGLang.
+GGUF-only release. Pull the Heretic safetensors from [`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic`](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic) if you need the `transformers` tree (or the vanilla pre-Heretic base from [`Qwen/Qwen3.6-35B-A3B`](https://huggingface.co/Qwen/Qwen3.6-35B-A3B)). The safetensors also keep the MTP layer that this GGUF does not carry — that's the path to speculative decoding under vLLM / SGLang.
 
-> ### Bundled blob status: the dense 27B is published
+> ### Bundled blob status: the 35B-A3B MoE is published
 >
-> The bundled GGUF is **`Janus-27B.Q4_K_M.gguf`** (~17.3 GB) — the dense Qwen 3.8
-> 27B this card describes. `ollama run hf.co/FoolDev/Janus-35B-HERETIC` serves it
-> directly, and `ollama create janus -f Modelfile` works from a fresh clone.
+> The bundled GGUF is **`Janus-35B-A3B.Q4_K_M.gguf`** (21,233,608,512 bytes —
+> 21.23 GB decimal, 19.78 GiB binary) — the Qwen 3.6 35B-A3B MoE this card
+> describes. `ollama run hf.co/FoolDev/Janus-35B-HERETIC` serves it directly, and
+> `ollama create janus -f Modelfile` works from a fresh clone.
 >
-> It is `llmfan46/…-MTP-Preserved-GGUF`'s Q4_K_M
-> (sha256 `97298d4b0f99a3f4c46b2dd013abd0ca1628d68be4c3960817b39998a60f0eaf`)
-> run through `./scripts/strip_mtp.py`: the NextN block at index 64 is dropped,
-> `block_count` 65 → 64, `nextn_predict_layers` removed, and every kept tensor
-> copied byte-for-byte — no re-quantization. `chat_template.jinja` is stamped into
-> its metadata in the same pass, so llama.cpp and LM Studio's llama.cpp runtime get
-> working tool calls with no extra flags (both tested; KoboldCpp and Jan were checked on 2026-09-14, see [Tool / function calling](#tool--function-calling)).
+> It is `llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF`'s Q4_K_M
+> (sha256 `b82f9f2155eb9c07139d48cc3a37880cf9d0edcca345ef6ad829b62941ccbb82`)
+> **byte-for-byte**: no re-quantization, no MTP strip and no template restamp. This
+> quant carries no NextN block to strip, and the GGUF keeps the base model's own
+> embedded chat template — this repo ships no `chat_template.jinja` of its own.
 >
-> Verified before publishing: all 14 Architecture claims below via
-> `python3 scripts/verify_arch.py`; loads in Ollama as `qwen35` / 26.9B dense with
-> `tools` and `thinking`; and a full tool-call round-trip on
-> `/v1/chat/completions`, including the replay turn whose string `arguments` used
-> to fail.
+> Verified before publishing (2026-09-18): the file's GGUF header was read directly
+> from the published blob by HTTP range request — `general.architecture qwen35moe`,
+> `block_count` 40, 256 experts / 8 active, `context_length` 262144, vocab 248,320,
+> 733 tensors, no `nextn` key and no NextN tensors — and every Architecture claim
+> below matches it. Not re-run since the reversal: a live load, a tool-call
+> round-trip and `scripts/live_check.sh`, all of which need the 21 GB blob on disk.
 >
-> The repo previously shipped a 35B-A3B MoE quant, which is where the
-> `Janus-35B-HERETIC` slug comes from. That blob is no longer published; it
-> remains in git history.
+> Between 0.2.0 and 0.6.5 this repo shipped a dense Qwen 3.8 27B
+> (`Janus-27B.Q4_K_M.gguf`). That blob is no longer published; it remains in git
+> history.
 
 ## Architecture
 
-A **dense** hybrid stack: linear-attention (Gated DeltaNet) layers with a full
-Gated Attention layer every fourth block. No experts, no router — all 27B
-parameters run on every token.
+<img src="https://huggingface.co/FoolDev/Janus-35B-HERETIC/resolve/main/moe-routing.svg" alt="animated MoE routing visualization: 16x16 grid of 256 expert dots with 8 lit at any time, cycling through 8 routing patterns" width="640" />
 
-- Qwen 3.8, 27B dense (no experts, no routing, nothing conditionally skipped)
-- 64 layers, 16 × (3 × Gated DeltaNet → MLP / 1 × Gated Attention → MLP) — `full_attention_interval` 4, so 16 full-attention and 48 linear-attention layers
-- Hidden size 5120, dense FFN intermediate 17408
-- Gated Attention: 24 Q-heads / 4 KV-heads (GQA), head_dim 256, gated output projection, partial RoPE (factor 0.25 — 64 of 256 dims rotated)
-- Gated DeltaNet: 48 V-heads / 16 QK-heads, head dim 128, conv kernel 4
+A **sparse** hybrid stack: linear-attention (Gated DeltaNet) layers with a full
+Gated Attention layer every fourth block, and a 256-expert MoE feed-forward on
+every block. ~34.7B parameters total, ~3B active per token — 8 routed experts
+plus one shared expert.
+
+- Qwen 3.6, 35B-A3B mixture-of-experts (256 experts, 8 routed per token, plus a shared expert on every block)
+- 40 layers, 10 × (3 × Gated DeltaNet → MoE / 1 × Gated Attention → MoE) — `full_attention_interval` 4, so 10 full-attention and 30 linear-attention layers
+- Hidden size 2048; per-expert FFN intermediate 512, shared-expert FFN 512
+- Gated Attention: 16 Q-heads / 2 KV-heads (GQA), head_dim 256, gated output projection, partial RoPE (`rope.dimension_count` 64 of 256 dims rotated), `rope.freq_base` 1e7
+- Gated DeltaNet: conv kernel 4, state size 128, 16 groups, inner size 4096
 - 262 144 native context (extensible to 1 010 000 with YaRN, but YaRN is not enabled in the bundled GGUF)
-- Vision + video supported by upstream (mmproj not included in this release)
+- Vision + video supported by upstream (mmproj not included in this release — see [Vision](#vision))
 - Vocab 248,320
-- GGUF arch stamp `qwen35` — the canonical upstream label for the whole Qwen 3.5 / 3.6 / 3.8 family; there is no `qwen38` arch in llama.cpp
+- GGUF arch stamp `qwen35moe` — the MoE arch in llama.cpp (`src/models/qwen35moe.cpp`, `case 40: LLM_TYPE_35B_A3B`); the dense members of the family stamp `qwen35`
+
+Every bullet above is asserted against the bundled GGUF's own metadata by
+`python3 scripts/verify_arch.py`.
 
-**MTP head (stripped).** The base is *MTP-preserved*: its GGUFs carry a NextN
-block at index 64 for vLLM / SGLang speculative decoding, and stock llama.cpp and
-Ollama refuse to load it. The bundled `Janus-27B.Q4_K_M.gguf` is therefore
-MTP-stripped — block 64 removed, `block_count` 65 → 64 — by
-`scripts/strip_mtp.py`, exactly as the dense sibling Thanatos does. If you want
-the MTP head, run the upstream safetensors under vLLM / SGLang, or take an
-unstripped quant straight from the source GGUF repo.
+**MTP head (absent from this quant).** The base *does* declare an MTP layer
+(`mtp_num_hidden_layers: 1` in its `config.json`) for vLLM / SGLang speculative
+decoding, but the Q4_K_M published in llmfan46's GGUF repo — the file this repo
+bundles — carries no NextN block: `block_count` is 40 and `blk.0`…`blk.39` are all
+that exist. So no strip is needed here, and `scripts/strip_mtp.py` is a defensive
+no-op on it. llmfan46 also publishes a separate `…-Native-MTP-Preserved-GGUF`
+variant whose Q4_K_M has `block_count` 41 with a NextN block at index 40; that one
+*would* need stripping, and it is not what this repo ships. For the MTP head
+itself, run the upstream safetensors under vLLM / SGLang.
 
 ## Quick start
 
@@ -197,14 +209,18 @@ unstripped quant straight from the source GGUF repo.
 
 Drop the GGUF into your loader of choice. The chat template is embedded in the GGUF metadata, and llama.cpp and LM Studio use it by default, so no `--chat-template` flag is needed (llama.cpp has no `--chat-template auto` mode; it would take "auto" as the template itself).
 
-**Tool calling works out of the box** — the bundled GGUF carries this repo's `chat_template.jinja` in its metadata, so `--jinja` alone is enough. Tool calls use Qwen's native XML form, the one llama-server's parser reads. (Upstream's template raises on `reasoning_effort: "max"` and on conflicting `preserve_thinking` / `preserve_reasoning`, both HTTP 500s on llama-server. Pass the file explicitly if you are running an unstamped quant:)
+**Tool calling works out of the box** — the GGUF carries Qwen 3.6's own template, so `--jinja` alone is enough and there is no file to pass:
 
 ```bash
-llama-server -m Janus-27B.Q4_K_M.gguf --jinja --chat-template-file chat_template.jinja
+llama-server -m Janus-35B-A3B.Q4_K_M.gguf --jinja
 ```
 
-A GGUF built by `./scripts/build.sh` has that template baked in and needs no flag.
-See [Tool / function calling](#tool--function-calling) for what differs and why.
+Tool calls use Qwen's native XML form, the one llama-server's parser reads. Two
+things this path does **not** have, because they lived in the patched Qwen 3.8
+template this repo shipped between 0.2.0 and 0.6.5 and no longer ships:
+`reasoning_effort` tiers, and the `tool_call_format` JSON opt-in. See
+[Tool / function calling](#tool--function-calling) and
+[Reasoning effort](#reasoning-effort).
 
 ### Ollama
 
@@ -229,9 +245,10 @@ Once the model is loaded (via `ollama run janus`, `lms server`, or `llama-server
 > The examples use `model: "janus"`, the tag from the local build (path B). If you pulled via the TL;DR one-liner instead, use the full tag `hf.co/FoolDev/Janus-35B-HERETIC`, or run `ollama cp hf.co/FoolDev/Janus-35B-HERETIC janus` once to create the short tag.
 
 > **On memory-tight hosts, cap `num_ctx` first.** `/v1/chat/completions` (OpenAI-compat) has
-> no `num_ctx` knob, so it loads at the baked **262,144** default (16 GiB KV / ~34 GiB total with
-> Ollama's default f16 cache), which does not fit a 32 GB box; `OLLAMA_KV_CACHE_TYPE=q8_0` on the
-> server brings it to ~26 GiB (see [Hardware requirements](#hardware-requirements)). Either
+> no `num_ctx` knob, so it loads at the baked **262,144** default (5.0 GiB KV / ~25 GiB total
+> with Ollama's default f16 cache — derived from the GGUF's geometry, not measured on this blob),
+> which is tight on a 32 GB box; `OLLAMA_KV_CACHE_TYPE=q8_0` on the
+> server brings it to ~22.4 GiB (see [Hardware requirements](#hardware-requirements)). Either
 > call `/api/chat` with `"options": {"num_ctx": 4096}`, or bake a small-context tag for
 > OpenAI clients: `ollama run hf.co/FoolDev/Janus-35B-HERETIC:Q4_K_M`, then
 > `/set parameter num_ctx 4096` and `/save janus`, and point clients at `janus` — or in one step, **`./scripts/cap_ctx.sh`** (which bakes exactly that tag).
@@ -321,16 +338,16 @@ Behavior rules:
 
 ## Vision
 
-The Qwen 3.8 base supports image (and video) input via a separate
+The Qwen 3.6 base supports image (and video) input via a separate
 `mmproj` projector. The full multimodal stack is:
 
 ```
-Janus-27B.Q4_K_M.gguf                                                       (~17 GB, the text decoder)
-Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf  (the vision projector)
+Janus-35B-A3B.Q4_K_M.gguf                            (21.23 GB, the text decoder)
+Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf  (902 MB, the vision projector)
 ```
 
 The projector and other-quant text decoders live at
-[`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF`](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF)
+[`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF`](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF)
 (BF16 mmproj only). This repo intentionally does not redistribute it;
 `./scripts/fetch_vision.sh` pulls the projector into the repo root.
 
@@ -338,21 +355,21 @@ The projector and other-quant text decoders live at
 
 | Loader | Text | Vision (mmproj) | Notes |
 |---|---|---|---|
-| **llama.cpp** (`llama-mtmd-cli`, `llama-server --mmproj`) | ✅ | ✅ | Reference path. Upstream has the `qwen35` arch entry. |
+| **llama.cpp** (`llama-mtmd-cli`, `llama-server --mmproj`) | ✅ | ✅ | Reference path. Upstream has the `qwen35moe` arch entry (`src/models/qwen35moe.cpp`). |
 | **llama-cpp-python** | ✅ | ✅ | See `examples/llama_cpp_vision.py`. |
-| **Ollama 0.24+** | ✅ | ❌ | Text inference works: Ollama's Go engine has the `qwen35` arch entry. Vision (mmproj) is still broken: the C++ llama.cpp fallback that Ollama switches to when an mmproj is attached lacks it. `ollama create` accepts a dual-`FROM` (text + mmproj) and `ollama show` reports `vision` capability — but the **first inference request** fails with an `unknown model architecture` load error, and once mmproj is attached this blocks text inference too. See [ollama/ollama#14575](https://github.com/ollama/ollama/issues/14575) (closed as completed on 2026-08-04; #15898 was closed as its duplicate and the sync PR #15899 closed unmerged). Re-test on a current Ollama before assuming vision is still broken — this table has not been re-verified since it closed. |
+| **Ollama** (0.33.3 and 0.34.x checked in source, 2026-09-18) | ✅ | ❌ | Text inference works: `qwen35moe` is handled through Ollama's llama.cpp compat shim at v0.33.3, v0.34.0 and v0.34.2. The version floor this row used to claim ("0.24+") was undated and inherited from the MoE-era card; it has not been re-established, so treat these three as the tested set. Vision (mmproj) is still broken: the C++ llama.cpp fallback that Ollama switches to when an mmproj is attached lacks it. `ollama create` accepts a dual-`FROM` (text + mmproj) and `ollama show` reports `vision` capability — but the **first inference request** fails with an `unknown model architecture` load error, and once mmproj is attached this blocks text inference too. See [ollama/ollama#14575](https://github.com/ollama/ollama/issues/14575) (closed as completed on 2026-08-04; #15898 was closed as its duplicate and the sync PR #15899 closed unmerged). Re-test on a current Ollama before assuming vision is still broken — this table has not been re-verified since it closed. |
 | **LM Studio** | ✅ | ✅ | Uses upstream llama.cpp directly. |
 
 ### Vision via llama.cpp
 
 ```bash
 # Fetch the projector first (into the repo root):
-./scripts/fetch_vision.sh   # Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf
+./scripts/fetch_vision.sh   # Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf
 
 # A. HTTP via llama-server (the easiest path):
 llama-server \
-  -m Janus-27B.Q4_K_M.gguf \
-  --mmproj Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+  -m Janus-35B-A3B.Q4_K_M.gguf \
+  --mmproj Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
   --host 127.0.0.1 --port 8765 -c 8192 -ngl 99
 # then POST OpenAI-style chat completions with an image_url content block —
 # e.g. {"type":"image_url","image_url":{"url":"data:image/jpeg;base64,..."}}
@@ -363,36 +380,51 @@ llama-server \
 # B. CLI via llama-mtmd-cli (one-shot). It's a separate cmake target, so a
 #    selective build can skip it; a plain `cmake --build build` produces it.
 llama-mtmd-cli \
-  -m Janus-27B.Q4_K_M.gguf \
-  --mmproj Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+  -m Janus-35B-A3B.Q4_K_M.gguf \
+  --mmproj Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
   --image photo.jpg \
   -p "Describe this image."
 
 # C. Python via llama-cpp-python:
 python examples/llama_cpp_vision.py \
-  --gguf Janus-27B.Q4_K_M.gguf \
-  --mmproj Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+  --gguf Janus-35B-A3B.Q4_K_M.gguf \
+  --mmproj Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
   --image /path/to/photo.jpg \
   --prompt "What is in this image?"
 ```
 
 The Ollama issue is closed upstream but this table has not been re-verified
 since; until you have re-tested, treat Ollama as **text-only** for this model. The bundled Q4_K_M decoder pairs with the projector directly — the
-mmproj is family-wide for Qwen 3.8 27B, so no separate text download is
+mmproj is family-wide for Qwen 3.6 35B-A3B, so no separate text download is
 needed for vision.
 
 ## Hardware requirements
 
-This is a ~17 GB Q4_K_M GGUF. Measured on Ollama 0.33.3's CPU backend (2026-09-14, from llama.cpp's own allocation log lines), it needs **16.1 GiB** for the weights, **0.15 GiB** of fixed recurrent state for the 48 linear-attention layers, a **0.3-0.8 GiB** compute buffer with flash attention (Ollama's default `auto` enables it; forcing it off grows the buffer to ~25 GiB at 262144), and a KV cache for the 16 full-attention layers of exactly **2 GiB per 32K tokens at f16** — Ollama's default — or **1.06 GiB per 32K at q8_0** (`OLLAMA_KV_CACHE_TYPE=q8_0`, with `OLLAMA_FLASH_ATTENTION=1`).
+This is a 21.23 GB Q4_K_M GGUF (19.78 GiB of weights). **The figures below are
+derived from the GGUF's own geometry, not measured on this blob** — every measured
+number this section used to carry was taken on the dense 27B that shipped between
+0.2.0 and 0.6.5 and has been removed rather than rescaled, because the geometry
+differs in both directions: more weights, far less KV.
+
+The KV cache covers the 10 full-attention layers (2 KV heads × 256 key dims + 256
+value dims), so each token costs 10 × 2 × 512 × 2 bytes = **20,480 B at f16** —
+**0.625 GiB per 32K tokens** — or about **10,880 B at q8_0** (0.332 GiB per 32K,
+`OLLAMA_KV_CACHE_TYPE=q8_0` with `OLLAMA_FLASH_ATTENTION=1`). That is under a third
+of the dense 27B's KV at the same window. The 30 linear-attention layers hold a fixed
+recurrent state and the runtime allocates a compute buffer on top; **neither is
+derivable from metadata and neither has been measured here**, so the totals below are
+floors, not forecasts.
 
 | `num_ctx` | f16 cache (default) | q8_0 cache |
 |---|---|---|
-| **262144 (default)** | 16 GiB KV, **~34 GiB** total | 8.5 GiB KV, **~26 GiB** total |
-| 65536 | 4 GiB KV, ~21 GiB total | 2.1 GiB KV, 19.2 GiB total (measured) |
-| 32768 | 2 GiB KV, ~19 GiB total | 1.1 GiB KV, ~18 GiB total |
-| 1010000 (needs YaRN) | 61.6 GiB KV, ~80 GiB total | 32.7 GiB KV, ~50 GiB total |
+| **262144 (default)** | 5.0 GiB KV, **~25 GiB** total | 2.66 GiB KV, **~22.4 GiB** total |
+| 65536 | 1.25 GiB KV, ~21 GiB total | 0.66 GiB KV, ~20.4 GiB total |
+| 32768 | 0.63 GiB KV, ~20.4 GiB total | 0.33 GiB KV, ~20.1 GiB total |
+| 1010000 (needs YaRN) | 19.3 GiB KV, ~39 GiB total | 10.2 GiB KV, ~30 GiB total |
 
-KV and recurrent sizes are exact (measured at 8K, 32K and 65K, and linear in `num_ctx`); totals at 262144 and above add llama.cpp master's `llama-fit-params` projection of the compute buffer (~1-1.5 GiB), which ran ~0.35 GiB above what Ollama allocated at 65536. It's **extensible to 1,010,000**, but this GGUF ships **no baked YaRN rope-scaling**, so positions past the 262144 native window use untrained RoPE and output degrades — reaching the 1.01M ceiling needs YaRN (see below); keep real work within ~262K otherwise.
+KV sizes are exact for this geometry and linear in `num_ctx`; the totals add the
+19.78 GiB of weights and nothing else. Re-measure with `make live-check` or
+llama.cpp's `llama-fit-params -v` once the blob is on disk. It's **extensible to 1,010,000**, but this GGUF ships **no baked YaRN rope-scaling**, so positions past the 262144 native window use untrained RoPE and output degrades — reaching the 1.01M ceiling needs YaRN (see below); keep real work within ~262K otherwise.
 
 **How to override it:** `ollama run` has no `-o` flag, and `OLLAMA_CONTEXT_LENGTH`
 only sets a default that the baked `num_ctx` overrides — so set it per-session
@@ -410,20 +442,18 @@ Programmatic callers pass the same via the API `options` field:
 
 | Hardware | Status |
 |---|---|
-| ≥48 GB RAM (CPU-only) | Works at the 262144 default (~34 GiB); a 32 GB host needs `OLLAMA_KV_CACHE_TYPE=q8_0` (~26 GiB, tight) or `num_ctx 65536` (~21 GiB) |
+| ≥48 GB RAM (CPU-only) | Works at the 262144 default (~25 GiB derived) with room to spare |
 | Single H100/A100 80 GB | Works, full offload |
 | RTX 4090 24 GB / 5090 32 GB + 32 GB RAM | Works, partial offload |
 | Mac Studio M2/M3 Ultra 64 GB+ unified | Works |
-| 32 GB unified-memory laptops (Ryzen AI Max+, Apple M-series) | Does not fit the 262144 default with the f16 cache; the q8_0 cache (~26 GiB) is tight, `num_ctx 65536` (~19-21 GiB) is comfortable |
+| 32 GB unified-memory laptops (Ryzen AI Max+, Apple M-series) | ~25 GiB derived at the 262144 default leaves little headroom on a 27 GiB-visible host; `OLLAMA_KV_CACHE_TYPE=q8_0` (~22.4 GiB) or `num_ctx 65536` (~21 GiB) is the comfortable setting |
 
-**Throughput, measured on CPU only: ~5.0 tok/s.** On a Ryzen AI Max+ 395 with
-Ollama 0.33.3's CPU backend, `./scripts/bench.sh` measured **4.97 tok/s** at Q4_K_M
-(3-prompt mix, flash attention, q8_0 KV cache), and llama-server generated at about
-the same rate on the same CPU. Partial GPU offload is covered below.
-The tok/s figures this table used to carry were taken before the 27B rebase and say
-nothing about this model, so they've been removed rather than carried over; the
-rows above are fit estimates from the memory math. `./scripts/bench.sh` measures
-tok/s on your own host.
+**No throughput figures are published for this build.** Every tok/s number this card
+carried was measured on the dense 27B, and a 35B-A3B MoE touches roughly 3B
+parameters per token instead of 27B — a bandwidth profile different enough that
+rescaling would be invention, not estimation. `./scripts/bench.sh` measures tok/s on
+your own host; contributions of real numbers are welcome (see
+[No formal evaluation](#known-limitations)).
 
 **GPU offload on a Strix Halo iGPU (Radeon 8060S): a small gain, and a trap.** On a
 Vulkan integrated GPU, llama.cpp - including the build Ollama 0.33.3 bundles - turns
@@ -431,20 +461,18 @@ mmap off and puts every layer it does *not* offload into GPU-reachable host memo
 the same pool as the GPU, so `num_gpu` alone does not limit GPU memory: a first attempt
 with llama-server filled the pool and took the desktop down with it. With
 `LLAMA_ARG_NO_HOST=1` in the Ollama server's environment (llama.cpp's `--no-host`) those
-layers stay in ordinary RAM. Measured that way on this model (a private Ollama 0.33.3
-with the `ollama-vulkan` backend and `OLLAMA_IGPU_ENABLE=1`; flash attention, q8_0 KV
-cache, `num_ctx` 4096, a short generation): 4.8 tok/s at `num_gpu` 4, 4.9 at 8, 5.3 at 16
-and 5.7 at 24 (7.9 GiB of the GPU pool), against about 5.0 on CPU only; prompt processing
-roughly doubled (61 against 30 tok/s). The step to 32 layers ran the 27 GiB host short of
-RAM and was stopped: the GPU's GTT is system RAM, so offloading frees none. On a machine
-like this, CPU-only is nearly as fast; if you try the GPU, set `LLAMA_ARG_NO_HOST=1` and a
-fixed `num_gpu`. The mechanism is reported upstream in
+layers stay in ordinary RAM. That mechanism is loader-side and applies to any model; the
+tok/s series this paragraph used to quote was measured on the dense 27B and has been
+removed with the rest. What generalises: the GPU's GTT is system RAM, so offloading frees
+none of it, and a first attempt without `--no-host` filled the pool and took the desktop
+session down with it. If you try the GPU on a machine like this, set
+`LLAMA_ARG_NO_HOST=1` and a fixed `num_gpu`. The mechanism is reported upstream in
 [ggml-org/llama.cpp#27360](https://github.com/ggml-org/llama.cpp/issues/27360).
 
 **Reaching a coherent ~1.01M context (opt-in YaRN).** The bundled GGUF ships no YaRN rope-scaling, so raising `num_ctx` toward the 1.01M ceiling degrades past the 262144 native window (see above). Ollama has no rope knob, so for a genuinely coherent long context run the GGUF under llama.cpp with YaRN enabled:
 
 ```bash
-llama-server -m Janus-27B.Q4_K_M.gguf \
+llama-server -m Janus-35B-A3B.Q4_K_M.gguf \
   --rope-scaling yarn --yarn-orig-ctx 262144 --rope-scale 3.853 -c 1010000
 ```
 
@@ -452,7 +480,7 @@ llama-server -m Janus-27B.Q4_K_M.gguf \
 
 ## Chat template
 
-The model uses the standard Qwen 3.x ChatML format with `<|im_start|>` / `<|im_end|>` role markers. The template is embedded in the GGUF metadata for plain conversation use, but on Ollama the Go `template` / `Modelfile` TEMPLATE is what runs: Ollama picks between it and the embedded template at load time (see [Which template Ollama runs](#which-template-ollama-runs)).
+The model uses the standard Qwen 3.x ChatML format with `<|im_start|>` / `<|im_end|>` role markers. Two templates are in play. The GGUF carries **Qwen 3.6's own embedded template**, exactly as llmfan46 published it — this repo ships no `chat_template.jinja` of its own — and that is what llama.cpp, LM Studio and KoboldCpp render. On Ollama the Go `template` / `Modelfile` TEMPLATE is what runs instead: Ollama picks between the two at load time (see [Which template Ollama runs](#which-template-ollama-runs)). Where the two differ, this card says which one it is describing.
 
 ### Plain conversation
 
@@ -499,42 +527,40 @@ each endpoint reads one field:
 | Ollama `/v1/chat/completions` | `reasoning` only — `reasoning_content` and `thinking` are dropped silently, and a message whose `content` is an array of parts keeps its reasoning only if it also has `tool_calls` |
 | llama-server `/v1/chat/completions` | `reasoning_content` |
 
-Checked live on 2026-09-13 with the restamped blob, CPU only: Ollama 0.33.3
-replayed `thinking` on `/api/chat` (232 prompt tokens with it, 187 without) and
-`reasoning` on `/v1` (215 vs 187) and ignored `reasoning_content` on `/v1` (187);
-llama-server master rendered `reasoning_content` and dropped a `reasoning` field.
+Which field each endpoint reads is decided by the server, not the model. Checked
+live on 2026-09-13 — on the dense 27B blob this repo shipped between 0.2.0 and
+0.6.5, CPU only — Ollama 0.33.3 replayed `thinking` on `/api/chat` (232 prompt
+tokens with it, 187 without) and `reasoning` on `/v1` (215 vs 187) and ignored
+`reasoning_content` on `/v1` (187); llama-server master rendered `reasoning_content`
+and dropped a `reasoning` field. The behaviour is Ollama-side and carries over; the
+token counts were measured on that other blob and are not this model's.
 That Ollama's `/v1` also drops `thinking`, and the array-content rule, come from
 Ollama's v0.33.3 and v0.34.0 source, and still hold on the current release:
 `openai/openai.go` and `server/prompt.go` are byte-identical from v0.33.3 through
 v0.34.2 (source, 2026-09-17). Ollama never passes reasoning to the GGUF's
 embedded Jinja template, so on Ollama only the Go template decides what is replayed.
-On llama.cpp, while replay is on, an earlier assistant turn with no reasoning still
-gets an empty `<think>\n\n</think>` block, as upstream renders it.
-
-**The cost is context.** Every retained trace stays in the prompt, measured at
-**181 prompt tokens without / 464 with** on a 3-message conversation whose first
-assistant turn carried a ~240-word trace. Prefill grows with every retained trace,
+On llama.cpp an earlier assistant turn that carries no reasoning renders with **no**
+`<think>` block at all: Qwen 3.6's template gates the block on
+`reasoning_content|length > 0`. The 3.8 template this repo used to ship reconstructed
+an empty one instead, so prompts built by the two differ on that turn.
+
+**The cost is context.** Every retained trace stays in the prompt — measured on the
+dense 27B at 181 prompt tokens without and 464 with, on a 3-message conversation whose
+first assistant turn carried a ~240-word trace, and not re-measured here. Prefill grows with every retained trace,
 and on a CPU-only host prefill is the slow part. Releases 0.3.0 through 0.3.2
 turned replay off for that reason; the CHANGELOG has the history.
 
-**Tested on llama.cpp** on 2026-09-13 with a 260K-parameter test model and
-`--chat-template-file` (the template, not the model, decides the prompt), via
-`/apply-template` and `/v1/chat/completions`, on master `4a89937` (b10941), b10760
-(the llama-server Ollama 0.33.3 bundles) and b10519 (LM Studio's avx2 CPU runtime
-2.30.0): with default flags an earlier turn's reasoning was replayed; with
-`--no-reasoning-preserve`, or a per-request `preserve_thinking: false` or
-`preserve_reasoning: false`, it was not; `preserve_thinking: true` replayed it even
-against `--no-reasoning-preserve`; a live tool-call chain kept its reasoning in every
-mode, and no request returned an error. Master (b10763 and later) passes
-`preserve_reasoning=true` unless the server runs with `--no-reasoning-preserve`, and
-logs "chat template supports preserving reasoning, it is enabled by default"; b10760
-and b10519 pass nothing, log "consider enabling it via --reasoning-preserve", and
-replay anyway, because the template's own default is on. On the restamped blob
-itself, with its embedded template and default flags, llama-server master rendered a
-3-message conversation in 69 prompt tokens with the earlier turn's reasoning and 39
-with `--no-reasoning-preserve` or either `false` kwarg (43 with no reasoning sent,
-for the empty think block), and a real tool-result turn with string arguments
-returned HTTP 200.
+**On llama.cpp, Qwen 3.6's own template decides.** Read from the template inside
+the published blob (2026-09-18, from source — not re-tested live on this model):
+`preserve_thinking` defaults to **true**, so an earlier turn's reasoning is replayed
+by default; the assistant branch takes the trace from `message.reasoning_content`,
+and failing that recovers one by splitting a `<think>` block out of `content`; and
+there is no `preserve_reasoning` variable in it at all. That last point costs
+nothing, because llama-server derives a `preserve_thinking` kwarg from
+`preserve_reasoning` (`common/jinja/caps.cpp`), and from b10763 it passes
+`preserve_reasoning=true` by default — so `--no-reasoning-preserve` and a request's
+`preserve_reasoning: false` still reach this template through the derived copy,
+while a request's own `preserve_thinking` is read directly.
 
 **Which llama.cpp an Ollama carries.** 0.33.3 and 0.34.0 bundle b10760; 0.34.1
 bundles b10864 and 0.34.2 b10969 (each release's `LLAMA_CPP_VERSION`). From 0.34.1
@@ -544,19 +570,19 @@ for this model runs Ollama's own Go engine, and the bundled llama.cpp comes into
 play only when Ollama falls back to its C++ engine, as it does once an mmproj is
 attached (see [Loader compatibility](#loader-compatibility)).
 
-**Conflicting settings do not fail the request.** A request's `preserve_thinking`
-replaces the copy llama-server derives from `preserve_reasoning`, so the template can
-see the two disagree. Upstream's template raises on that, and llama-server returns the
-raise as HTTP 500 — verified on master for a `preserve_thinking: false` request under
-default flags, and on all three builds for `preserve_thinking: true` against
-`--no-reasoning-preserve`. This template lets `preserve_thinking` win and never raises.
+**Nothing raises on conflicting settings.** The Qwen 3.8 template that this repo
+patched between 0.4.0 and 0.6.5 raised when `preserve_thinking` and
+`preserve_reasoning` disagreed, and llama-server returned that raise as HTTP 500 —
+which is what the patch existed to prevent. Qwen 3.6's template has no such check:
+it reads `preserve_thinking`, ignores anything else, and cannot fail that way.
 
 **To turn replay off:**
 
 - **llama-server** — start it with `--no-reasoning-preserve`, or send
-  `"chat_template_kwargs": {"preserve_thinking": false}` (or
-  `{"preserve_reasoning": false}`) on a request. A request's
+  `"chat_template_kwargs": {"preserve_thinking": false}` on a request. A request's
   `preserve_thinking: true` switches it back on for that request.
+  `{"preserve_reasoning": false}` works too, through the kwarg llama-server derives
+  from it; the template itself never reads that name.
 - **Ollama** — edit the template. In the assistant branch of both the `Modelfile`
   and `template` (so `make check`'s bridge sync stays green), change `{{ if (and $.IsThinkSet .Thinking) -}}` back to Qwen's stock
   `{{ if (and $.IsThinkSet (and .Thinking (or $last (gt $i $lastUserIdx)))) -}}`
@@ -575,59 +601,67 @@ ollama run hf.co/FoolDev/Janus-35B-HERETIC:Q4_K_M --think=false
 
 or send `"think": false` on `/api/chat`. With thinking off the model skips the reasoning trace and answers straight into `content`; with it on (the default) reasoning is emitted into the `thinking` field.
 
-### Reasoning effort
+On llama.cpp the switch is the embedded template's own: send
+`"chat_template_kwargs": {"enable_thinking": false}`, which primes a closed, empty
+`<think>` block — and, because the template gates its replay branch on
+`enable_thinking` too, drops every earlier turn's trace for that request. That
+variable is upstream Qwen 3.6's, not this repo's.
 
-OpenAI-compatible clients can send `reasoning_effort`. Ollama's `/v1` layer accepts
-eight values. Where `chat_template.jinja` sees the value as sent (llama.cpp), it maps
-each to one of three tiers or switches thinking off:
+### Reasoning effort
 
-| `reasoning_effort` | Effect |
-|---|---|
-| `high`, `xhigh`, `max`, `ultra` | **xhigh** — the model is told to think carefully and check its assumptions |
-| `medium`, unset, `null` | **medium** — the default; no effort instruction is added |
-| `low`, `minimal` | **low** — the model is told to keep its thinking brief |
-| `none` | thinking **off** for that request, the same as `"think": false` |
-
-Anything unrecognised falls back to the medium default rather than failing the
-request. The two siblings differ here, each following its base model's template:
-an unset or unrecognised value is **medium** on Janus and **xhigh** on Thanatos. Upstream's template raised on unfamiliar values, so `reasoning_effort: "max"` broke every request. On Ollama, while it ran the embedded template, that surfaced as
-HTTP 500.
-
-**On Ollama's default path the Go template runs instead** (see
-[Which template Ollama runs](#which-template-ollama-runs)), and it adds the same
-instruction from Ollama's think level. Ollama folds the eight values into four
-levels before any template sees them, so the Go template maps levels, not values:
-`high`, `xhigh`, `max` and `ultra` get the xhigh line; `low` and `minimal` get the
-low line; `medium` and an unset value get no line; `none` switches thinking off. `"think": "high"`,
-`"low"` and `"max"` on `/api/chat` map the same way. Mixed case such as `"HIGH"`
-is rejected by Ollama itself with HTTP 400 before any template runs. Verified on
-Ollama 0.33.3 and 0.34.0 with `scripts/live_check.sh`, which sends `/api/chat` think levels: on a one-line chat, `high` and `max`
-each added 38 prompt tokens and `low` 26, while `medium` and an unset value added
-none. The `/v1` value-to-level mapping above comes from Ollama's source, unchanged
-from v0.33.3 through v0.34.2 (2026-09-17).
-
-On llama.cpp every value except `none` reaches `chat_template.jinja` as sent;
-llama-server handles `none` itself by switching thinking off. Tested on llama.cpp
-master `a2878d3`: all eight values, `"HIGH"` and an unknown word each
-returned HTTP 200, and the rendered prompt carried the tier in the table. The
-template lower-cases and trims the value itself. LM Studio's CPU engine (llama.cpp b10519) passed the same checks; the LM Studio app's own API layer is untested.
+**This works on Ollama, and not on llama.cpp.** The instruction comes from this
+repo's Go `template`, which Ollama runs (see
+[Which template Ollama runs](#which-template-ollama-runs)). Qwen 3.6's own template —
+the one inside the bundled GGUF, and so the one llama.cpp and LM Studio render — has
+no `reasoning_effort` variable at all, so there the tier values are accepted by the
+server and then quietly ignored (read from the template, 2026-09-18). `none` is the
+one exception: llama-server maps it to `enable_thinking: false` and drops the kwarg
+before the template runs (`tools/server/server-common.cpp`, checked 2026-09-18), so
+`reasoning_effort: "none"` does switch thinking off on llama.cpp. Between 0.2.0 and
+0.6.5 this repo shipped a patched Qwen 3.8 template that did implement the tiers on
+the llama.cpp path; that file is gone with the rebase back to the MoE.
+
+Ollama folds the eight values its `/v1` layer accepts into four think levels before
+any template sees them, so the Go template maps levels, not values:
+
+| `reasoning_effort` (Ollama `/v1`) | Think level | Effect |
+|---|---|---|
+| `high`, `xhigh`, `max`, `ultra` | xhigh | the model is told to think carefully and check its assumptions |
+| `medium`, unset, `null` | medium | the default; no effort instruction is added |
+| `low`, `minimal` | low | the model is told to keep its thinking brief |
+| `none` | — | thinking **off** for that request, the same as `"think": false` |
+
+`"think": "high"`, `"low"` and `"max"` on `/api/chat` map the same way. Mixed case
+such as `"HIGH"` is rejected by Ollama itself with HTTP 400 before any template runs.
+The value-to-level mapping comes from Ollama's source, unchanged from v0.33.3 through
+v0.34.2 (2026-09-17).
+
+Verified with `scripts/live_check.sh` on Ollama 0.33.3 and 0.34.0 — on the dense 27B
+bundle, before the reversal: on a one-line chat, `high` and `max` each added 38 prompt
+tokens and `low` 26, while `medium` and an unset value added none. Both the Go
+template and Ollama's folding are model-independent, so the mapping carries over
+unchanged; the live check has not been re-run against the MoE blob (`make live-check`
+needs the 21 GB file on disk).
 
 ### Which template Ollama runs
 
-This repo ships two templates for the same ChatML model: the Go `template` (served
-by HF's Ollama bridge) / `Modelfile` TEMPLATE, and `chat_template.jinja`, stamped
-into the GGUF. They do not render identical prompts — the Go template pins JSON
-tool calls and takes the reasoning-effort line from Ollama's think level, while the
-Jinja template has its own tool instructions, uses the XML `<function=…>` form
-unless a replayed call carries string arguments, and takes the line from the
-request's `reasoning_effort`.
-Ollama 0.33.3 and 0.34.0 (both verified) pick one at load time: they prefer the
-embedded template when that advertises more capabilities — tools, thinking — and
-keep the Go template when they tie. They tie, so **Ollama runs the Go template**;
-llama.cpp and LM Studio run the embedded Jinja template. That selection code is
-unchanged through v0.34.2 (source, 2026-09-17), and Ollama's built-in renderers —
-it ships a `qwen35` one — displace both templates only when the model's own config
-names a renderer or parser, which this repo's does not. Ollama logs the choice:
+Two templates exist for the same ChatML model: the Go `template` this repo ships
+(served by HF's Ollama bridge) / `Modelfile` TEMPLATE, and **Qwen 3.6's own template
+inside the GGUF**, which llmfan46 stamped and this repo leaves untouched. They do not
+render identical prompts — the Go template pins JSON tool calls and adds a
+reasoning-effort line from Ollama's think level, while the embedded template teaches
+the XML `<function=…>` form and has no effort variable at all.
+
+Ollama picks one at load time: it prefers the embedded template when that advertises
+more capabilities — tools, thinking — and keeps the Go template when they tie. Both
+advertise tools and thinking, so they tie and **Ollama runs the Go template**;
+llama.cpp and LM Studio run the embedded one. That was verified live on Ollama 0.33.3
+and 0.34.0 against the dense 27B bundle, and the selection code is unchanged through
+v0.34.2 (source, 2026-09-17); the tie itself depends on what the *embedded* template
+advertises, so it is expected rather than re-verified for this blob until
+`make live-check` runs on it. Ollama's built-in renderers — it ships a `qwen35` one —
+displace both templates only when the model's own config names a renderer or parser,
+which this repo's does not. Ollama logs the choice:
 
 ```text
 msg="template selection" ... selected=go_template go_template="[completion tools thinking]"
@@ -635,17 +669,19 @@ msg="template selection" ... selected=go_template go_template="[completion tools
 
 The Go template's "thinking" entry comes from its single `.Thinking` reference —
 the block that renders each assistant turn's reasoning. Removing it drops that
-capability: Ollama switches to the embedded template, a single tool call can
-come back twice (seen once; cause inferred, not confirmed — see
-[Known limitations](#known-limitations)), and `reasoning_effort` suddenly selects
-the Jinja template's tiers — under upstream's version of that template it raised
-instead, which is what caused the HTTP 500s. That happened once; the CHANGELOG has
-the details. Setting `OLLAMA_GO_TEMPLATE=1` or `=0` on the Ollama server forces one
-template or the other for every model.
+capability, and Ollama switches to the embedded template: tool calls change from
+JSON-in-XML to Qwen's XML form, which Ollama's extractor does not parse into a
+`tool_calls` array, `reasoning_effort` stops doing anything (the embedded template
+has no such variable), and a single tool call can come back twice (seen once on the
+27B; cause inferred, not confirmed — see [Known limitations](#known-limitations)).
+Setting `OLLAMA_GO_TEMPLATE=1` or `=0` on the Ollama server forces one template or
+the other for every model.
 
 ### Tool / function calling
 
-The model emits whichever format the system prompt specifies. The Ollama path pins JSON. On llama.cpp the template defaults to XML, the model's native form and the only one llama-server's tool-call parser reads; `tool_call_format: "auto"` is an opt-in for loaders that pass arguments through as strings (below).
+The model emits whichever format the prompt specifies, and the two paths specify
+different ones: the Ollama path pins JSON-in-XML, while the llama.cpp path gets
+Qwen's native XML form from the template embedded in the GGUF.
 
 **Ollama path** (this repo's `Modelfile`). The TEMPLATE advertises tools inside `<tools>…</tools>` and asks the model to reply in JSON-in-XML — the form Ollama's tool-call extractor parses into a structured `tool_calls` array on `/api/chat` and `/v1/chat/completions`. The tool definitions go in with `{{ json .Function }}`: on Ollama 0.14 and later a bare `{{ .Function }}` prints Go struct syntax instead of JSON ([ollama/ollama#14601](https://github.com/ollama/ollama/issues/14601); fix proposed in [ollama/ollama#18391](https://github.com/ollama/ollama/pull/18391)). The model replies like this:
 
@@ -655,7 +691,7 @@ The model emits whichever format the system prompt specifies. The Ollama path pi
 </tool_call>
 ```
 
-**Embedded-jinja path** (llama.cpp, llama-cpp-python, LM Studio). The bundled GGUF already embeds `chat_template.jinja`, so this path works as-is. Like the upstream Qwen 3.8 template, it defaults to the XML form:
+**Embedded-template path** (llama.cpp, llama-cpp-python, LM Studio, KoboldCpp). The bundled GGUF carries Qwen 3.6's own template, so `--jinja` alone is enough — there is no file to pass and nothing to stamp. It teaches the XML form:
 
 ```text
 <tool_call>
@@ -667,56 +703,11 @@ Tokyo
 </tool_call>
 ```
 
-**Keep XML on llama-server.** llama-server recognises this template as Qwen3-Coder-style and parses the model's reply with a parser — and, once the model opens `<tool_call>`, a grammar — that accept only `<function=…><parameter=…>`. A prompt that teaches the JSON form gets replies that parser cannot read. 0.3.0 to 0.4.0 defaulted to `auto`; 0.5.0 went back to `xml` for that reason.
-
-**Replayed tool calls render on llama-server.** Every OpenAI-compatible client hands assistant tool calls back with `function.arguments` as a JSON **string**, and the XML parameter form needs the individual key/value pairs — a chat template has `tojson` but no inverse. llama-server decodes the string into a mapping before it renders the template, so the second turn of a tool call renders in XML with no error. Tested on 2026-09-14 with a 260K-parameter test model and this template, replaying a call whose `arguments` was the string `{"city": "Paris"}`: `/apply-template` and `/v1/chat/completions` returned HTTP 200 with the call rendered as `<parameter=city>` on llama.cpp master `97e4ca7`, b10760 (the llama-server Ollama 0.33.3 bundles) and b10519 (LM Studio's avx2 CPU runtime 2.30.0).
-
-**Other loaders, checked 2026-09-14.** KoboldCpp v1.120 renders the template with Python's jinja2 only when run with `--jinja --jinja_tools` (without `--jinja_tools`, requests with tools skip the template), and parses JSON-string `arguments` with `json.loads` first: with this template and a string-argument replay it returned HTTP 200 and rendered the call as XML (tested with a 260K-parameter model). Jan runs llama.cpp's own server code — v0.8.4 downloads `llama-server` from the janhq/llama.cpp fork (b9967), and its main branch links ggml-org llama.cpp b10809 — so it inherits the conversion above (from source, untested). The LM Studio app renders templates with its own JavaScript Jinja engine rather than llama-server's, and also parses the arguments first: through LM Studio 0.4.24's `/v1/chat/completions` (CPU runtime avx2 2.37.0, a 260K-parameter model carrying this template) a string-argument replay returned HTTP 200 with the call rendered as XML, and a request whose `arguments` were not valid JSON returned HTTP 500 before the template ran, with or without `tool_call_format: "auto"`. If a loader does raise the message below, change `'xml'` to `'auto'` in the template's `_requested_tool_format` default (in LM Studio, under the model's Prompt Template setting).
+**Keep XML on llama-server.** llama-server recognises this template as Qwen3-Coder-style and parses the model's reply with a parser — and, once the model opens `<tool_call>`, a grammar — that accept only `<function=…><parameter=…>`. Qwen 3.6's tool-instruction literal is byte-identical to Qwen 3.8's (compared 2026-09-18), so the detection and the wire format are exactly what this card documented before the reversal. What is gone is the `tool_call_format` knob: the JSON opt-in described in releases 0.3.0 through 0.6.5 lived in the patched 3.8 template this repo no longer ships.
 
-A loader that hands the template the raw string instead gets this raise under the default:
-
-```text
-tool_call_format="xml" requires tool-call arguments to be mappings, but received
-a JSON string. Parse the JSON string into a mapping before applying the template,
-or set tool_call_format="auto" (or "json") to use the lossless JSON tool-call
-representation.
-```
+**Replayed tool calls: normalise `arguments` first.** Every OpenAI-compatible client hands assistant tool calls back with `function.arguments` as a JSON **string**, while the XML parameter form needs the individual key/value pairs — a chat template has `tojson` but no inverse. Qwen 3.6's template renders `<parameter=…>` only when `arguments` is a mapping; handed a string it emits that string as-is inside `<function=…>`, carrying upstream's own comment that you should "normalize arguments to a dict in your serving layer before applying this template". It does **not** raise, so a loader that passes the string straight through produces a silently malformed prompt rather than an error — the failure is quieter here than it was under the 3.8 template, which raised and returned HTTP 500.
 
-For those, `tool_call_format` also accepts `auto` — the whole prompt in JSON form whenever a historical tool call carries string arguments, byte-identical to `xml` when every argument is a mapping — and `json`. Pass it with `--chat-template-kwargs` or a request's `chat_template_kwargs`:
-
-```bash
-llama-server -m Janus-27B.Q4_K_M.gguf --jinja \
-  --chat-template-kwargs '{"tool_call_format":"auto"}'
-```
-
-On llama-server `auto` changes nothing, because arguments reach the template as mappings; do not set `json` there, for the parser reason above.
-
-**`chat_template.jinja` in this repo is the base model's own template with two deliberate changes,** each marked `CHANGED FROM UPSTREAM` in the file: `preserve_thinking` / `preserve_reasoning` never raise — when they disagree `preserve_thinking` wins, where upstream raises and llama-server returns HTTP 500 — while earlier turns' reasoning is replayed by default, as upstream does (see [Thinking is replayed across turns](#thinking-is-replayed-across-turns)); and `reasoning_effort` is normalised instead of validated (see [Reasoning effort](#reasoning-effort)). The tool-call format, `max_tool_arg_chars`, `auto_disable_thinking_with_tools`, the vision handling and the whitespace contract are upstream's. The stock template still raises on `reasoning_effort: "max"`, which llama-server passes to the template, so run an unstamped quant with this file:
-
-```bash
-llama-server -m Janus-27B.Q4_K_M.gguf --jinja --chat-template-file chat_template.jinja
-```
-
-With it the same client code should work against either server, as long as both return a parsed `tool_calls` array — verified on Ollama and on standalone llama-server (llama.cpp master `a2878d3` and b10760, under the earlier `auto` default); the prompt format underneath differs (see [Which template Ollama runs](#which-template-ollama-runs)).
-
-> **The bundled GGUF already carries this template — you do not need the flag.**
-> `Janus-27B.Q4_K_M.gguf` has `chat_template.jinja` stamped into its
-> metadata, so a loader that reads the *embedded* template and parses Qwen's
-> `<tool_call>` output gets working tool calls with no configuration: llama-server
-> (tested on llama.cpp master `a2878d3` and b10760) and LM Studio's CPU runtime
-> (llama.cpp b10519, tested). llama-cpp-python renders the tools but, per its
-> source, does not parse `<tool_call>` output into `tool_calls`. KoboldCpp (with
-> `--jinja --jinja_tools`) was tested and Jan checked from source; see above. `./scripts/build.sh` (`make build`) stamps it into every quant it builds,
-> too. The `--chat-template-file` flag above is only needed for a GGUF that was
-> not built or stamped that way — a quant pulled straight from upstream, for
-> instance. To restamp one you already have:
->
-> ```bash
-> python3 scripts/strip_mtp.py IN.gguf OUT.gguf --chat-template chat_template.jinja
-> ```
->
-> On an already-MTP-clean input that rewrites the file purely to swap the template;
-> tensor data is copied byte-for-byte either way, so there is no re-quantization.
+In practice the loaders convert before rendering: llama-server decodes the string into a mapping, KoboldCpp (`--jinja --jinja_tools`) runs `json.loads` first, and the LM Studio app parses the arguments before its own JavaScript Jinja engine renders. All three were checked on 2026-09-14 against the 3.8 template this repo shipped then; the conversion is loader-side, so it applies unchanged here (from source for this template — not re-tested on this blob).
 
 #### Example (Ollama, OpenAI-compatible API)
 
@@ -753,36 +744,36 @@ print(resp.choices[0].message.tool_calls)
 
 - Use direct prompts ("Call X for Y") rather than soft hints ("Use the tool"). The model thinks before committing to a call, and weak prompts can exhaust `num_predict` inside the `<think>` block before the call is emitted.
 - Allow at least `num_predict: 1024` (or `max_tokens: 1024`) for tool-calling turns, more if the schemas are large.
-- The JSON-in-XML format is what Ollama's tool-call extractor understands, and the Go template pins it. `chat_template.jinja` renders the XML `<function=…>` form unless a replayed call carries string arguments, so the prompt format does change when you swap loaders. Client code should not have to, as long as the server returns a parsed `tool_calls` array — verified on Ollama and on standalone llama-server (llama.cpp master `a2878d3` and b10760).
+- The JSON-in-XML format is what Ollama's tool-call extractor understands, and the Go template pins it; the GGUF's embedded template renders the XML `<function=…>` form. So the prompt format does change when you swap loaders, while client code should not have to, as long as the server returns a parsed `tool_calls` array.
 
 ## Known limitations
 
-- **On the embedded-template path, a single tool call can come back twice.** In one test Ollama 0.33.3, running the embedded template, returned a first-turn tool call twice. A separate raw generation showed the model drafting the call inside `<think>` before emitting it once after `</think>`, so the parser most likely matched such a draft (inferred, not confirmed). It did not reproduce on standalone llama.cpp master (`a2878d3`, CPU): across both models, 12 first-turn calls (three prompts, with and without `parallel_tool_calls`) and two streamed runs each came back exactly once. Nor on b10760, the llama.cpp build Ollama 0.33.3 bundles and the one the duplicate came through: six more first-turn calls and a streamed run on this model each came back once. LM Studio's CPU engine (llama.cpp b10519) passed the same checks; the LM Studio app's own API layer is untested. Ollama's default path — the Go template, see [Which template Ollama runs](#which-template-ollama-runs) — returned one call in a comparable test; whether the prompt or the parser makes the difference was not isolated. If your client executes tools wherever the embedded template renders (llama.cpp, LM Studio, or Ollama with `OLLAMA_GO_TEMPLATE=0`), drop identical consecutive calls.
-- **No mmproj in this release.** The base Qwen3.8 supports image and video input via a separate `mmproj` file, which is not included here. Text-only inference works out of the box; multimodal inference requires fetching `Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf` (or equivalent) from upstream — run `./scripts/fetch_vision.sh` and see [Vision](#vision) for the full path.
+- **On the embedded-template path, a single tool call can come back twice.** Seen on the dense 27B blob, not re-tested here: in one test Ollama 0.33.3, running the embedded template, returned a first-turn tool call twice. A separate raw generation showed the model drafting the call inside `<think>` before emitting it once after `</think>`, so the parser most likely matched such a draft (inferred, not confirmed). It did not reproduce on standalone llama.cpp master (`a2878d3`, CPU): across both models, 12 first-turn calls (three prompts, with and without `parallel_tool_calls`) and two streamed runs each came back exactly once. Nor on b10760, the llama.cpp build Ollama 0.33.3 bundles and the one the duplicate came through: six more first-turn calls and a streamed run on this model each came back once. LM Studio's CPU engine (llama.cpp b10519) passed the same checks; the LM Studio app's own API layer is untested. Ollama's default path — the Go template, see [Which template Ollama runs](#which-template-ollama-runs) — returned one call in a comparable test; whether the prompt or the parser makes the difference was not isolated. If your client executes tools wherever the embedded template renders (llama.cpp, LM Studio, or Ollama with `OLLAMA_GO_TEMPLATE=0`), drop identical consecutive calls.
+- **No mmproj in this release.** The base Qwen 3.6 35B-A3B supports image and video input via a separate `mmproj` file, which is not included here. Text-only inference works out of the box; multimodal inference requires fetching `Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf` (or equivalent) from upstream — run `./scripts/fetch_vision.sh` and see [Vision](#vision) for the full path.
 - **Quantization-induced quality loss.** Q4_K_M is a strong general-purpose quant but does measurably degrade math and code accuracy compared to BF16. If you need maximum quality, run the upstream safetensors on a host with room for the full BF16 weights.
-- **No MTP head on the GGUF path.** The base preserves the multi-token-prediction (NextN) block, but stock llama.cpp and Ollama can't load it, so the bundled quant is MTP-stripped (see [Architecture](#architecture)). No speculative decoding here — use the upstream safetensors under vLLM / SGLang, or an unstripped quant from the source GGUF repo, if you need it.
-- **Dense, so the whole model is resident.** There's no expert sparsity to hide behind: all 27B parameters are touched on every token, and the ~16.5 GiB weights-plus-compute footprint is a floor, not an average. Trim `num_ctx` to fit a smaller host — there is no expert-offload trick to fall back on.
-- **Thinking traces can loop.** Like most reasoning-distilled models, Janus-27B occasionally gets stuck repeating itself inside `<think>` tags. Mitigations: lower temperature to 0.4-0.6, raise `repeat_penalty` to 1.08, or set a `<think>`-token budget cap if your loader supports it.
+- **No MTP head on the GGUF path.** The base declares a multi-token-prediction layer (`mtp_num_hidden_layers: 1`), but the Q4_K_M published in llmfan46's GGUF repo — the file this repo bundles — carries no NextN block at all (see [Architecture](#architecture)). No speculative decoding here: use the upstream safetensors under vLLM / SGLang, or llmfan46's separate `…-Native-MTP-Preserved-GGUF` variant, if you need it.
+- **Sparse compute, dense memory.** Only ~3B of ~34.7B parameters are touched per token, but every expert has to be resident: the 19.78 GiB of weights is a floor whatever the routing does, and MoE sparsity buys compute, not RAM. What it does buy on the memory side is a small KV cache — 0.625 GiB per 32K at f16, under a third of a comparable dense stack — so long contexts are unusually cheap here relative to the weights.
+- **Thinking traces can loop.** Like most reasoning-distilled models, Janus-35B occasionally gets stuck repeating itself inside `<think>` tags. Mitigations: lower temperature to 0.4-0.6, raise `repeat_penalty` to 1.08, or set a `<think>`-token budget cap if your loader supports it.
 - **Large tool-call arguments can be dropped.** Ollama's JSON-in-XML tool format makes the model JSON-escape the entire arguments object inline; for a big/complex payload (e.g. a file's `content` in a `write_file` call) the model can fail to escape it, so the field arrives `undefined` and the call fails. Qwen's native `<function=…><parameter=…>` format (raw values, no escaping) was tested as a fix but parses unreliably through Ollama, so the template deliberately keeps JSON-in-XML. Mitigation: write large files in smaller pieces per call.
 - **Uncensored base — not aligned with any specific safety policy.** This is a personal repackage of an open-weight base whose refusal behavior has been abliterated away (the llmfan46 Heretic base). There is no RLHF refusal layer; the model will attempt most requests, so downstream safety is entirely the operator's responsibility.
-- **No formal evaluation in this card.** The hardware table is fit estimates from the memory math — the measured throughput figures are 4.97 tok/s on CPU and a short partial-GPU-offload series on the same Ryzen AI Max+ 395, and the pre-rebase numbers were dropped rather than carried over. No task benchmarks are claimed either. If you produce real numbers (tok/s, MMLU, HumanEval, …) and want them included, file a PR.
+- **No formal evaluation in this card, and no throughput figures at all.** The hardware table is derived from the GGUF's geometry, not measured on this blob, and every tok/s number the card used to carry was measured on the dense 27B and has been removed rather than rescaled. No task benchmarks are claimed either. If you produce real numbers (tok/s, MMLU, HumanEval, …) and want them included, file a PR.
 
 ## Related models
 
 | Model | Size | Notes |
 |---|---|---|
-| [llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) | 27B dense | **Immediate base.** Uncensored Heretic (MPOA-style) abliteration of Qwen 3.8 27B, with the MTP head preserved; `transformers`-native safetensors. |
-| [llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF) | 27B dense | Heretic GGUFs — BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S, Q5_K_M, Q5_K_S, Q6_K, Q8_0, plus the BF16 mmproj. MTP-preserved, so strip before loading on llama.cpp / Ollama; the bundled Q4_K_M is this quant, already stripped. |
-| [Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B) | 27B dense | Upstream pre-Heretic base model. `transformers`-native multimodal weights. |
-| [FoolDev/Thanatos-27B-HERETIC](https://huggingface.co/FoolDev/Thanatos-27B-HERETIC) | 27B dense | Sibling on the same Qwen 3.8 27B architecture, abliterated the other way — the ARA-based [`heretic-org/Qwen3.8-27B-heretic-ara`](https://huggingface.co/heretic-org/Qwen3.8-27B-heretic-ara). Same teacher (Fable 5), same dataset family. (The older `FoolDev/Thanatos-27B` and `Thanatos-27B-Heretic` slugs now 307 to this path.) |
-| [Crownelius/Crow-9B-HERETIC-4.6](https://huggingface.co/Crownelius/Crow-9B-HERETIC-4.6) | 9B dense | Heretic-flavored fine-tune on a smaller 9B Qwen base. Useful as a fast first-pass model when 27B is too heavy for the host. |
+| [llmfan46/Qwen3.6-35B-A3B-uncensored-heretic](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic) | 35B-A3B MoE | **Immediate base.** Uncensored Heretic abliteration of Qwen 3.6 35B-A3B; `transformers`-native safetensors, and the only place the MTP layer survives. |
+| [llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF) | 35B-A3B MoE | Heretic GGUFs — BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S, Q5_K_M, Q5_K_S, Q6_K, Q8_0, plus the BF16 mmproj. MTP-clean, so they load as-is; the bundled Q4_K_M **is** this repo's Q4_K_M, byte-for-byte. |
+| [Qwen/Qwen3.6-35B-A3B](https://huggingface.co/Qwen/Qwen3.6-35B-A3B) | 35B-A3B MoE | Upstream pre-Heretic base model. `transformers`-native multimodal weights. |
+| [FoolDev/Thanatos-27B-HERETIC](https://huggingface.co/FoolDev/Thanatos-27B-HERETIC) | 27B dense | Sibling repo, and now a genuinely different model: a **dense Qwen 3.8 27B**, abliterated from the ARA-based [`heretic-org/Qwen3.8-27B-heretic-ara`](https://huggingface.co/heretic-org/Qwen3.8-27B-heretic-ara). Same teacher (Fable 5), same tooling, newer Qwen generation, no experts. Pick Thanatos for a smaller resident footprint and a dense compute profile; pick Janus for 35B-class capacity at ~3B active. (The older `FoolDev/Thanatos-27B` and `Thanatos-27B-Heretic` slugs now 307 to this path.) |
+| [Crownelius/Crow-9B-HERETIC-4.6](https://huggingface.co/Crownelius/Crow-9B-HERETIC-4.6) | 9B dense | Heretic-flavored fine-tune on a smaller 9B Qwen base. Useful as a fast first-pass model when 35B is too heavy for the host. |
 
-> **Janus vs Thanatos.** After this rebase the two are the *same* model on paper: dense Qwen 3.8 27B, 64 layers, the same hybrid Gated-DeltaNet / Gated-Attention stack, the same 262,144 native window, the same Claude Fable 5 teacher slot and dataset family. The only real difference is which abliteration sits underneath — Janus on llmfan46's Heretic / MPOA-style, MTP-preserved base, Thanatos on heretic-org's ARA base; both bundles are MTP-stripped for the same llama.cpp / Ollama reason. Janus is **not** bigger, **not** a mixture-of-experts, and **not** architecturally distinct from its sibling; choose between them on how each abliteration behaves, not on capacity. (This repo used to ship a 35B-A3B MoE build, which is where the `Janus-35B-HERETIC` slug comes from; the model it names is now the dense 27B described above.)
+> **Janus vs Thanatos.** Since 0.7.0 the two are genuinely different models, not two abliterations of one base. **Janus** is Qwen 3.6 **35B-A3B**: a mixture of experts, ~34.7B parameters total with ~3B active per token, 40 layers, 256 experts (8 routed + 1 shared), on llmfan46's Heretic base, and its bundled quant is MTP-clean so no strip is needed. **Thanatos** is a dense Qwen 3.8 **27B** — every parameter on every token, 64 layers — on heretic-org's ARA base, and its bundle *is* MTP-stripped, because that base ships the NextN block. They still share the 262,144 native window, the ChatML frame, the Claude Fable 5 teacher slot and this repo's tooling. Choose on shape, not only on abliteration: Janus for 35B-class capacity at ~3B active and a KV cache under a third the size (0.625 vs 2 GiB per 32K at f16), Thanatos for the smaller resident footprint (16.1 vs 19.78 GiB of weights) and a newer Qwen generation.
 
 ## Credits
 
-- Immediate base: [llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved](https://huggingface.co/llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved) — Heretic-style (MPOA, MTP-preserved) abliteration of Qwen 3.8 27B
-- Upstream base: [Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B) (Alibaba)
+- Immediate base: [llmfan46/Qwen3.6-35B-A3B-uncensored-heretic](https://huggingface.co/llmfan46/Qwen3.6-35B-A3B-uncensored-heretic) — Heretic-style abliteration of Qwen 3.6 35B-A3B
+- Upstream base: [Qwen/Qwen3.6-35B-A3B](https://huggingface.co/Qwen/Qwen3.6-35B-A3B) (Alibaba)
 - Reasoning teacher: Claude Fable 5 (Anthropic)
 - Distillation lineage and dataset curation: [Crownelius](https://huggingface.co/Crownelius)
 

chat_template.jinja

@@ -1,642 +0,0 @@
-{#- Janus-27B chat template for llama.cpp / llama-server (--jinja).
-
-    This is the base model's own embedded template (qwen3.8-safe-v3.1), with
-    two deliberate changes, each marked CHANGED FROM UPSTREAM in place:
-      1. `preserve_thinking` and `preserve_reasoning` never raise: when both are
-         set, `preserve_thinking` wins, where upstream raises on conflicting
-         values. Earlier turns' reasoning is replayed by default, as upstream
-         has it;
-      2. `reasoning_effort` is normalised instead of validated, so an unfamiliar
-         value falls back to the default rather than failing the request.
-
-    `tool_call_format` defaults to 'xml', as upstream ships it. 0.3.0 to 0.4.0
-    of this repo defaulted to 'auto'; 0.5.0 went back. llama-server parses this
-    template's output with its Qwen3-Coder parser, whose grammar accepts only
-    the XML form <tool_call><function=NAME><parameter=ARG>, and it turns a
-    client's JSON-string `function.arguments` into a mapping before rendering, so
-    a replayed tool call renders as XML there under either default and nothing
-    raises. Pinning 'xml' keeps the prompt in the only form that parser reads.
-
-    'auto' stays available for a loader that hands the template the raw JSON
-    string: the XML parameter form needs the individual key/value pairs and a
-    chat template has `tojson` but no inverse, so under 'xml' the template
-    raises there; 'auto' renders the whole prompt in JSON form instead. Opt in
-    through the loader's template kwargs, e.g.
-    chat_template_kwargs: {"tool_call_format": "auto"}. On llama-server 'auto'
-    changes nothing, since arguments arrive as mappings; 'json' would break its
-    parser.
-
-    Nothing else is modified. max_tool_arg_chars,
-    auto_disable_thinking_with_tools, the vision handling and the whitespace
-    contract are all upstream's. This file is what scripts/build.sh stamps into
-    the GGUF it builds.
-
-    Guarded by scripts/check_chat_template.py (check 8 in scripts/check.sh).
--#}
-{%- set template_version = "qwen3.8-safe-v3.1" %}
-{#- -------------------------------------------------------------------------
-    Whitespace contract: every tag opener in this file carries a leading minus,
-    so it strips the whitespace and newlines that precede it. All emitted text
-    comes from string literals, which makes the rendered prompt byte-exact and
-    free of incidental newlines. Comment tags need the minus just as much as
-    block tags do; a plain comment tag breaks the strip chain and leaks the
-    surrounding indentation into the prompt.
-    ------------------------------------------------------------------------- -#}
-{#- The message list has to exist before anything else can inspect it. -#}
-{%- if not messages %}
-    {{- raise_exception('No messages provided.') }}
-{%- endif %}
-{#- -------------------------------------------------------------------------
-    Configuration
-    ------------------------------------------------------------------------- -#}
-{#- The default is 'xml', as upstream ships it (0.3.0 to 0.4.0 of this repo used
-    'auto'; see the header and "Resolve the tool-call wire format" below). -#}
-{%- set _requested_tool_format =
-    tool_call_format if tool_call_format is defined else 'xml'
-%}
-{%- if _requested_tool_format not in ('auto', 'xml', 'json') %}
-    {{- raise_exception(
-        'Unexpected tool_call_format ' ~ _requested_tool_format ~
-        '. Supported values are xml (the default), auto, and json.'
-    ) }}
-{%- endif %}
-{%- set add_vision_id = add_vision_id if add_vision_id is defined else false %}
-{%- set enable_thinking = enable_thinking if enable_thinking is defined else true %}
-{%- set auto_disable_thinking_with_tools =
-    auto_disable_thinking_with_tools
-    if auto_disable_thinking_with_tools is defined
-    else false
-%}
-{#- CHANGED FROM UPSTREAM: upstream raises when preserve_reasoning and
-    preserve_thinking are both set to different values, and otherwise lets
-    preserve_reasoning win. llama-server from b10763 passes
-    preserve_reasoning=true unless run with --no-reasoning-preserve, and a
-    request's preserve_thinking kwarg replaces the copy it derives from that, so
-    a request sending preserve_thinking=false made upstream raise there, as
-    preserve_thinking=true did against --no-reasoning-preserve on any build;
-    llama-server returns the raise as an HTTP 500. Here preserve_thinking wins
-    and nothing raises. With neither set, earlier turns' reasoning is replayed, as upstream
-    does. -#}
-{%- if preserve_thinking is defined and preserve_thinking is not none %}
-    {%- set _preserve_thinking = preserve_thinking %}
-{%- elif preserve_reasoning is defined and preserve_reasoning is not none %}
-    {%- set _preserve_thinking = preserve_reasoning %}
-{%- else %}
-    {%- set _preserve_thinking = true %}
-{%- endif %}
-{%- set max_tool_arg_chars =
-    max_tool_arg_chars if max_tool_arg_chars is defined else 0
-%}
-{%- set max_tool_response_chars =
-    max_tool_response_chars if max_tool_response_chars is defined else 0
-%}
-{%- if max_tool_arg_chars is not number or max_tool_arg_chars < 0 %}
-    {{- raise_exception('max_tool_arg_chars must be a non-negative number.') }}
-{%- endif %}
-{%- if max_tool_response_chars is not number or max_tool_response_chars < 0 %}
-    {{- raise_exception('max_tool_response_chars must be a non-negative number.') }}
-{%- endif %}
-{%- if tools is defined and tools is not none and tools %}
-    {%- if tools is string or tools is mapping or tools is not iterable %}
-        {{- raise_exception('tools must be an iterable list of tool definitions.') }}
-    {%- endif %}
-    {%- set _has_tools = true %}
-{%- else %}
-    {%- set _has_tools = false %}
-{%- endif %}
-{#- -------------------------------------------------------------------------
-    Resolve the tool-call wire format.
-
-    OpenAI-compatible servers hand assistant tool calls back with
-    `function.arguments` as a JSON *string*, not a mapping. The XML parameter
-    form needs the individual key/value pairs, and a chat template cannot
-    decode a JSON string: the standard chat-template environment provides
-    `tojson` but no inverse, and no codepoint-to-character primitive, so a
-    hand-rolled scanner could not decode \uXXXX escapes correctly. Guessing
-    would silently corrupt tool arguments, which is worse than any error.
-
-    The default is XML, matching Qwen's native tool-call wire format and the
-    Qwen3-Coder parser llama-server uses for this template - that parser and its
-    grammar accept nothing else. llama-server converts JSON-string arguments to
-    mappings before rendering, so they never reach this check there. 'auto'
-    (opt-in) renders the whole prompt in JSON form whenever a historical tool
-    call carries string arguments. That path is lossless, needs no decoding, and
-    keeps the system-prompt instructions and rendered history in one consistent
-    format. Histories whose arguments are all mappings still render as XML,
-    byte-identically to tool_call_format='xml'.
-
-    Under 'xml', the default, a caller still
-    gets a hard error for non-empty string arguments, because that request
-    cannot be honoured faithfully in the native XML parameter representation.
-    ------------------------------------------------------------------------- -#}
-{%- set format_scan = namespace(has_json_string_arguments=false) %}
-{%- for message in messages %}
-    {%- if message.role == 'assistant'
-           and message.tool_calls is defined
-           and message.tool_calls is not none
-           and message.tool_calls
-           and message.tool_calls is not string
-           and message.tool_calls is not mapping
-           and message.tool_calls is iterable %}
-        {%- for tool_call in message.tool_calls %}
-            {%- if tool_call.function is defined
-                   and tool_call.function is not none %}
-                {%- set _tc = tool_call.function %}
-            {%- else %}
-                {%- set _tc = tool_call %}
-            {%- endif %}
-            {%- if _tc.arguments is defined
-                   and _tc.arguments is not none
-                   and _tc.arguments is string
-                   and _tc.arguments | trim
-                   and _tc.arguments | trim != '{}' %}
-                {%- set format_scan.has_json_string_arguments = true %}
-            {%- endif %}
-        {%- endfor %}
-    {%- endif %}
-{%- endfor %}
-{%- if _requested_tool_format == 'auto' %}
-    {%- if format_scan.has_json_string_arguments %}
-        {%- set _tool_format = 'json' %}
-    {%- else %}
-        {%- set _tool_format = 'xml' %}
-    {%- endif %}
-{%- else %}
-    {%- set _tool_format = _requested_tool_format %}
-{%- endif %}
-{%- set _thinking_enabled = enable_thinking %}
-{%- if auto_disable_thinking_with_tools and _has_tools %}
-    {%- set _thinking_enabled = false %}
-{%- endif %}
-{#- Normalize and validate reasoning effort even when thinking is disabled.
-    Explicit null follows the template default; OpenAI-style `minimal` maps to
-    low, while `none` disables thinking for this render. -#}
-{#- CHANGED FROM UPSTREAM: normalise instead of raising. Clients do not agree on
-    the vocabulary - OpenAI-style minimal/low/medium/high, xhigh, the "max" that
-    Ollama's own /v1 layer sends for xhigh and ultra, mixed case - and upstream
-    raised on anything off its list. Under Ollama >= 0.33 and
-    llama-server a template raise is an HTTP 500 for the entire request, so one
-    unfamiliar effort word made the model unusable. Values are lower-cased and
-    trimmed, aliases map to the nearest tier, and anything unrecognised falls back
-    to the medium default instead of failing the request. -#}
-{%- if reasoning_effort is undefined or reasoning_effort is none %}
-    {%- set _effort_raw = '' %}
-{%- else %}
-    {%- set _effort_raw = reasoning_effort | string | lower | trim %}
-{%- endif %}
-{%- if _effort_raw in ('none', 'off', 'disabled', 'false') %}
-    {%- set _thinking_enabled = false %}
-    {%- set _reasoning_effort = 'xhigh' %}
-{%- elif _effort_raw in ('xhigh', 'high', 'max', 'ultra', 'maximum', 'highest', 'x-high', 'x_high', 'extra-high', 'extra_high', 'very-high', 'very_high') %}
-    {%- set _reasoning_effort = 'xhigh' %}
-{%- elif _effort_raw in ('low', 'minimal', 'min') %}
-    {%- set _reasoning_effort = 'low' %}
-{%- else %}
-    {#- medium, empty, auto, default, and anything unrecognised -#}
-    {%- set _reasoning_effort = 'medium' %}
-{%- endif %}
-{%- set reasoning_instructions = '' %}
-{%- if _thinking_enabled %}
-    {%- if _reasoning_effort == 'xhigh' %}
-        {%- set reasoning_instructions =
-            'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.'
-        %}
-    {%- elif _reasoning_effort == 'low' %}
-        {%- set reasoning_instructions =
-            'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.'
-        %}
-    {%- endif %}
-{%- endif %}
-{#- -------------------------------------------------------------------------
-    Content rendering
-    ------------------------------------------------------------------------- -#}
-{%- set image_count = namespace(value=0) %}
-{%- set video_count = namespace(value=0) %}
-{%- macro render_content(content, do_vision_count, is_system_content=false) %}
-    {%- if content is string %}
-        {{- content }}
-    {%- elif content is iterable and content is not mapping %}
-        {%- for item in content %}
-            {%- if item is not mapping %}
-                {{- raise_exception(
-                    'Content-list items must be mappings with a supported text, image, or video type.'
-                ) }}
-            {%- endif %}
-            {%- set _item_type = item.type if 'type' in item else none %}
-            {%- if _item_type is not none
-                   and _item_type not in ('text', 'image', 'image_url', 'video') %}
-                {{- raise_exception(
-                    'Unexpected content item type ' ~ _item_type ~ '.'
-                ) }}
-            {%- endif %}
-            {%- set _is_image =
-                _item_type == 'image'
-                or _item_type == 'image_url'
-                or 'image' in item
-                or 'image_url' in item
-            %}
-            {%- set _is_video =
-                _item_type == 'video'
-                or 'video' in item
-            %}
-            {%- if _is_image and _is_video %}
-                {{- raise_exception(
-                    'A content item cannot contain both image and video data.'
-                ) }}
-            {%- elif _item_type == 'text' and (_is_image or _is_video) %}
-                {{- raise_exception(
-                    'A text content item cannot also contain image or video data.'
-                ) }}
-            {%- elif _is_image %}
-                {%- if is_system_content %}
-                    {{- raise_exception(
-                        'System and developer messages cannot contain images.'
-                    ) }}
-                {%- endif %}
-                {%- if do_vision_count %}
-                    {%- set image_count.value = image_count.value + 1 %}
-                {%- endif %}
-                {%- if add_vision_id %}
-                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
-                {%- endif %}
-                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
-            {%- elif _is_video %}
-                {%- if is_system_content %}
-                    {{- raise_exception(
-                        'System and developer messages cannot contain videos.'
-                    ) }}
-                {%- endif %}
-                {%- if do_vision_count %}
-                    {%- set video_count.value = video_count.value + 1 %}
-                {%- endif %}
-                {%- if add_vision_id %}
-                    {{- 'Video ' ~ video_count.value ~ ': ' }}
-                {%- endif %}
-                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
-            {%- elif _item_type == 'text' or 'text' in item %}
-                {%- if 'text' not in item or item.text is not string %}
-                    {{- raise_exception(
-                        'Text content items must contain a string text field.'
-                    ) }}
-                {%- endif %}
-                {{- item.text }}
-            {%- else %}
-                {{- raise_exception(
-                    'Unexpected item in content list. Expected text, image, or video content.'
-                ) }}
-            {%- endif %}
-        {%- endfor %}
-    {%- elif content is none or content is undefined %}
-        {{- '' }}
-    {%- else %}
-        {{- raise_exception('Unexpected content type.') }}
-    {%- endif %}
-{%- endmacro %}
-{#- -------------------------------------------------------------------------
-    Validate and merge leading system/developer messages
-    ------------------------------------------------------------------------- -#}
-{%- set head = namespace(count=0, seen_non_system=false) %}
-{%- for message in messages %}
-    {%- set _is_system =
-        message.role == 'system' or message.role == 'developer'
-    %}
-    {%- if _is_system %}
-        {%- if head.seen_non_system %}
-            {{- raise_exception(
-                'System and developer messages must appear before all user, assistant, and tool messages.'
-            ) }}
-        {%- endif %}
-        {%- set head.count = head.count + 1 %}
-    {%- else %}
-        {%- set head.seen_non_system = true %}
-    {%- endif %}
-{%- endfor %}
-{%- set system_state = namespace(content='') %}
-{%- for message in messages[:head.count] %}
-    {%- set _part =
-        render_content(message.content, false, true) | trim
-    %}
-    {%- if _part %}
-        {%- if system_state.content %}
-            {%- set system_state.content =
-                system_state.content ~ '\n\n' ~ _part
-            %}
-        {%- else %}
-            {%- set system_state.content = _part %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- set _system_content = system_state.content %}
-{%- set _msgs = messages[head.count:] %}
-{#- -------------------------------------------------------------------------
-    System prompt and tool instructions
-    ------------------------------------------------------------------------- -#}
-{%- if _has_tools %}
-    {{- '<|im_start|>system\n' }}
-    {%- if reasoning_instructions %}
-        {{- reasoning_instructions ~ '\n\n' }}
-    {%- endif %}
-    {{- '# Tools\n\nYou have access to the following functions:\n\n<tools>' }}
-    {%- for tool in tools %}
-        {{- '\n' }}
-        {{- tool | tojson }}
-    {%- endfor %}
-    {{- '\n</tools>' }}
-    {%- if _tool_format == 'json' %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n{"name": "example_function_name", "arguments": {"example_parameter_1": "value_1", "example_parameter_2": "This is the value for the second parameter"}}\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: a single JSON object with "name" and "arguments" keys must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
-    {%- else %}
-        {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
-    {%- endif %}
-    {%- if _system_content %}
-        {{- '\n\n' ~ _system_content }}
-    {%- endif %}
-    {{- '<|im_end|>\n' }}
-{%- else %}
-    {%- if _system_content %}
-        {{- '<|im_start|>system\n'
-            ~ (reasoning_instructions ~ '\n\n' if reasoning_instructions else '')
-            ~ _system_content
-            ~ '<|im_end|>\n'
-        }}
-    {%- elif reasoning_instructions %}
-        {{- '<|im_start|>system\n'
-            ~ reasoning_instructions
-            ~ '<|im_end|>\n'
-        }}
-    {%- endif %}
-{%- endif %}
-{#- -------------------------------------------------------------------------
-    Find the last real user query
-    ------------------------------------------------------------------------- -#}
-{%- set ns = namespace(
-    multi_step_tool=true,
-    last_query_index=(_msgs | length) - 1
-) %}
-{%- for message in _msgs[::-1] %}
-    {%- set index = (_msgs | length - 1) - loop.index0 %}
-    {%- if ns.multi_step_tool and message.role == 'user' %}
-        {%- set _rendered_user =
-            render_content(message.content, false) | trim
-        %}
-        {%- if not (
-            _rendered_user.startswith('<tool_response>')
-            and _rendered_user.endswith('</tool_response>')
-        ) %}
-            {%- set ns.multi_step_tool = false %}
-            {%- set ns.last_query_index = index %}
-        {%- endif %}
-    {%- endif %}
-{%- endfor %}
-{%- if ns.multi_step_tool %}
-    {{- raise_exception('No user query found in messages.') }}
-{%- endif %}
-{#- -------------------------------------------------------------------------
-    Conversation rendering
-    ------------------------------------------------------------------------- -#}
-{%- set history_state = namespace(previous_role='') %}
-{%- for message in _msgs %}
-    {%- set content =
-        render_content(message.content, true) | trim
-    %}
-    {%- if message.role == 'user' %}
-        {{- '<|im_start|>user\n'
-            ~ content
-            ~ '<|im_end|>\n'
-        }}
-    {%- elif message.role == 'assistant' %}
-        {%- set reasoning_content = '' %}
-        {#- Prefer current vLLM's `reasoning` field, then retain compatibility
-            with older `reasoning_content` and other servers' `thinking`. -#}
-        {%- if message.reasoning is defined
-               and message.reasoning is not none %}
-            {%- if message.reasoning is string %}
-                {%- set reasoning_content = message.reasoning %}
-            {%- else %}
-                {%- set reasoning_content =
-                    message.reasoning | string
-                %}
-            {%- endif %}
-        {%- elif message.reasoning_content is defined
-                 and message.reasoning_content is not none %}
-            {%- if message.reasoning_content is string %}
-                {%- set reasoning_content = message.reasoning_content %}
-            {%- else %}
-                {%- set reasoning_content =
-                    message.reasoning_content | string
-                %}
-            {%- endif %}
-        {%- elif message.thinking is defined
-                 and message.thinking is not none %}
-            {%- if message.thinking is string %}
-                {%- set reasoning_content = message.thinking %}
-            {%- else %}
-                {%- set reasoning_content =
-                    message.thinking | string
-                %}
-            {%- endif %}
-        {%- endif %}
-        {%- set reasoning_content = reasoning_content | trim %}
-        {#- Preserve the original invariant: when thinking is preserved,
-            always reconstruct the thinking block, even when it is empty. -#}
-        {%- if _preserve_thinking
-               or loop.index0 > ns.last_query_index %}
-            {{- '<|im_start|>assistant\n<think>\n'
-                ~ reasoning_content
-                ~ '\n</think>\n\n'
-                ~ content
-            }}
-        {%- else %}
-            {{- '<|im_start|>assistant\n' ~ content }}
-        {%- endif %}
-        {%- if message.tool_calls is defined
-               and message.tool_calls is not none
-               and message.tool_calls %}
-            {%- if message.tool_calls is string
-                   or message.tool_calls is mapping
-                   or message.tool_calls is not iterable %}
-                {{- raise_exception(
-                    'assistant.tool_calls must be an iterable list of tool calls.'
-                ) }}
-            {%- endif %}
-            {%- for tool_call in message.tool_calls %}
-                {%- if tool_call.function is defined
-                       and tool_call.function is not none %}
-                    {%- set tc = tool_call.function %}
-                {%- else %}
-                    {%- set tc = tool_call %}
-                {%- endif %}
-                {%- if tc.name is not defined
-                       or tc.name is none
-                       or tc.name is not string
-                       or not tc.name %}
-                    {{- raise_exception(
-                        'Every tool call must have a non-empty string name.'
-                    ) }}
-                {%- endif %}
-                {%- set tc_name = tc.name %}
-                {%- if _tool_format == 'json' %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n' }}
-                        {%- else %}
-                            {{- '<tool_call>\n' }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n<tool_call>\n' }}
-                    {%- endif %}
-                    {%- set _json_arguments = '{}' %}
-                    {%- if tc.arguments is defined
-                           and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- set _json_arguments =
-                                tc.arguments | tojson
-                            %}
-                        {%- elif tc.arguments is string %}
-                            {%- set _raw_arguments =
-                                tc.arguments | trim
-                            %}
-                            {%- if _raw_arguments %}
-                                {%- if not (
-                                    _raw_arguments.startswith('{')
-                                    and _raw_arguments.endswith('}')
-                                ) %}
-                                    {{- raise_exception(
-                                        'JSON tool-call arguments must be a JSON object string.'
-                                    ) }}
-                                {%- endif %}
-                                {%- set _json_arguments =
-                                    _raw_arguments
-                                %}
-                            {%- endif %}
-                        {%- else %}
-                            {{- raise_exception(
-                                'JSON tool-call arguments must be a mapping or a JSON object string.'
-                            ) }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '{"name": ' }}
-                    {{- tc_name | tojson }}
-                    {{- ', "arguments": ' }}
-                    {{- _json_arguments }}
-                    {{- '}\n</tool_call>' }}
-                {%- else %}
-                    {%- if loop.first %}
-                        {%- if content | trim %}
-                            {{- '\n\n<tool_call>\n<function='
-                                ~ tc_name
-                                ~ '>\n'
-                            }}
-                        {%- else %}
-                            {{- '<tool_call>\n<function='
-                                ~ tc_name
-                                ~ '>\n'
-                            }}
-                        {%- endif %}
-                    {%- else %}
-                        {{- '\n<tool_call>\n<function='
-                            ~ tc_name
-                            ~ '>\n'
-                        }}
-                    {%- endif %}
-                    {%- if tc.arguments is defined
-                           and tc.arguments is not none %}
-                        {%- if tc.arguments is mapping %}
-                            {%- for args_name, args_value
-                                   in tc.arguments | items %}
-                                {%- set _argument_name =
-                                    args_name | string
-                                %}
-                                {{- '<parameter='
-                                    ~ _argument_name
-                                    ~ '>\n'
-                                }}
-                                {#- Preserve strings verbatim. Serialize every
-                                    other type as JSON so booleans and null stay
-                                    true/false/null instead of True/False/None. -#}
-                                {%- if args_value is string %}
-                                    {%- set _argument_value =
-                                        args_value
-                                    %}
-                                {%- else %}
-                                    {%- set _argument_value =
-                                        args_value | tojson
-                                    %}
-                                {%- endif %}
-                                {%- if max_tool_arg_chars > 0
-                                       and _argument_value | length
-                                           > max_tool_arg_chars %}
-                                    {{- _argument_value[:max_tool_arg_chars] }}
-                                    {{- '\n[TRUNCATED — original length '
-                                        ~ (_argument_value | length | string)
-                                        ~ ' chars]'
-                                    }}
-                                {%- else %}
-                                    {{- _argument_value }}
-                                {%- endif %}
-                                {{- '\n</parameter>\n' }}
-                            {%- endfor %}
-                        {%- elif tc.arguments is string %}
-                            {%- set _raw_arguments =
-                                tc.arguments | trim
-                            %}
-                            {%- if _raw_arguments
-                                   and _raw_arguments != '{}' %}
-                                {{- raise_exception(
-                                    'tool_call_format="xml" requires tool-call arguments to be mappings, but received a JSON string. Parse the JSON string into a mapping before applying the template, or set tool_call_format="auto" (or "json") to use the lossless JSON tool-call representation.'
-                                ) }}
-                            {%- endif %}
-                        {%- else %}
-                            {{- raise_exception(
-                                'XML tool-call arguments must be a mapping. Parse JSON-string arguments before applying the template.'
-                            ) }}
-                        {%- endif %}
-                    {%- endif %}
-                    {{- '</function>\n</tool_call>' }}
-                {%- endif %}
-            {%- endfor %}
-        {%- endif %}
-        {{- '<|im_end|>\n' }}
-    {%- elif message.role == 'tool' %}
-        {%- if history_state.previous_role != 'tool' %}
-            {{- '<|im_start|>user' }}
-        {%- endif %}
-        {%- if max_tool_response_chars > 0
-               and content | length > max_tool_response_chars %}
-            {%- set content =
-                content[:max_tool_response_chars]
-                ~ '\n[TRUNCATED — original length '
-                ~ (content | length | string)
-                ~ ' chars]'
-            %}
-        {%- endif %}
-        {{- '\n<tool_response>\n' }}
-        {{- content }}
-        {{- '\n</tool_response>' }}
-        {%- if loop.last %}
-            {{- '<|im_end|>\n' }}
-        {%- elif _msgs[loop.index0 + 1].role != 'tool' %}
-            {{- '<|im_end|>\n' }}
-        {%- endif %}
-    {%- elif message.role == 'system'
-             or message.role == 'developer' %}
-        {{- raise_exception(
-            'System and developer messages must appear only at the beginning of the conversation.'
-        ) }}
-    {%- else %}
-        {{- raise_exception(
-            'Unexpected message role ' ~ message.role ~ '.'
-        ) }}
-    {%- endif %}
-    {%- set history_state.previous_role = message.role %}
-{%- endfor %}
-{#- -------------------------------------------------------------------------
-    Generation prompt
-    ------------------------------------------------------------------------- -#}
-{%- if add_generation_prompt %}
-    {{- '<|im_start|>assistant\n' }}
-    {%- if not _thinking_enabled %}
-        {{- '<think>\n\n</think>\n\n' }}
-    {%- else %}
-        {{- '<think>\n' }}
-    {%- endif %}
-{%- endif %}

examples/README.md

@@ -1,13 +1,13 @@
-# Janus-27B examples
+# Janus-35B examples
 
 Four minimal entry points. Pick the one that matches how you run models.
 
 | File | Backend | When to use |
 |---|---|---|
 | `ollama_chat.py` | Ollama HTTP API | You already have `ollama serve` running and the `janus` model created from the project `Modelfile`. **Text + tool calling** — vision via Ollama is broken upstream for this arch. |
-| `transformers_quickstart.py` | Hugging Face Transformers | You want to run the Heretic safetensors (`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved`) on GPU, optionally in 4-bit via bitsandbytes. |
+| `transformers_quickstart.py` | Hugging Face Transformers | You want to run the Heretic safetensors (`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic`) on GPU, optionally in 4-bit via bitsandbytes. |
 | `llama_cpp_quickstart.py` | llama-cpp-python | You want to invoke a local GGUF directly without a daemon (CI, batch jobs, scripts). Text only. |
-| `llama_cpp_vision.py` | llama-cpp-python + mmproj | **Image input.** Loads a text GGUF + `Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf` and answers questions about an image. The only working vision path right now. |
+| `llama_cpp_vision.py` | llama-cpp-python + mmproj | **Image input.** Loads a text GGUF + `Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf` and answers questions about an image. The only working vision path right now. |
 
 The text clients apply the same Janus system prompt; `llama_cpp_vision.py` uses a task-specific vision prompt. The three non-Ollama scripts
 explicitly pin the model card's tighter-reasoning sampling profile
@@ -27,7 +27,7 @@ root-level `template` / `system` / `params` files via HF's Ollama
 bridge):
 
 ```bash
-ollama pull hf.co/FoolDev/Janus-35B-HERETIC              # bundled Q4_K_M, ~17.3 GB
+ollama pull hf.co/FoolDev/Janus-35B-HERETIC              # bundled Q4_K_M, 21.23 GB
 pip install requests
 MODEL=hf.co/FoolDev/Janus-35B-HERETIC python ollama_chat.py
 ```
@@ -42,8 +42,9 @@ python ollama_chat.py                                   # MODEL defaults to `jan
 
 For a non-bundled quant (e.g. Q3_K_M, Q5_K_M), `./scripts/build.sh`
 downloads it from
-`llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF`,
-runs it through `strip_mtp.py`, patches the `Modelfile` `FROM` line into a
+`llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF`,
+passes it through `strip_mtp.py` (a no-op on those quants — they ship
+MTP-clean), patches the `Modelfile` `FROM` line into a
 temp copy, and creates the local `janus` tag:
 
 ```bash
@@ -54,7 +55,7 @@ python ollama_chat.py
 ### Transformers (safetensors)
 
 ```bash
-pip install --upgrade transformers accelerate sentencepiece bitsandbytes  # needs a build new enough for Qwen 3.8
+pip install --upgrade transformers accelerate sentencepiece bitsandbytes  # needs a build new enough for Qwen 3.6
 python transformers_quickstart.py            # 4-bit (bitsandbytes)
 python transformers_quickstart.py --no-4bit  # bf16
 ```
@@ -63,7 +64,7 @@ python transformers_quickstart.py --no-4bit  # bf16
 
 ```bash
 pip install llama-cpp-python  # CPU-only build
-python llama_cpp_quickstart.py /path/to/Janus-27B.Q4_K_M.gguf
+python llama_cpp_quickstart.py /path/to/Janus-35B-A3B.Q4_K_M.gguf
 ```
 
 For GPU offload, rebuild llama-cpp-python with the matching backend (see
@@ -78,14 +79,14 @@ cd ..  &&  ./scripts/fetch_vision.sh  &&  cd examples
 
 pip install llama-cpp-python pillow
 python llama_cpp_vision.py \
-  --gguf ../Janus-27B.Q4_K_M.gguf \
-  --mmproj ../Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+  --gguf ../Janus-35B-A3B.Q4_K_M.gguf \
+  --mmproj ../Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
   --image /path/to/photo.jpg \
   --prompt "Describe this image."
 ```
 
-Why not Ollama? Ollama's Go engine has the `qwen35` arch entry
-(text inference works in 0.24+), but the C++ llama.cpp fallback that
+Why not Ollama? Ollama's Go engine has the `qwen35moe` arch entry
+(text inference checked in source at 0.33.3, 0.34.0 and 0.34.2), but the C++ llama.cpp fallback that
 Ollama switches to when an mmproj is attached still lacks it.
 `ollama create` accepts the dual-`FROM` and `ollama show` reports
 `vision` capability, but the first inference call fails with an

examples/llama_cpp_quickstart.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Janus-27B — llama-cpp-python quickstart.
+Janus-35B — llama-cpp-python quickstart.
 
 Skip Ollama entirely and call the GGUF directly through llama-cpp-python.
 Useful for batch jobs, CI, or environments where you don't want a daemon.
@@ -14,7 +14,7 @@ For GPU offload (CUDA / Metal / ROCm), install with the matching extras:
     CMAKE_ARGS="-DGGML_HIPBLAS=on" pip install llama-cpp-python --no-binary :all:
 
 Usage:
-    python llama_cpp_quickstart.py /path/to/Janus-27B.Q4_K_M.gguf
+    python llama_cpp_quickstart.py /path/to/Janus-35B-A3B.Q4_K_M.gguf
     python llama_cpp_quickstart.py /path/to/file.gguf --gpu-layers 99
     python llama_cpp_quickstart.py /path/to/file.gguf --prompt "..."
 """
@@ -49,7 +49,7 @@ JANUS_SYSTEM = (
 
 def main() -> None:
     ap = argparse.ArgumentParser()
-    ap.add_argument("gguf", help="Path to Janus-27B GGUF (e.g. Q4_K_M).")
+    ap.add_argument("gguf", help="Path to Janus-35B-A3B GGUF (e.g. Q4_K_M).")
     ap.add_argument(
         "--prompt",
         default="Explain the Burrows-Wheeler transform in 200 words.",

examples/llama_cpp_vision.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-Janus-27B — vision (image-text-to-text) via llama-cpp-python.
+Janus-35B — vision (image-text-to-text) via llama-cpp-python.
 
 Why this script exists:
-    Ollama's Go engine has the qwen35 arch entry (text inference works
+    Ollama's Go engine has the qwen35moe arch entry (text inference works
     on 0.24+), but the C++ llama.cpp fallback that Ollama switches to
     when an mmproj is attached still lacks it. Both `FROM mmproj.gguf`
     and `ADAPTER mmproj.gguf` fail at the first inference call with an
@@ -24,26 +24,26 @@ Install:
     #   CMAKE_ARGS="-DGGML_HIPBLAS=on" pip install llama-cpp-python --no-binary :all:
 
 Files you need:
-    1. A text GGUF (any quant): the bundled Janus-27B.Q4_K_M.gguf (~17 GB),
-       or another quant from
-       llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF
-       — run those through ./scripts/strip_mtp.py first; the source repo's
-       quants are MTP-preserved and stock llama.cpp cannot load them.
+    1. A text GGUF (any quant): the bundled Janus-35B-A3B.Q4_K_M.gguf
+       (21.23 GB), or another quant from
+       llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF
+       — those ship MTP-clean, so no ./scripts/strip_mtp.py pass is needed;
+       only llmfan46's separate -Native-MTP-Preserved-GGUF variant needs it.
     2. A vision projector:
-       Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf
+       Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf
        — run ./scripts/fetch_vision.sh to pull it.
 
 Usage:
     python llama_cpp_vision.py \
-        --gguf   Janus-27B.Q4_K_M.gguf \
-        --mmproj Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+        --gguf   Janus-35B-A3B.Q4_K_M.gguf \
+        --mmproj Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
         --image  /path/to/photo.jpg \
         --prompt "What is in this image? Be specific."
 
     # CLI alternative without python binding (ships with llama.cpp):
     #   llama-mtmd-cli \
-    #     -m Janus-27B.Q4_K_M.gguf \
-    #     --mmproj Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-BF16.gguf \
+    #     -m Janus-35B-A3B.Q4_K_M.gguf \
+    #     --mmproj Qwen3.6-35B-A3B-uncensored-heretic-mmproj-BF16.gguf \
     #     --image photo.jpg \
     #     -p "Describe this image."
 """
@@ -79,7 +79,7 @@ def encode_image_data_uri(path: Path) -> str:
 
 def main() -> None:
     ap = argparse.ArgumentParser()
-    ap.add_argument("--gguf", required=True, help="Text GGUF (e.g. Janus-27B.Q4_K_M.gguf).")
+    ap.add_argument("--gguf", required=True, help="Text GGUF (e.g. Janus-35B-A3B.Q4_K_M.gguf).")
     ap.add_argument("--mmproj", required=True, help="Vision projector GGUF (mmproj-BF16.gguf).")
     ap.add_argument("--image", required=True, help="Image to analyze.")
     ap.add_argument("--prompt", default="Describe this image in detail.")
@@ -98,7 +98,7 @@ def main() -> None:
         sys.exit(f"Image not found: {image_path}")
 
     # Qwen 2.5 VL chat handler is the closest match shipped with
-    # llama-cpp-python; Qwen 3.5 / 3.6 / 3.8 vision uses the same projector
+    # llama-cpp-python; Qwen 3.5 / 3.6 vision uses the same projector
     # layout. If/when llama-cpp-python ships a Qwen3VLChatHandler, swap it in.
     handler = Qwen25VLChatHandler(clip_model_path=args.mmproj)
 

examples/ollama_chat.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Janus-27B — Ollama chat examples.
+Janus-35B — Ollama chat examples.
 
 Prerequisites (pick one):
 

examples/transformers_quickstart.py

@@ -1,22 +1,24 @@
 #!/usr/bin/env python3
 """
-Janus-27B — Hugging Face Transformers quickstart.
+Janus-35B — Hugging Face Transformers quickstart.
 
-Loads the Heretic Qwen 3.8 27B safetensors directly and runs a single
-chat turn using its embedded chat template. Janus-27B is a *wrapper*
+Loads the Heretic Qwen 3.6 35B-A3B safetensors directly and runs a single
+chat turn using its embedded chat template. Janus-35B is a *wrapper*
 around that base, so for the transformers route there is nothing to
 download from this repo — point at
-llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved
+llmfan46/Qwen3.6-35B-A3B-uncensored-heretic
 and apply the same system prompt the Modelfile uses.
 
-Set MODEL_ID = "Qwen/Qwen3.8-27B" to bypass the Heretic abliteration and
+Set MODEL_ID = "Qwen/Qwen3.6-35B-A3B" to bypass the Heretic abliteration and
 load the vanilla upstream base instead.
 
-Note: this is a dense 27B — every parameter runs on every token. There is no
-routing and no active-parameter discount: memory tracks the full 27B.
+Note: this is a mixture-of-experts model — ~34.7B parameters total, ~3B active
+per token (derived from the bundled GGUF's header, 2026-09-18). Transformers
+keeps all 256 experts resident, so memory tracks the ~34.7B total, not the 3B
+active count.
 
 Requirements:
-    pip install --upgrade transformers accelerate sentencepiece bitsandbytes  # needs a build new enough for Qwen 3.8
+    pip install --upgrade transformers accelerate sentencepiece bitsandbytes  # needs a build new enough for Qwen 3.6
 
 Memory:
     - bf16 full precision: multi-GPU or CPU offload.
@@ -44,7 +46,7 @@ except ImportError as e:  # pragma: no cover
     )
 
 
-MODEL_ID = "llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved"
+MODEL_ID = "llmfan46/Qwen3.6-35B-A3B-uncensored-heretic"
 
 JANUS_SYSTEM = (
     "You are Janus, a precise and capable assistant for reasoning, writing, "

scripts/bench.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Janus-27B — tok/s benchmark via Ollama.
+# Janus-35B — tok/s benchmark via Ollama.
 #
 # Reads timing from Ollama's /api/chat response metadata (eval_count and
 # eval_duration are authoritative — no client-side stopwatch noise) and

scripts/build.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Janus-27B — fetch a Qwen 3.8 27B GGUF and build the Ollama model.
+# Janus-35B — fetch a Qwen 3.6 35B-A3B GGUF and build the Ollama model.
 #
 # Usage:
 #   ./scripts/build.sh                       # default: Q4_K_M
@@ -7,16 +7,15 @@
 #   QUANT=Q6_K ./scripts/build.sh
 #
 # Skip the download by pointing at a GGUF you already have:
-#   GGUF_PATH=/path/to/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-Q4_K_M.gguf ./scripts/build.sh Q4_K_M
+#   GGUF_PATH=/path/to/Qwen3.6-35B-A3B-uncensored-heretic-Q4_K_M.gguf ./scripts/build.sh Q4_K_M
 #
 # Note: a `<gguf>.stripped.gguf` sibling is created next to the source GGUF (the
-# MTP-stripped copy) and becomes ollama's FROM target. The upstream quants are
-# MTP-preserved, so that sibling is a real second file rather than a hardlink —
-# budget disk for both. It's gitignored in-repo; for an out-of-repo GGUF_PATH,
-# remove the sibling yourself.
+# MTP-stripped copy — or, for these quants, a hardlink no-op, so no extra disk)
+# and becomes ollama's FROM target. It's gitignored in-repo; for an out-of-repo
+# GGUF_PATH, remove the sibling yourself.
 #
 # Requires: huggingface-cli (or hf), ollama, awk, python3 with the `gguf`
-# package (the MTP strip below is not optional).
+# package (the MTP strip below still runs, defensively).
 set -euo pipefail
 
 # Resolve a Hugging Face CLI. The bare name `hf` is ambiguous: Arch's `hf`
@@ -38,14 +37,14 @@ detect_hf() {
 
 QUANT="${1:-${QUANT:-Q4_K_M}}"
 
-REPO_ID="${REPO_ID:-llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF}"
-# Filenames at
-# llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF follow
-#   Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-${QUANT}.gguf
-# Published quants: BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S, Q5_K_M, Q5_K_S, Q6_K,
-# Q8_0. Check the repo's Files tab if that list has moved on; override GGUF_NAME
-# or GGUF_PATH below if the naming differs for your chosen quant.
-GGUF_NAME="Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-${QUANT}.gguf"
+REPO_ID="${REPO_ID:-llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF}"
+# Filenames at llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF follow
+#   Qwen3.6-35B-A3B-uncensored-heretic-${QUANT}.gguf
+# Published quants (HF API, 2026-09-18): BF16, Q3_K_L, Q3_K_M, Q4_K_M, Q4_K_S,
+# Q5_K_M, Q5_K_S, Q6_K, Q8_0, plus the BF16 mmproj (scripts/fetch_vision.sh).
+# Check the repo's Files tab if that list has moved on; override GGUF_NAME or
+# GGUF_PATH below if the naming differs for your chosen quant.
+GGUF_NAME="Qwen3.6-35B-A3B-uncensored-heretic-${QUANT}.gguf"
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 # GGUF_PATH defaults to ${ROOT}/${GGUF_NAME}, but can be overridden so users
 # with cached weights elsewhere don't have to copy or symlink anything.
@@ -95,34 +94,25 @@ if [[ ! -f "${GGUF_PATH}" ]]; then
     exit 1
 fi
 
-# ---- 2b. Strip the MTP/NextN layer ------------------------------------------
-# REQUIRED, not a safety net. The base is MTP-preserved, so the quants in the
-# source repo carry the MTP/NextN head as an extra block (index 64) that stock
-# llama.cpp / Ollama can't load (aborts on the missing SSM tensor). strip_mtp.py
-# drops that block and sets block_count back to 64; kept tensors are copied
-# byte-for-byte, so no re-quantization and no quality change. Same step the dense
-# sibling FoolDev/Thanatos-27B-HERETIC needs. If you want the MTP head, use the
-# upstream safetensors under vLLM / SGLang, or the unstripped GGUF straight from
-# the source repo — not this path.
+# ---- 2b. Strip the MTP/NextN layer if present -------------------------------
+# Defensive, not a required build step. The quants in the source repo are
+# MTP-clean — Q4_K_M read from its GGUF header on 2026-09-18: block_count 40,
+# blk.0…blk.39 only, no nextn_predict_layers key — so strip_mtp.py finds nothing
+# to drop and passes the file through as a hardlink (no extra disk, no
+# re-quantization). The call stays because llmfan46 also publishes a separate
+# *-Native-MTP-Preserved-GGUF variant whose Q4_K_M has block_count 41 with a
+# NextN block at index 40; point GGUF_PATH at one of those and this step is what
+# makes it loadable on stock llama.cpp / Ollama. No --chat-template here: the
+# GGUF carries the base's own embedded template and this repo ships no
+# chat_template.jinja to stamp over it.
 STRIPPED_PATH="${GGUF_PATH%.gguf}.stripped.gguf"
-# Stamp this repo's chat template into the GGUF in the same pass. llama.cpp,
-# LM Studio, Jan and KoboldCpp all read the template embedded in the GGUF, and
-# the upstream one raises on reasoning_effort values such as "max" and on
-# conflicting preserve_thinking / preserve_reasoning, which llama-server returns
-# as HTTP 500. Stamping it here means those loaders get this repo's template
-# with no extra flags. Skipped if the file is absent.
-STAMP_ARGS=()
-if [[ -f "${ROOT}/chat_template.jinja" ]]; then
-    STAMP_ARGS=(--chat-template "${ROOT}/chat_template.jinja")
-    echo "[*] stamping chat_template.jinja into the built GGUF"
-fi
-python3 "${ROOT}/scripts/strip_mtp.py" "${GGUF_PATH}" "${STRIPPED_PATH}" ${STAMP_ARGS[@]+"${STAMP_ARGS[@]}"}
+python3 "${ROOT}/scripts/strip_mtp.py" "${GGUF_PATH}" "${STRIPPED_PATH}"
 GGUF_PATH="${STRIPPED_PATH}"
 echo "[*] gguf (post-strip): ${GGUF_PATH}"
 
 # ---- 3. Patch the Modelfile FROM line in a temp copy -------------------------
 
-TMP_MODELFILE="$(mktemp -t janus27b-modelfile.XXXXXX)"
+TMP_MODELFILE="$(mktemp -t janus35b-modelfile.XXXXXX)"
 trap 'rm -f "${TMP_MODELFILE}"' EXIT
 awk -v p="${GGUF_PATH}" '
     /^FROM[[:space:]]/ && !done { print "FROM " p; done=1; next }

scripts/cap_ctx.sh

@@ -1,11 +1,12 @@
 #!/usr/bin/env bash
-# Janus-27B — create a small-context local tag for OpenAI /v1 clients.
+# Janus-35B — create a small-context local tag for OpenAI /v1 clients.
 #
 # Ollama's /v1/chat/completions (OpenAI-compatible) silently ignores the
-# `options` field, so it loads at the baked default `num_ctx 262144` — ~34 GiB
-# total with Ollama's default f16 KV cache, which is too much for a tight host. This bakes a local tag with
-# num_ctx overridden to a loadable value (and num_batch 256), which any OpenAI
-# /v1 client can point at.
+# `options` field, so it loads at the baked default `num_ctx 262144` — the
+# 21.23 GB of weights plus a 262K f16 KV cache, which is too much for a tight
+# host (see the README's Hardware requirements for the figures). This bakes a
+# local tag with num_ctx overridden to a loadable value (and num_batch 256),
+# which any OpenAI /v1 client can point at.
 # Reuses this repo's Modelfile verbatim (TEMPLATE / SYSTEM / stop params), only
 # swapping the FROM line to the bundled blob and the num_ctx parameter.
 #
@@ -21,7 +22,7 @@ CTX="${CTX:-4096}"
 NBATCH="${NBATCH:-256}"
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 MODELFILE="${ROOT}/Modelfile"
-GGUF="${GGUF:-${ROOT}/Janus-27B.Q4_K_M.gguf}"
+GGUF="${GGUF:-${ROOT}/Janus-35B-A3B.Q4_K_M.gguf}"
 TAG="${TAG:-janus}"
 
 if ! command -v ollama >/dev/null 2>&1; then echo "[!] ollama not found in PATH" >&2; exit 1; fi
@@ -43,7 +44,7 @@ echo "[*] tag:       ${TAG}"
 echo "[*] gguf:      ${GGUF}"
 echo "[*] num_ctx:   ${CTX}   num_batch: ${NBATCH}"
 
-TMP="$(mktemp -t janus27b-capctx.XXXXXX)"
+TMP="$(mktemp -t janus35b-capctx.XXXXXX)"
 trap 'rm -f "${TMP}"' EXIT
 awk -v g="${GGUF}" -v c="${CTX}" -v b="${NBATCH}" '
     /^FROM[[:space:]]/ && !done { print "FROM " g; done=1; next }

scripts/check.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Janus-27B — repo-local sanity checks.
+# Janus-35B — repo-local sanity checks.
 #
 # Runs everything that's cheap and catches a real-world bug we've already hit:
 #
@@ -7,15 +7,16 @@
 #   2. shellcheck on every *.sh, if installed     (catches quoting/SC2086 bugs)
 #   3. python3 -m pyflakes on every *.py          (catches NameError, unused imports)
 #   4. python3 -m py_compile on every *.py        (catches actual syntax errors)
-#   5. grep -E for a FROM/BUNDLE path pointing at an unstripped
-#      -MTP-Preserved- quant (this base keeps its MTP head; see strip_mtp.py)
+#   5. the Modelfile's FROM target is the GGUF this repo actually ships
+#      (the local-build path da34705 broke, with nothing here to catch it)
 #   6. multi-line-aware scan for the VAR="$(cmd 2>/dev/null | filter)" silent-exit
 #      under set -e + pipefail (the one we shipped in d87bc64 and fixed in 385ed94)
 #   7. Modelfile <-> template/system/params bridge-file sync
-#   8. chat_template.jinja render checks (the tool-call shape llama.cpp needs)
-#   9. Go template keeps Ollama's thinking detection and the replay condition
+#   8. Go template keeps Ollama's thinking detection and the replay condition
 #
-# Exit non-zero on any failure. Designed to run from .git/hooks/pre-commit.
+# Exit non-zero on any failure; a check whose tooling or input is missing is
+# reported as skipped and never counted as a pass. Designed to run from
+# .git/hooks/pre-commit.
 #
 # Usage:
 #   ./scripts/check.sh                 # one-shot
@@ -31,6 +32,8 @@ yellow() { printf "\033[33m%s\033[0m\n" "$*"; }
 blue()   { printf "\033[34m%s\033[0m\n" "$*"; }
 
 FAIL=0
+SKIPPED=0
+CHECKS=8          # the numbered checks above; keep in sync with that list
 
 # ---- collect targets -------------------------------------------------------
 
@@ -69,6 +72,7 @@ if command -v shellcheck >/dev/null 2>&1; then
     done
 else
     yellow "[~] shellcheck not installed (skip). Install with: apt install shellcheck"
+    SKIPPED=$((SKIPPED + 1))
 fi
 
 # ---- 3. pyflakes -----------------------------------------------------------
@@ -86,6 +90,7 @@ if (( ${#PY_FILES[@]} )); then
         done
     else
         yellow "[~] pyflakes not installed (skip). Install with: pip install pyflakes"
+        SKIPPED=$((SKIPPED + 1))
     fi
 fi
 
@@ -105,28 +110,44 @@ if (( ${#PY_FILES[@]} )); then
     find . -type d -name __pycache__ -not -path './.git/*' -exec rm -rf {} + 2>/dev/null || true
 fi
 
-# ---- 5. footgun: MTP-unstripped bundle reference ---------------------------
+# ---- 5. footgun: Modelfile FROM target vs the bundled GGUF -----------------
 #
-# The Janus base is MTP-PRESERVED: quants pulled from
-# llmfan46/...-MTP-Preserved-GGUF carry a NextN block at index 64 that
-# stock llama.cpp and Ollama cannot load. Every bundled/committed GGUF must
-# go through scripts/strip_mtp.py first. Block any doc or script that points
-# a FROM / bundle path straight at an -MTP-Preserved- quant.
+# 'ollama create janus -f Modelfile' resolves the FROM line against the repo
+# root, so that filename and the blob this repo actually ships have to be the
+# same file. The 0.2.0 rebase renamed FROM ahead of the blob: for a day the
+# repo tracked one bundle and FROM named another, so the local-build path
+# failed outright from a fresh clone until the blob swap in da34705 caught up
+# — and nothing here noticed (CHANGELOG: "the broken Modelfile FROM path
+# shipped unnoticed"). A rename on either side alone breaks it again.
 #
-# (Note: unlike the Thanatos sibling, DASH-separated quant filenames are
-# correct here — llmfan46 names them
-# Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-Q4_K_M.gguf —
-# so there is no dot-vs-dash guard in this repo.)
-
-blue "[*] grep: bundled FROM/BUNDLE pointing at an unstripped -MTP-Preserved- quant"
-if grep -RnE '^(FROM|BUNDLE=|GGUF=)[^#]*MTP-Preserved-Q[0-9A-Z_]+\.gguf' \
-        --include='*.sh' --include='Modelfile*' \
-        --exclude-dir=.git --exclude-dir=__pycache__ \
-        . ; then
-    red "  [FAIL] bundle path points at an unstripped MTP quant (run scripts/strip_mtp.py)"
-    FAIL=1
+# This replaces the '-MTP-Preserved-Q<quant>.gguf' grep that used to sit here:
+# no Qwen 3.6 quant filename carries that substring, so the guard was green by
+# construction rather than by inspection. What still guards the MTP footgun is
+# scripts/strip_mtp.py itself — build.sh runs every fetched quant through it,
+# and it no-ops on the MTP-clean quant this repo bundles.
+
+blue "[*] Modelfile FROM target is the GGUF this repo ships"
+if [[ ! -f "${ROOT}/Modelfile" ]]; then
+    yellow "[~] Modelfile missing; skipping FROM target check"
+    SKIPPED=$((SKIPPED + 1))
 else
-    echo "  [ ok ] no unstripped-MTP bundle references"
+    mapfile -t BUNDLES < <(find . -maxdepth 1 -type f -name '*.gguf' | sed 's|^\./||' | sort)
+    FROM_TARGET="$(awk '/^FROM[[:space:]]/{print $2; exit}' "${ROOT}/Modelfile")"
+    if (( ${#BUNDLES[@]} != 1 )); then
+        red "  [FAIL] expected exactly one bundled *.gguf in the repo root, found ${#BUNDLES[@]}"
+        FAIL=1
+    elif [[ "${FROM_TARGET#./}" != "${BUNDLES[0]}" ]]; then
+        red "  [FAIL] Modelfile FROM '${FROM_TARGET}' is not the bundled '${BUNDLES[0]}'"
+        red "    'ollama create janus -f Modelfile' cannot resolve it from a fresh clone."
+        FAIL=1
+    elif ! git -C "${ROOT}" ls-files --error-unmatch "${BUNDLES[0]}" >/dev/null 2>&1; then
+        red "  [FAIL] bundled '${BUNDLES[0]}' is not tracked by git"
+        red "    It exists on disk but would be absent from a fresh clone and from the"
+        red "    published repo. Stage it: git add '${BUNDLES[0]}'"
+        FAIL=1
+    else
+        echo "  [ ok ] FROM ${FROM_TARGET} == bundled ${BUNDLES[0]} (tracked)"
+    fi
 fi
 
 # ---- 6. footgun: VAR="$(cmd 2>/dev/null | filter)" silent-exit pattern -----
@@ -198,28 +219,10 @@ if [[ -f "${ROOT}/Modelfile" && -f "${ROOT}/template" \
     fi
 else
     yellow "[~] bridge files missing; skipping sync check"
+    SKIPPED=$((SKIPPED + 1))
 fi
 
-# ---- 8. chat_template.jinja render checks ----------------------------------
-#
-# 'chat_template.jinja' is what llama.cpp / llama-server applies under
-# '--jinja --chat-template-file'. It is data, not code, so nothing else in this
-# file looks at it: py_compile and pyflakes skip it, and a one-character edit
-# can silently switch the tool-call format away from the XML form llama-server's
-# parser reads, or bring back a raise llama-server returns as HTTP 500.
-# check_chat_template.py renders it and asserts the properties tool calling,
-# reasoning replay and reasoning_effort depend on.
-
-if [[ -f "${ROOT}/chat_template.jinja" ]]; then
-    blue "[*] python: chat_template.jinja render checks"
-    if ! python3 "${ROOT}/scripts/check_chat_template.py"; then
-        FAIL=1
-    fi
-else
-    yellow "[~] chat_template.jinja missing; skipping render checks"
-fi
-
-# ---- 9. Go template: Ollama's thinking detection + replay condition ------
+# ---- 8. Go template: Ollama's thinking detection + replay condition ------
 #
 # Ollama picks between the Go 'template' and the GGUF's embedded Jinja template
 # by comparing their capabilities, and infers the Go template's "thinking" from
@@ -234,6 +237,7 @@ if [[ -f "${ROOT}/template" ]]; then
     fi
 else
     yellow "[~] template missing; skipping Go template check"
+    SKIPPED=$((SKIPPED + 1))
 fi
 
 # ---- result ----------------------------------------------------------------
@@ -243,4 +247,8 @@ if (( FAIL )); then
     red "[!] FAIL"
     exit 1
 fi
-green "[+] all checks passed"
+if (( SKIPPED )); then
+    yellow "[+] $(( CHECKS - SKIPPED )) of ${CHECKS} checks passed, ${SKIPPED} skipped"
+else
+    green "[+] all ${CHECKS} checks passed"
+fi

scripts/check_bridge_sync.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Janus-27B — verify Modelfile and HF Ollama bridge files stay in sync.
+Janus-35B — verify Modelfile and HF Ollama bridge files stay in sync.
 
 The repo ships two parallel Ollama configurations:
 

scripts/check_chat_template.py

@@ -1,228 +0,0 @@
-#!/usr/bin/env python3
-"""Render ``chat_template.jinja`` and assert the properties tool calling needs.
-
-``chat_template.jinja`` is this repo's copy of the base model's embedded chat
-template with two changes: ``preserve_thinking`` and ``preserve_reasoning``
-resolved without raising, and ``reasoning_effort`` normalisation. It is what
-llama.cpp / llama-server applies under ``--jinja --chat-template-file``, and what
-``scripts/build.sh`` stamps into the GGUF it builds.
-
-The tool-call wire format defaults to XML, as upstream ships it. llama-server
-parses this template's output with its Qwen3-Coder parser, which accepts only
-the XML form, and converts a client's JSON-string ``function.arguments`` to a
-mapping before rendering. A JSON default would teach the model a form that
-parser cannot read, and that failure is invisible to every other check here: the
-template is data, not code, so ``py_compile`` and ``pyflakes`` never look at it.
-
-``tool_call_format='auto'`` stays available for loaders that pass the raw JSON
-string through: the XML form needs individual key/value pairs and a chat template
-has ``tojson`` but no inverse, so it renders the prompt in JSON form instead.
-
-Run directly (``python3 scripts/check_chat_template.py``) or via
-``./scripts/check.sh`` / ``make check``. Skips with exit 0 when Jinja2 is absent,
-matching how check.sh treats shellcheck and pyflakes.
-"""
-import os
-import sys
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-TEMPLATE_PATH = os.path.join(ROOT, "chat_template.jinja")
-
-try:
-    import jinja2
-except ImportError:
-    print("[~] jinja2 not installed (skip). Install with: pip install jinja2")
-    sys.exit(0)
-
-if not os.path.exists(TEMPLATE_PATH):
-    print(f"[!] missing {TEMPLATE_PATH}")
-    sys.exit(1)
-
-
-class TemplateRaise(Exception):
-    """What the template's raise_exception() maps to (minja provides this global)."""
-
-
-env = jinja2.Environment(undefined=jinja2.ChainableUndefined)
-env.globals["raise_exception"] = lambda msg: (_ for _ in ()).throw(TemplateRaise(msg))
-try:
-    TPL = env.from_string(open(TEMPLATE_PATH, encoding="utf-8").read())
-except jinja2.TemplateSyntaxError as exc:
-    print(f"[!] template does not parse: line {exc.lineno}: {exc.message}")
-    sys.exit(1)
-
-WEATHER = {"type": "function", "function": {
-    "name": "get_weather", "description": "Get current weather for a city",
-    "parameters": {"type": "object", "properties": {"city": {"type": "string"}},
-                   "required": ["city"]}}}
-USER = {"role": "user", "content": "Weather in Tokyo?"}
-# Exactly the shape an OpenAI-compatible client replays on turn 2.
-CALL_STR = {"role": "assistant", "content": None, "tool_calls": [
-    {"id": "c1", "type": "function",
-     "function": {"name": "get_weather", "arguments": '{"city":"Tokyo"}'}}]}
-CALL_MAP = {"role": "assistant", "content": "", "tool_calls": [
-    {"function": {"name": "get_weather", "arguments": {"city": "Tokyo"}}}]}
-RESULT = {"role": "tool", "tool_call_id": "c1", "content": '{"temp_c": 22}'}
-
-failures = []
-
-
-def render(messages, **kwargs):
-    kwargs.setdefault("add_generation_prompt", True)
-    return TPL.render(messages=messages, **kwargs)
-
-
-def check(name, condition, context=""):
-    if condition:
-        print(f"  [ ok ] {name}")
-    else:
-        print(f"  [FAIL] {name}")
-        failures.append((name, context))
-
-
-def attempt(messages, **kwargs):
-    """-> (ok, output_or_error)"""
-    try:
-        return True, render(messages, **kwargs)
-    except Exception as exc:  # noqa: BLE001 - any raise is an HTTP 500 under llama-server
-        return False, f"{type(exc).__name__}: {exc}"
-
-
-# 1. The default is XML, upstream's and the only form llama-server's parser reads.
-ok, out = attempt([USER, CALL_MAP, RESULT], tools=[WEATHER])
-check("mapping tool-call arguments render with no kwargs", ok, out)
-if ok:
-    check("default renders the XML tool-call form",
-          "<tool_call>\n<function=get_weather>\n<parameter=city>\nTokyo\n</parameter>\n</function>\n</tool_call>" in out, out)
-    check("default system prompt advertises the matching XML form",
-          "<function=example_function_name>" in out and '{"name": "example_function_name"' not in out, out)
-    ok_x, out_x = attempt([USER, CALL_MAP, RESULT], tools=[WEATHER], tool_call_format="xml")
-    check("default is byte-identical to tool_call_format='xml'", ok_x and out_x == out, out_x)
-
-ok_pin, _ = attempt([USER, CALL_STR, RESULT], tools=[WEATHER])
-check("default still refuses unconverted string arguments (upstream behaviour)",
-      not ok_pin, "expected a raise, got a successful render")
-
-# 2. 'auto' (opt-in): a replayed tool call with string arguments renders as JSON.
-ok, out = attempt([USER, CALL_STR, RESULT], tools=[WEATHER], tool_call_format="auto")
-check("auto: string tool-call arguments do not raise", ok, out)
-if ok:
-    check("auto: string arguments render as JSON inside <tool_call>",
-          '<tool_call>\n{"name": "get_weather", "arguments": {"city":"Tokyo"}}\n</tool_call>' in out, out)
-    check("auto: system prompt advertises the matching JSON form",
-          '{"name": "example_function_name"' in out, out)
-    check("auto: no XML tool-call form alongside the JSON instructions",
-          "<function=" not in out, out)
-
-# 3. Every format value renders mapping arguments.
-for fmt in ("auto", "json", "xml"):
-    msgs = [USER, CALL_MAP, RESULT]
-    ok_f, out_f = attempt(msgs, tools=[WEATHER], tool_call_format=fmt)
-    check(f"tool_call_format={fmt!r} renders", ok_f, out_f)
-
-ok_bad, _ = attempt([USER], tools=[WEATHER], tool_call_format="nonsense")
-check("an unknown tool_call_format is rejected", not ok_bad,
-      "expected a raise for an invalid format")
-
-# 4. Thinking prefill, both directions. Structure, not exact whitespace: the
-#    trailing newlines are upstream's and are reproduced verbatim.
-ok_on, on = attempt([USER])
-tail_on = on.split("<|im_start|>assistant")[-1] if ok_on else ""
-check("thinking on primes an open <think>",
-      ok_on and tail_on.lstrip("\n").startswith("<think>") and "</think>" not in tail_on,
-      repr(tail_on))
-ok_off, off = attempt([USER], enable_thinking=False)
-tail_off = off.split("<|im_start|>assistant")[-1] if ok_off else ""
-check("thinking off primes a closed, empty <think>",
-      ok_off and "<think>" in tail_off and "</think>" in tail_off
-      and tail_off.split("<think>")[1].split("</think>")[0].strip() == "",
-      repr(tail_off))
-
-# 5. Multimodal parts must survive, or the --mmproj path in the README breaks.
-ok_v, vis = attempt([{"role": "user", "content": [
-    {"type": "text", "text": "What is this?"},
-    {"type": "image_url", "image_url": {"url": "data:image/png;base64,AAA"}}]}])
-check("image parts render vision pads",
-      ok_v and "<|vision_start|><|image_pad|><|vision_end|>" in vis, vis)
-check("text parts survive alongside images", ok_v and "What is this?" in vis, vis)
-
-# 6. Plain conversation, and multi-turn reasoning handling.
-ok_p, plain = attempt([{"role": "system", "content": "You are helpful."}, USER])
-check("plain conversation renders with the system turn",
-      ok_p and "<|im_start|>system" in plain and "You are helpful." in plain, plain)
-
-# 7. Earlier turns' reasoning IS replayed by default, as upstream does. llama-server
-#    from b10763 passes preserve_reasoning=true and derives preserve_thinking from
-#    it, but a request's preserve_thinking kwarg replaces the derived copy, so the
-#    two can disagree: that must not raise (upstream does), and preserve_thinking
-#    wins. A live tool-call chain keeps its own trace whatever the setting.
-PRIOR = {"role": "assistant", "content": "First answer.", "reasoning_content": "OLDTRACE"}
-FOLLOWUP = {"role": "user", "content": "second question"}
-LIVE = {"role": "assistant", "content": "", "reasoning_content": "LIVETRACE",
-        "tool_calls": [{"function": {"name": "get_weather", "arguments": {"city": "Tokyo"}}}]}
-
-ok_d, out_d = attempt([USER, PRIOR, FOLLOWUP])
-check("earlier reasoning is replayed by default", ok_d and "OLDTRACE" in out_d, out_d)
-
-ok_t, out_t = attempt([USER, PRIOR, FOLLOWUP], preserve_thinking=True)
-check("preserve_thinking=True replays it", ok_t and "OLDTRACE" in out_t, out_t)
-
-ok_f, out_f = attempt([USER, PRIOR, FOLLOWUP], preserve_thinking=False)
-check("preserve_thinking=False drops it", ok_f and "OLDTRACE" not in out_f, out_f)
-
-ok_r, out_r = attempt([USER, PRIOR, FOLLOWUP], preserve_reasoning=False)
-check("preserve_reasoning=False drops it", ok_r and "OLDTRACE" not in out_r, out_r)
-
-ok_c, out_c = attempt([USER, PRIOR, FOLLOWUP], preserve_reasoning=True, preserve_thinking=False)
-check("conflicting values do not raise; preserve_thinking=False wins (llama-server default + request kwarg)",
-      ok_c and "OLDTRACE" not in out_c, out_c)
-
-ok_c2, out_c2 = attempt([USER, PRIOR, FOLLOWUP], preserve_reasoning=False, preserve_thinking=True)
-check("conflicting values do not raise; preserve_thinking=True wins",
-      ok_c2 and "OLDTRACE" in out_c2, out_c2)
-
-ok_l, out_l = attempt([USER, LIVE, RESULT], tools=[WEATHER], preserve_thinking=False)
-check("a live tool-call chain keeps its own reasoning",
-      ok_l and "LIVETRACE" in out_l, out_l)
-
-SYS = {"role": "system", "content": "You are a helpful assistant."}
-
-# reasoning_effort must never fail the request. Clients disagree on the
-# vocabulary (OpenAI minimal/low/medium/high, xhigh, "max", mixed case), and a
-# template raise is an HTTP 500 for the whole request under Ollama >= 0.33 and
-# llama-server - reasoning_effort="max" made the model unusable. Every value a
-# real client might send has to render, including an explicit JSON null.
-for eff in ("none", "minimal", "low", "medium", "high", "xhigh", "max",
-            "HIGH", " High ", "auto", "default", "", "ultra", 5, True, False):
-    ok_e, out_e = attempt([SYS, USER], reasoning_effort=eff)
-    check(f"reasoning_effort={eff!r} renders", ok_e, out_e)
-ok_null, out_null = attempt([SYS, USER], reasoning_effort=None)
-check("reasoning_effort=null (explicit JSON null) renders", ok_null, out_null)
-
-# Ollama's /v1 layer accepts exactly eight values - minimal, low, medium, high,
-# xhigh, ultra, max, none - and rejects anything else with a 400 before the
-# template runs. Each must land on a sensible tier, not merely avoid raising.
-for eff, want in (("high", "xhigh"), ("xhigh", "xhigh"), ("max", "xhigh"),
-                  ("ultra", "xhigh"), ("low", "low"), ("minimal", "low")):
-    ok_t, out_t = attempt([SYS, USER], reasoning_effort=eff)
-    check(f"reasoning_effort={eff!r} selects the {want} tier",
-          ok_t and f"Reasoning effort is set to {want}" in out_t, out_t)
-ok_med, out_med = attempt([SYS, USER], reasoning_effort="medium")
-check("reasoning_effort='medium' selects the medium tier",
-      ok_med and "Reasoning effort is set to" not in out_med, out_med)
-ok_none, out_none = attempt([SYS, USER], reasoning_effort="none")
-tail_none = out_none.split("<|im_start|>assistant")[-1] if ok_none else ""
-check("reasoning_effort='none' switches thinking off",
-      ok_none and "</think>" in tail_none
-      and tail_none.split("<think>")[1].split("</think>")[0].strip() == "",
-      repr(tail_none))
-
-print()
-if failures:
-    print(f"[!] {len(failures)} chat-template check(s) failed")
-    for name, context in failures:
-        print(f"--- {name} ---")
-        if context:
-            print(context[:1500])
-    sys.exit(1)
-print("[+] chat_template.jinja checks passed")

scripts/fetch_vision.sh

@@ -1,20 +1,20 @@
 #!/usr/bin/env bash
-# Janus-27B — fetch the vision projector (mmproj) for image input.
+# Janus-35B — fetch the vision projector (mmproj) for image input.
 #
 # Why this is separate from build.sh:
 #   build.sh is for the Ollama text path. The mmproj is only useful for
 #   llama.cpp / llama-cpp-python right now, because Ollama's vendored
-#   llama.cpp fork is missing the qwen35 arch entries needed to attach
+#   llama.cpp fork is missing the qwen35moe arch entries needed to attach
 #   it (see README Vision section, ollama/ollama#14575).
 #
 # Usage:
-#   ./scripts/fetch_vision.sh                    # default: BF16
+#   ./scripts/fetch_vision.sh                    # default: BF16 (902 MB)
 #
-# The Heretic GGUF repo publishes the projector as BF16; for another
-# precision, point REPO_ID / FILE_NAME at a projector from any other
-# Qwen3.8-27B GGUF repo:
-#   REPO_ID=<other-qwen3.8-27b-gguf-repo> FILE_NAME=mmproj-F16.gguf ./scripts/fetch_vision.sh
-# (vision tokens are projected the same way across Qwen 3.8 27B
+# The Heretic GGUF repo publishes the projector as BF16 only (its Files
+# listing, HF API, 2026-09-18); for another precision, point REPO_ID /
+# FILE_NAME at a projector from any other Qwen3.6-35B-A3B GGUF repo:
+#   REPO_ID=<other-qwen3.6-35b-a3b-gguf-repo> FILE_NAME=mmproj-F16.gguf ./scripts/fetch_vision.sh
+# (vision tokens are projected the same way across Qwen 3.6 35B-A3B
 # finetunes, so a family projector is functionally interchangeable.)
 #
 # Requires: huggingface-cli (or hf).
@@ -38,8 +38,8 @@ detect_hf() {
 }
 
 PRECISION="${1:-${PRECISION:-BF16}}"
-REPO_ID="${REPO_ID:-llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-GGUF}"
-FILE_NAME="${FILE_NAME:-Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved-mmproj-${PRECISION}.gguf}"
+REPO_ID="${REPO_ID:-llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF}"
+FILE_NAME="${FILE_NAME:-Qwen3.6-35B-A3B-uncensored-heretic-mmproj-${PRECISION}.gguf}"
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 DEST="${MMPROJ_PATH:-${ROOT}/${FILE_NAME}}"
 
@@ -72,7 +72,7 @@ fi
 echo
 echo "[+] Done. Use it via:"
 echo "    python ${ROOT}/examples/llama_cpp_vision.py \\"
-echo "        --gguf   ${ROOT}/Janus-27B.Q4_K_M.gguf \\"
+echo "        --gguf   ${ROOT}/Janus-35B-A3B.Q4_K_M.gguf \\"
 echo "        --mmproj ${DEST} \\"
 echo "        --image  /path/to/photo.jpg \\"
 echo "        --prompt 'Describe this image.'"

scripts/install-hooks.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Janus-27B — install scripts/check.sh as a git pre-commit hook.
+# Janus-35B — install scripts/check.sh as a git pre-commit hook.
 #
 # Idempotent. Re-runs are safe.
 set -euo pipefail

scripts/live_check.sh

@@ -22,9 +22,10 @@
 #      WORK_DIR (<repo>/.cache/live-check): each run uses a fresh subdirectory of
 #      it and deletes only that; KEEP=1 keeps the run directory.
 #
-# Needs free disk on WORK_DIR of about twice the GGUF (Ollama keeps the imported
-# file plus a rewritten copy, and briefly more during the import), RAM to load it,
-# and tens of minutes on CPU for a 27B. Exits non-zero if any check fails.
+# Needs free disk on WORK_DIR of about twice the GGUF - ~42 GB for the bundled
+# 21.23 GB Q4_K_M (Ollama keeps the imported file plus a rewritten copy, and
+# briefly more during the import), RAM to load it, and tens of minutes on CPU for
+# a 35B-A3B. Exits non-zero if any check fails.
 #
 # The server runs on CPU only: GPU backends are switched off in its environment,
 # and the run stops before importing if Ollama still reports a GPU. On a shared

scripts/load_bundle.sh

@@ -1,14 +1,14 @@
 #!/usr/bin/env bash
-# Janus-27B — load this repo's bundle into Ollama as a local tag.
+# Janus-35B — load this repo's bundle into Ollama as a local tag.
 #
-# The bundled GGUF (Janus-27B.Q4_K_M.gguf) is qwen35-stamped and
-# MTP-stripped, so it loads directly on stock llama.cpp / Ollama. This
-# script is the one-shot path from "I just cloned this repo" to "I have
-# a working local Ollama tag":
+# The bundled GGUF (Janus-35B-A3B.Q4_K_M.gguf) is qwen35moe-stamped and
+# loads directly on stock llama.cpp / Ollama. This script is the
+# one-shot path from "I just cloned this repo" to "I have a working
+# local Ollama tag":
 #
 #   1. Resolve the bundle. If it's an LFS pointer (cloned without
-#      `git lfs pull`), download the real ~17 GB blob via `hf download`.
-#   2. Sanity-check `general.architecture` is qwen35.
+#      `git lfs pull`), download the real ~21 GB blob via `hf download`.
+#   2. Sanity-check `general.architecture` is qwen35moe.
 #   3. Run `ollama create <tag> -f <temp Modelfile pointing at the
 #      resolved bundle>`.
 #
@@ -18,7 +18,7 @@
 # Usage:
 #   ./scripts/load_bundle.sh                 # default tag: janus
 #   TAG=janus-bundle ./scripts/load_bundle.sh
-#   BUNDLE=/path/to/Janus-27B.Q4_K_M.gguf ./scripts/load_bundle.sh
+#   BUNDLE=/path/to/Janus-35B-A3B.Q4_K_M.gguf ./scripts/load_bundle.sh
 #
 # Requires: ollama, python3 with the `gguf` package, hf (if the bundle
 # needs to be downloaded).
@@ -42,7 +42,7 @@ detect_hf() {
 }
 
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-BUNDLE="${BUNDLE:-${ROOT}/Janus-27B.Q4_K_M.gguf}"
+BUNDLE="${BUNDLE:-${ROOT}/Janus-35B-A3B.Q4_K_M.gguf}"
 TAG="${TAG:-janus}"
 REPO_ID="${REPO_ID:-FoolDev/Janus-35B-HERETIC}"
 MODELFILE="${ROOT}/Modelfile"
@@ -116,14 +116,14 @@ PY
 )"
 echo "[*] bundle arch: ${ARCH}"
 
-if [[ "${ARCH}" != "qwen35" ]]; then
+if [[ "${ARCH}" != "qwen35moe" ]]; then
     echo "[!] unexpected arch '${ARCH}' — refusing to load. Edit this script if intentional." >&2
     exit 1
 fi
 
 # ---- 4. Build a Modelfile copy with FROM pointing at the bundle --------------
 
-TMP_MODELFILE="$(mktemp -t janus27b-loadbundle.XXXXXX)"
+TMP_MODELFILE="$(mktemp -t janus35b-loadbundle.XXXXXX)"
 trap 'rm -f "${TMP_MODELFILE}"' EXIT
 awk -v p="${BUNDLE}" '
     /^FROM[[:space:]]/ && !done { print "FROM " p; done=1; next }

scripts/smoke_test.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Janus-27B — smoke test against a running Ollama daemon.
+# Janus-35B — smoke test against a running Ollama daemon.
 #
 # Verifies:
 #   1. The Ollama server is reachable.
@@ -46,7 +46,7 @@ echo "[+] server reachable"
 # ---- 2. Model present? ------------------------------------------------------
 # Match case-insensitively: Ollama 0.24 normalizes model names at lookup but
 # preserves whatever case was first registered on disk (e.g. an earlier
-# session may leave a `Janus-27B:latest` manifest dir behind even when a
+# session may leave a `Janus-35B:latest` manifest dir behind even when a
 # build was invoked with TAG=janus). The exact tag the user typed is still
 # valid for `ollama run` — the comparison just needs to be case-folded to
 # match.
@@ -54,7 +54,7 @@ if ! curl -fsS "${HOST}/api/tags" | jq -e --arg m "${MODEL}" '.models[] | select
     echo "[!] Model '${MODEL}' not found. Build it first:" >&2
     echo "    ./scripts/build.sh                # Q4_K_M" >&2
     echo "    ./scripts/build.sh Q3_K_M         # smaller quant" >&2
-    echo "    ./scripts/load_bundle.sh          # load this repo's qwen35 bundle" >&2
+    echo "    ./scripts/load_bundle.sh          # load this repo's qwen35moe bundle" >&2
     exit 1
 fi
 echo "[+] model present"

scripts/strip_mtp.py

@@ -1,22 +1,28 @@
 #!/usr/bin/env python3
 """
-Strip the MTP / NextN layer (the extra last block) out of a qwen35 GGUF so it
+Strip the MTP / NextN layer (the extra last block) out of a qwen35moe GGUF so it
 loads on stock llama.cpp / Ollama.
 
 MTP-preserving GGUF conversions keep the MTP tensors as one extra NextN block,
-so block_count = <transformer layers> + 1 MTP layer — here 64 + 1 = 65, with the
-NextN block at index 64. Stock loaders treat that last block as a normal hybrid
+so block_count = <transformer layers> + 1 MTP layer — here 40 + 1 = 41, with the
+NextN block at index 40. Stock loaders treat that last block as a normal hybrid
 layer and abort with `missing tensor 'blk.<last>.ssm_conv1d.weight'`. This drops
-all `blk.<last>.*` tensors, sets block_count down by one (back to 64), and
+all `blk.<last>.*` tensors, sets block_count down by one (back to 40), and
 removes nextn_predict_layers.
 
-Janus' base — llmfan46/Qwen3.8-27B-Ultra-Uncensored-Heretic-Native-MTP-Preserved
-— ships the MTP head intact, so this step is REQUIRED, not a safety net: the
-bundled Janus-27B.Q4_K_M.gguf is this script's stripped output, exactly as the
-dense sibling FoolDev/Thanatos-27B-HERETIC does for its heretic-ara base. It
-still no-ops (hardlink, no extra disk) on an input that is already MTP-clean.
-Wanting the MTP head means running the upstream safetensors under vLLM / SGLang,
-or taking the unstripped GGUF straight from the source repo.
+For the blob this repo bundles, that is a no-op passthrough (hardlink, no extra
+disk), not a required build step. Janus-35B-A3B.Q4_K_M.gguf comes from
+llmfan46/Qwen3.6-35B-A3B-uncensored-heretic-GGUF and is already MTP-clean:
+block_count 40, blk.0…blk.39 only, no nextn_predict_layers. The head exists
+upstream (the base's config.json declares mtp_num_hidden_layers 1) and llmfan46
+publishes it as a separate *-Native-MTP-Preserved-GGUF whose Q4_K_M reports
+block_count 41 — that variant is what this script is for, and this repo
+deliberately does not ship it. So the strip is kept purely as a safety net, the
+way the dense sibling FoolDev/Thanatos-27B-HERETIC needs it for its
+MTP-preserved heretic-ara base: it guards against a future llmfan46 re-quant
+shipping the MTP layer. Wanting the MTP head means running the upstream
+safetensors under vLLM / SGLang, or taking the unstripped GGUF straight from
+that variant repo.
 
 Every KEPT tensor is copied byte-for-byte (raw quantized data) — no
 re-quantization, so no quality change to the model itself.
@@ -26,11 +32,11 @@ Optionally also restamp the embedded chat template in the same pass:
     --chat-template FILE   replace tokenizer.chat_template with FILE's contents
 
 That matters because llama.cpp, LM Studio, Jan and KoboldCpp all read the
-template baked into the GGUF, and the upstream one raises on reasoning_effort
-values such as "max" and on conflicting preserve_thinking / preserve_reasoning,
-which llama-server returns as HTTP 500. Stamping this repo's chat_template.jinja
-in at build time gives every one of those loaders its fixes with no extra flags. build.sh does this
-automatically when chat_template.jinja is present.
+template baked into the GGUF, so replacing it is the only way to change what
+those loaders see. This repo no longer carries a chat_template.jinja — the Qwen
+3.6 base's own embedded template governs the llama.cpp path — so nothing here
+passes the flag today: build.sh calls this script without it, and the bundled
+blob keeps the template it shipped with.
 
 With --chat-template and no MTP block to strip, the file is still rewritten (the
 usual hardlink passthrough would not carry the new template).

scripts/verify_arch.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-Janus-27B — verify the README "Architecture" claims and the dense
+Janus-35B — verify the README "Architecture" claims and the MoE
 forward-pass structure against the actual GGUF metadata.
 
-Reads the qwen35-stamped bundle (or any GGUF that declares that
+Reads the qwen35moe-stamped bundle (or any GGUF that declares that
 `general.architecture` value), prints each claim alongside the metadata key
 it derives from, and exits non-zero if any value mismatches the expected
 claim. Useful as a manual audit after the bundle is re-stamped or after
@@ -11,19 +11,22 @@ upstream re-conversion.
 
 Usage:
     python3 scripts/verify_arch.py                          # default bundle
-    python3 scripts/verify_arch.py Janus-27B.Q4_K_M.gguf
+    python3 scripts/verify_arch.py Janus-35B-A3B.Q4_K_M.gguf
     python3 scripts/verify_arch.py /path/to/some-other.gguf
 
 Exit code 0 = all claims verify, 1 = at least one mismatch.
 
-Note: this does NOT verify the 27B parameter count directly (no such KV in
-the GGUF) — it follows from the layer count, hidden size and FFN width below
-and llama.cpp's `qwen35` type branch, not from a single metadata field.
-
-`block_count` is checked against 64, i.e. the MTP-stripped value. The source
-GGUF is MTP-preserved and carries an extra NextN block at index 64, so a
-bundle that has not been through scripts/strip_mtp.py reports 65 here and
-fails this check — as it would also fail to load on stock llama.cpp / Ollama.
+Note: this does NOT verify the ~34.7B-total / ~3B-active parameter counts
+directly (no such KV in the GGUF) — they follow from the layer count, hidden
+size and the expert count/width below and llama.cpp's `qwen35moe` type branch,
+not from a single metadata field.
+
+`block_count` is checked against 40, which is this model's natural depth (10
+Gated-Attention + 30 Gated-DeltaNet layers), NOT a post-strip value: the
+bundled quant carries no MTP/NextN tensors, so scripts/strip_mtp.py is a
+defensive no-op for it. llmfan46's separate *-Native-MTP-Preserved-GGUF variant
+— which this repo does not ship — reports 41 here, with a NextN block at index
+40 that stock llama.cpp / Ollama cannot load.
 """
 from __future__ import annotations
 
@@ -33,22 +36,27 @@ from pathlib import Path
 from gguf import GGUFReader
 
 EXPECTED = {
-    "block_count": (64, "64 transformer layers"),
+    "block_count": (40, "40 transformer layers"),
     "context_length": (262144, "262 144 native context"),
-    "embedding_length": (5120, "Hidden size 5120"),
-    "feed_forward_length": (17408, "Dense FFN intermediate size 17408"),
-    "attention.head_count": (24, "Gated Attention: 24 Q-heads"),
-    "attention.head_count_kv": (4, "Gated Attention: 4 KV-heads (GQA)"),
+    "embedding_length": (2048, "Hidden size 2048"),
+    "expert_count": (256, "MoE: 256 experts"),
+    "expert_used_count": (8, "MoE: 8 experts active per token"),
+    "expert_feed_forward_length": (512, "MoE: per-expert FFN 512"),
+    "expert_shared_feed_forward_length": (512, "MoE: shared-expert FFN 512"),
+    "attention.head_count": (16, "Gated Attention: 16 Q-heads"),
+    "attention.head_count_kv": (2, "Gated Attention: 2 KV-heads (GQA)"),
     "attention.key_length": (256, "Gated Attention: head_dim 256 (key)"),
     "attention.value_length": (256, "Gated Attention: head_dim 256 (value)"),
     "rope.dimension_count": (64, "Partial RoPE: 64 of 256 dims (factor 0.25)"),
-    "full_attention_interval": (4, "Hybrid stack: every 4th layer is Gated Attention (16 cycles)"),
+    "full_attention_interval": (4, "Hybrid stack: every 4th layer is Gated Attention (10 cycles)"),
+    "ssm.conv_kernel": (4, "Gated DeltaNet: conv kernel 4"),
     "ssm.state_size": (128, "Gated DeltaNet: head_dim 128"),
-    "ssm.time_step_rank": (48, "Gated DeltaNet: 48 V-heads"),
+    "ssm.time_step_rank": (32, "Gated DeltaNet: 32 V-heads"),
     "ssm.group_count": (16, "Gated DeltaNet: 16 QK-heads"),
+    "ssm.inner_size": (4096, "Gated DeltaNet: inner size 4096 (32 V-heads x 128)"),
 }
 EXPECTED_VOCAB = 248320
-EXPECTED_ARCHS = {"qwen35"}
+EXPECTED_ARCHS = {"qwen35moe"}
 
 
 def read_scalar(reader: GGUFReader, key: str):
@@ -69,18 +77,18 @@ def read_arch(reader: GGUFReader) -> str:
 
 def main() -> int:
     if len(sys.argv) > 2:
-        print(f"usage: {sys.argv[0]} [path/to/Janus-27B.Q4_K_M.gguf]", file=sys.stderr)
+        print(f"usage: {sys.argv[0]} [path/to/Janus-35B-A3B.Q4_K_M.gguf]", file=sys.stderr)
         return 2
     root = Path(__file__).resolve().parent.parent
     default_paths = [
-        root / "Janus-27B.Q4_K_M.gguf",
+        root / "Janus-35B-A3B.Q4_K_M.gguf",
     ]
     if len(sys.argv) == 2:
         path = Path(sys.argv[1])
     else:
         path = next((p for p in default_paths if p.exists() and p.stat().st_size > 1024), None)
         if path is None:
-            print("[!] no Janus-27B GGUF found in repo root; pass a path explicitly", file=sys.stderr)
+            print("[!] no Janus-35B GGUF found in repo root; pass a path explicitly", file=sys.stderr)
             return 2
 
     print(f"[*] reading: {path}")
@@ -114,11 +122,12 @@ def main() -> int:
         mismatches += 1
 
     # ---- embedded chat template vs the repo's chat_template.jinja -------------
-    # scripts/build.sh stamps chat_template.jinja into every GGUF it builds, and the
-    # bundled blob carries it too. Nothing else notices if the two drift: the
-    # template is data, the blob is an LFS pointer in a fresh clone, and a stale
-    # embedded copy silently reinstates the tool-calling failure for every loader
-    # that reads the GGUF instead of an external file. This has drifted twice.
+    # Since 0.7.0 this repo ships NO chat_template.jinja: the bundled GGUF carries the
+    # Qwen 3.6 base's own embedded template, untouched, so there are no two copies to
+    # drift and the block below skips. It is kept for the case where a maintainer
+    # reintroduces a repo-side template (as 0.2.0-0.6.5 had): back then the two did
+    # drift twice, and a stale embedded copy silently reinstates the tool-calling
+    # failure for every loader that reads the GGUF instead of an external file.
     repo_template = Path(__file__).resolve().parent.parent / "chat_template.jinja"
     if repo_template.exists():
         f = reader.fields.get("tokenizer.chat_template")