Tessera-27B-B-CJK

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.

This repo holds the merged bf16 weights, 55.6 GB.

Repos

The model comes in four repos.

Repo	Contents
Tessera-27B-B-CJK	Merged bf16 weights, 55.6 GB. This is the model we checked against the evaluated LoRA.
Tessera-27B-B-CJK-LoRA	The PEFT adapter, 1.09 GB
Tessera-27B-B-CJK-GGUF	BF16 GGUF and five Unsloth-layout replica quants, not evaluated
Tessera-27B-B-CJK-NVFP4	NVFP4 and FP8 checkpoint, 23.4 GB, not evaluated

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.

Test	Tessera vs base
Thinking per agent turn. 11 held-out coding-agent tasks, 44 fixed agent states, 2 samples each	0.50-0.64x base thinking tokens. The typical turn, a geometric mean over tasks, is 0.496x, 90% CI 0.385-0.624. The token-weighted ratio is 0.644x, 90% CI 0.208-0.866.
Tokens generated per agent turn, same turns, counting think, answer and tool calls	Mean 575 vs 847
Valid tool calls, same turns	88 of 88, the same as base
Repetition loops, same turns	0 of 88, the same as base
Multi-step agent runs. 9 held-out tasks, up to 15 steps each	Neither model broke existing tests. No measured quality loss, on a small test.
Long context. 6 agent states with 101K-131K-token prompts, output capped at 32,768 tokens	6 of 6 valid tool calls, the same as base. No loops or window fills.
Safety and language smoke test. 20 prompts at 2 efforts, output capped at 4,096 tokens	No flag against the base, by one blind model judge

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

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}
}