Tessera-27B-B-CJK-GGUF

This repo holds GGUF files of Tessera-27B-B-CJK for llama.cpp. The main repo, ZelligeAI/Tessera-27B-B-CJK, holds the merged bf16 weights. Apart from the GGUF section, this card is a copy of the main card. Its results come from the LoRA on Tinker, which matches the merged bf16 weights by a logprob check. They are not measurements of the files in this repo.

Tessera-27B-B-CJK is a coding-agent model built on Qwen3.8-27B. It thinks in compressed CJK, a shorthand that mixes English, Chinese words and symbols, and on held-out agent tasks it uses 0.50-0.64x the base model's thinking tokens per turn. Answers and tool calls stay in plain English and code.

This is a beta release, a rank-32 LoRA merged into the base model's bf16 weights.

The GGUF files

We did not evaluate or run these files.

UL stands for Unsloth layout, and 1 GB is 10^9 bytes. To load the BF16 model, point llama.cpp at part 1, which should read part 2 from the same folder. We have not tried this.

We converted the merged bf16 model to GGUF with llama.cpp at commit c83f3058 and quantized it with llama-quantize. Each quant copies the per-tensor quant types of the unsloth/Qwen3.8-27B-GGUF file with the same name. Each quant also uses Unsloth's imatrix_unsloth.gguf, which Unsloth computed on the base model, not on this fine-tune. We checked every file against its Unsloth counterpart and found 866 tensors and 0 type mismatches in each. The files copy Unsloth's layout. They do not reproduce Unsloth's full procedure on this model. The header of UL-Q8_K_XL says file_type Q4_K_M because we copied that field from Unsloth's UD-Q8_K_XL header.

To run a file with llama.cpp, start from this command. We have not tested it.

# Untested. We did not load or run these files.
llama-server -m Tessera-27B-B-CJK-UL-Q4_K_XL.gguf --jinja -c 65536 \
  --temp 1.0 --top-p 0.95 --top-k 20 \
  --chat-template-kwargs '{"reasoning_effort": "xhigh"}'

For image input, add --mmproj mmproj-Tessera-27B-B-CJK-F16.gguf. We did not test images either.

Repos

The model comes in four repos.

Results

Each test compares Tessera with the untuned base model on the same inputs. Both ran in bf16 at temperature 1.0, top-p 0.95 and top-k 20, at reasoning_effort="xhigh" unless a row says otherwise. Agent turns could fill the 64K-token window. We pre-registered every test.

What a think looks like

Here is one agent turn from the held-out go-critic task, verbatim. It is 27 tokens, followed by two tool calls.

查看`linter`包; 查`FileWalker`; 查checker在`checkers`包中如何注册.

In English it says to look at the linter package, look up FileWalker, and look up how a checker gets registered in the checkers package.

The base model's think at the same state, 137 tokens

Okay, now I understand the astwalk package. What's noteworthy is that `DocCommentVisitor` doesn't receive the node being documented — it only receives the `*ast.CommentGroup`. In the new `DocLinkVisitor`, we need to report diagnostics at the position of the declaration node being documented, so we probably need to pass both the comment group and the node being documented.

Let's look at some existing checkers to understand the pattern. In particular, checkers that use type information (like `tooManyResults`), and how checkers are registered in `checkers.go`. Also, let's look at a doc-comment-related checker like `docStub`.

This draw is shorter than most. The typical turn is 0.496x base.

On this tokenizer compressed CJK saves characters, not tokens, so the saving comes from the model thinking less.

Intended use

Use Tessera in coding-agent loops with reasoning_effort="xhigh". Drop past thinks from the history and sample at temperature 1.0, top-p 0.95 and top-k 20. The fine-tune adds no safety tuning beyond the base model's.

How to use the merged bf16 weights

We tested two loaders on a local copy of the merged bf16 weights. vLLM 0.31 served them for the merge check below, with pre-tokenized prompts, and transformers 5.17 loaded them with AutoModelForImageTextToText. Loading from the Hub and every line marked untested were not run. The stock Qwen3.8 chat template takes reasoning_effort as low, medium or xhigh.

# Tested on a local copy with vLLM 0.31 and these arguments. Our run set max_model_len to 58,640.
from vllm import LLM, SamplingParams

llm = LLM(model="ZelligeAI/Tessera-27B-B-CJK", dtype="bfloat16", max_model_len=65536,
          enforce_eager=True, limit_mm_per_prompt={"image": 0, "video": 0})

# Untested: chat-template rendering through vLLM.
params = SamplingParams(temperature=1.0, top_p=0.95, top_k=20, max_tokens=32768)
out = llm.chat([{"role": "user", "content": "..."}], params,
               chat_template_kwargs={"reasoning_effort": "xhigh"})

# Tested on a local copy with transformers 5.17. Generation was not tested.
import torch
from transformers import AutoModelForImageTextToText, AutoTokenizer

tok = AutoTokenizer.from_pretrained("ZelligeAI/Tessera-27B-B-CJK")
model = AutoModelForImageTextToText.from_pretrained("ZelligeAI/Tessera-27B-B-CJK",
                                                    dtype=torch.bfloat16, device_map="cuda")

Merge check

The merge folds all 401 LoRA pairs into the bf16 weights as W' = bf16(W + B@A). Each tensor keeps 0.965-1.03 of the LoRA delta. lm_head is outside that range in the report, and a float64 recheck put it at 0.99999.

On two held-out sequences of 58,624 and 15,370 tokens, the merged weights on vLLM 0.31 differ from the Tinker LoRA by a mean absolute logprob of 0.024 and 0.012 on the generated tokens. The base model differs from itself across the same two engines by 0.022 and 0.009, and the fine-tune moves logprobs by 0.34 and 0.21. Both sequences passed the pre-registered rule.

Training

The base is Qwen/Qwen3.8-27B at revision 1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0, with the stock tokenizer and chat template. The LoRA has rank 32 and alpha 32 and covers attention, the MLP and lm_head. In the linear-attention layers we fused Tinker's separate q, k and v LoRAs into the Hugging Face in_proj_qkv module at rank 96. The maximum relative fusion error is 6.5e-7.

Training ran in four LoRA steps on Tinker, each starting from the previous weights.

1. Seed SFT on 3,362 of the base model's own thinks in coding, math, logic and knowledge, rewritten into compressed CJK by our own rewriting model and checked by an audit. 2 epochs at learning rate 5e-5.
2. An anti-loop step on 183 token-level preference pairs at loop onsets, with an FTPO-style method. 7 steps at learning rate 1e-5.
3. Agentic SFT on 164 passing DeepSWE-style trajectories with thinks rewritten into compressed CJK, plus a 15% replay of question-answer data. 27.0M tokens, 1 epoch at learning rate 5e-5 on the 256K tier.
4. A rejection-sampling fine-tune (RFT) on the model's own shortest clean rollouts for 33 math and code problem-effort cells, with cross-entropy loss only. 1 epoch of 9 steps at learning rate 1e-5 with a fresh Adam state.

Evaluation data

The 11 coding-agent tasks are DeepSWE-style tasks that we never used in training or selection. Qwen's pretraining data may still contain them. The 118 sealed reasoning items come from AIME 2022-2024, LiveCodeBench hard, LiveCodeBench medium and MATH level 5.

Limitations

• Hard math and competitive code score below the base at every effort, 87 vs 98 of 118 at xhigh. Use the base model for those.
• Repetition loops are rare in agent work, 1 in 100 multi-step agent steps against 0 in 97 for the base. They are more common on hard math, 12 in 198 draws against 0.
• We evaluated the LoRA on Tinker, and the merged bf16 weights match it by the logprob check above. We did not evaluate the GGUF and NVFP4 files, image input, or speculative decoding with the MTP head.

License and citation

The license is Apache-2.0, the same as the base model's, and each of the four repos includes the LICENSE file. The paper is a draft, and a link will follow.

@misc{zellige2026tessera27bbcjk,
  title  = {Tessera-27B-B-CJK: teaching a 27B agent to think less per turn},
  author = {Zellige},
  year   = {2026},
  note   = {Draft. https://huggingface.co/ZelligeAI/Tessera-27B-B-CJK}
}