Tessera-27B-B-CJK: teaching a 27B agent to think less per turn

We release Tessera-27B-B-CJK under Apache-2.0, like its base model. We evaluated it on Tinker and checked that the merged bf16 weights match the evaluated LoRA (section 8). Result numbers in sections 5 and 7 come from the project's frozen numbers sheet (docs/summaries/t10-card-numbers.md) and the pre-registered result blocks it cites. Method, notation and release numbers come from the logs and data files listed in paper/SOURCES.md.

Abstract

Reasoning models spend most of their output on thinking that the user never reads, and an agent loop writes that thinking again on every turn. Tessera-27B-B-CJK is a rank-32 LoRA on Qwen3.8-27B that thinks less per turn and still acts. On 44 frozen states from 11 coding-agent tasks that no training or selection step used, it uses about 0.50-0.64x the base model's thinking tokens per agentic turn. The geometric mean over tasks is 0.496 (90% CI 0.385-0.624) and the token-weighted ratio is 0.644 (90% CI 0.208-0.866). It made a valid tool call on all 88 of its draws, with no repetition loop and no draw cut off by the context window. On 6 agentic states with inputs of 101K-131K tokens it made a valid tool call 6 times out of 6, and the safety and language smoke test raised no flag against the base.

We trained the model on Tinker in four short steps. These were supervised fine-tuning (SFT) on the base model's own thinks rewritten into a compressed CJK notation, a token-level fix for repetition loops, SFT on agentic trajectories, and a rejection-sampling fine-tune (RFT) on the model's own shortest correct rollouts, one epoch.

The style survives the training. Tessera writes compressed CJK in 86 of its 88 agentic thinks, mixing English with CJK words, symbols such as ⇒, and short labels it defines in context, and it keeps its visible answers in plain English. On hard math and competitive code it is worse than the base, 87 against 98 of 118 items at xhigh, and it loops more often there. We release Tessera-27B-B-CJK as an agentic model that thinks less per turn, in a compressed CJK style.

1. Introduction

A coding agent built on a reasoning model writes a think before every tool call. Most thinks are a sentence or two, but some run to thousands of tokens. A model that reaches the same next action with less thinking makes each turn faster to generate.

There are two ways to spend fewer tokens on thinking. One is to think less, by not restating the task or re-checking what is already known. The other is to write denser, by keeping the steps and writing each one in fewer tokens. Our earlier preview model, Tessera-Preview-9B [2], showed that a 9B coding model can move its reasoning into a dense CJK register and still write normal code. This work takes the idea to a 27B model in agentic use, with a richer notation. The notation uses CJK words for common concepts (查 for "look up", 设 for "let" or "assume"), logic symbols (⇒, ∴, ≠), and labels the model defines once and then reuses.

Thinking less worked for agentic turns. On held-out tasks with matched prompts, Tessera thinks about half to two thirds as much as the base per turn, and it made a valid tool call in all 88 draws, none of which looped. Writing denser ended as a style. Tessera is an agentic model rather than a general reasoner, and it gives up accuracy on hard math and competitive code.

2. Background

Reasoning models often keep thinking after they have the answer [3, 4]. Several methods train them to reason more briefly, often with reinforcement learning (RL) and a length term in the reward [5, 6]. Others control the thinking budget at inference time [7], or show that a model already carries a signal for when it can stop [8]. The closest public model is BottleCap AI's ThinkingCap-Qwen3.6-27B [1]. It reports about 46% fewer thinking tokens out of domain at a cost of 0.7 accuracy points. It compares thinking tokens per question in matched pairs, so a model cannot save tokens by giving up. That habit shaped our evaluation.

Our base model is Qwen3.8-27B [10], a 27B hybrid-attention model. Its chat template takes a reasoning_effort of low, medium or xhigh. The agent harnesses we use drop past thinks from the history, so the model writes each turn's think fresh.

The rules of the compressed CJK notation are short. Keep identifiers, numbers, code and negations exact. Replace English scaffolding with single CJK words or symbols. Bind a long phrase to a short label once, then reuse the label. On this tokenizer compressed CJK saves characters, not tokens, so the measured saving comes from the model thinking less. A compressor we own wrote the first examples. It is a LoRA from our caveman-ai project that rewrites English thinking into this style. Later the model wrote the notation itself.

All training and evaluation sampling ran on Tinker, a hosted service that trains and samples LoRAs on open-weight models.

3. From idea to model

(open full-size image in a new tab)

3.1 Seed data from the base model's own thinks

We sampled Qwen3.8-27B on coding, math, logic and knowledge problems at all three efforts and passed each think through the compressor. An audit then checked whether the compressed think still supported the answer. We kept the 3,362 rows it judged preserved, out of 11,156, about 27.7M tokens. We used the model's own thinks, not a stronger teacher's, on purpose. The goal was to change how it writes, not what it knows. Training ran 2 epochs at learning rate 5e-5.

The seed SFT model wrote compressed CJK. On hard problems it sometimes fell into repetition loops, writing one line again and again until it ran out of budget. Every later step had to work around this.

3.2 A small token-level loop fix

We ported Liquid AI's anti-doom method, final-token preference optimization (FTPO) [9], to Tinker. Each training pair holds a loop onset, which is the token that starts the loop, and the model's own top alternatives at that point. A paired importance-sampling loss moves probability from the loop token to the alternatives. With 183 pairs (150 for training, 33 for validation) and 7 steps at learning rate 1e-5, hard loops on a 24-problem holdout fell from 12.5% to 2.1% of draws, and answer agreement with the reference stayed level (88.8% before, 91.1% after).

3.3 Agentic SFT

The seed SFT model switched back to English in long agentic contexts, because it had learned the style only for the prompt shape it trained on. So we collected agentic data the same way. The anti-loop model ran DeepSWE-style software tasks in Docker, using mini-swe-agent with a bash tool. We kept trajectories that passed the task's tests and rewrote each think with the compressor. Three LLM judges from different vendors then checked a sample under a pre-registered protocol. They saw only the compressed think and the actions of each step, with no English, and the sample held 724 steps from the 181 kept trajectories plus 60 planted canaries. All 164 trajectories in the released data are among those 181. 85.6% of the steps passed the strict rule, which needs at least two YES votes and no NO (95% CI ±2.3 points, clustered by trajectory). A follow-up check of the steps that drew a NO found compressor damage in 6 of the 724. Steps that no judge flagged got no second check, so 6 is a lower bound.

The training set has 164 trajectories from 81 tasks, plus question-answer rows that fill 15% of the optimizer steps (29 of 193). That is 27.0M tokens, 7.4M of them supervised. Each trajectory is one sequence on Tinker's 256K tier, with loss only on think and action spans, so the trainer pays for a long history once. One epoch of 193 steps at learning rate 5e-5, with a fresh Adam optimizer, gave the agentic SFT checkpoint, which is the released model's direct parent.

3.4 Why not more SFT, or RL

On a sealed reasoning set, meaning items we never trained or tuned on, the agentic SFT model's thinks were 21.6% CJK characters, at 1.50 characters per token against the base's 2.97. That is what CJK text does on this tokenizer. The thinks looked compressed but used no fewer tokens, since that checkpoint generated 3.81M tokens to the base's 3.60M. It had also lost accuracy and gained loops. Two attempts to fix this explain the final step.

The first attempt was better dense data. Faithful rewrites of the base's long, hard reasoning came out at only about 0.75-0.9 of the original length once a fidelity check held them to the content, and a separate dense-SFT run from the base reproduced the same loops. For the recipes we tried, more dense SFT was not the lever.

The second attempt was RL from the agentic SFT checkpoint that rewarded correct answers first and fewer tokens second. After five updates the policy had more loops and rambled to the token cap more often. Long failed rollouts carried most of the gradient, so each update mostly pushed down on sampled tokens, and entropy rose. With mostly negative advantages, this RL damaged the model faster than it shortened it.

3.5 RFT on the shortest correct rollouts

The alternative uses only positive examples. Sample the model, keep only its best rollouts, and train on them with plain cross-entropy. Banked rollouts showed that the agentic SFT model had a short mode to select. At xhigh its shortest of six correct draws was typically about half its own median.

Below, a clean draw is correct, finished, and free of repetition loops. We had 216 banked rollouts from that checkpoint, 6 draws in each of 36 problem-effort cells. For each cell with at least two clean draws we kept the shortest clean draw, with three guards. It had to be at least 0.4x the base's length, so the model could not learn to collapse. It had to keep at least 0.4x the base's verification markers. And it could be no longer than the cell's clean median. That gave 33 rows (10 low, 11 medium, 12 xhigh). We stored them as the exact sampled token ids.

We first trained two epochs. A frozen gate of 12 held-out cells, 6 draws each, compared the arms. The one-epoch model was better than or equal to the two-epoch model on every measure, with 53 against 52 clean draws, 59 correct for both, and 6 against 8 hard failures. A hard failure is a draw that hit the token cap or ended in a loop. So the second pass over the same rows did harm. A later round on 84 rows (these 33 plus 51 from a fresh resample) was not better either, and we froze the one-epoch model as the release. It missed one gate bar, with 6 hard failures against its parent's 4 in 72 draws, a gap the gate cannot resolve at that size.

(open full-size image in a new tab)

4. How we measured it

Our first agentic measurement put the model at 0.40x the base's thinking per turn. An audit then found that 18 of its 20 states came from tasks in the agentic SFT data, so we withdrew the number. A second, clean measurement used 18 states from never-trained tasks, chosen because the anti-loop model had thought long there. It gave an unclear result, 0.74x (90% CI 0.54-1.04), and its 16K-token output cap cut off 7 of the base's 36 draws. The confirmation round fixed both problems. It uses only 11 tasks that no training or selection step used, it gives both models the full context window, and it samples states without looking at think length.

Agentic runs drift apart after one turn, so a comparison of whole runs mixes thinking style with different histories. The primary test, which we call C3a, freezes 44 states. Each task gives 4 states, with prompts of 8K-49K tokens and past thinks dropped. Both models write the next turn from the same prompt and seed. The registered estimand is the geometric mean over tasks of the per-state log ratio of thinking tokens, with a task-clustered bootstrap CI. We report the token-weighted ratio beside it.

Before any spend, each component had a frozen manifest, a read rule and a spend cap, and "insufficient evidence" was a registered outcome. The components were thinking per agentic turn (C3a), multi-step task progress (C3b), 118 sealed hard math and code items at xhigh (C1), 40 of those items at low and medium (C2), a long-context smoke test (C4), and a safety and language smoke test (S). The round cost $73.68. Sampling uses the Qwen card settings (temperature 1.0, top-p 0.95, top-k 20). C3a, C3b, C1 and C2 give both models the full context window, so the base is never cut off early. The two smoke tests use fixed output caps.

5. Results

5.1 Thinking per agentic turn

(open full-size image in a new tab)

Tessera uses about 0.50-0.64x the base's thinking tokens per agentic turn, from the typical turn to the total workload. No single task drives the result. Leaving any one task out keeps the geometric mean between 0.463 and 0.547. Both models made a valid tool call on every draw.

(open full-size image in a new tab)

Most turns are short. The median think is 23 tokens for Tessera and 37 for the base, against means of 480 and 745, and 65 of the base's 88 draws think for under 100 tokens. On the 9 states where the base thought for 300 tokens or more, Tessera's total was 0.595x the base's, with a heavy tail in both directions (Figure 4). Fewer generated tokens should make each turn faster to produce, although we did not measure latency.

A short example from one state and seed, the first go-critic state, with an 8,249-token prompt:

base (137 think 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`.
-> cat checkers/checkers.go ; cat checkers/docStub_checker.go

Tessera (27 think tokens)
查看`linter`包; 查`FileWalker`; 查checker在`checkers`包中如何注册.
-> cat linter/linter.go ; cat checkers/checkers.go | head -150

Figure 5. One C3a pair. The thinks are verbatim. We shortened the commands by removing each cd /app && prefix and joining two calls with ;. Tessera's think reads "look at the linter package; look up FileWalker; look up how a checker is registered in the checkers package". Both next steps are reasonable but not the same. One pair is an illustration, not evidence.

5.2 Multi-step agentic work

C3b ran both models from frozen mid-task states on the 9 held-out tasks that replay cleanly in Docker, for up to 15 steps each. Each task's own tests then graded the working tree. The registered read is "insufficient evidence". Only one task was informative. On testem the base made 32 more target tests pass and Tessera 16. The mean difference in headroom-normalized gain, which divides the target tests newly passing by those still failing, was -0.0198 (90% CI -0.0593 to 0.0). Neither model broke an existing test. With 9 tasks and one run each, this test could not show parity even for two equal models, and we said so before running it.

5.3 Loops

Loops were this model family's recurring failure, so we report each observation separately. In matched agentic turns (C3a), Tessera had 0 periodic loops and 0 capped draws in 88 draws, and the base also had 0 in 88. In the multi-step runs (C3b), Tessera had 1 periodic step out of 100 steps and the base 0 of 97, with 2 capped steps each. On hard reasoning (C1 and C2), Tessera had 12 periodic loops in 198 sealed draws and the base had 0. So loops are rare in these agentic samples and real on hard reasoning (section 5.4).

5.4 Hard math and code

(open full-size image in a new tab)

Tessera is worse than the base on hard math and code at every effort we tested. At xhigh the drop is outside the registered margin, and at low the point drop sits inside the -3.39 margin without showing non-inferiority. At xhigh the base solved 18 of 18 AIME items and Tessera 14. On MATH level 5 the counts were 39 and 33 of 40, and on medium LiveCodeBench 19 and 17 of 20. On hard LiveCodeBench the two were level, 22 and 23 of 40.

Loops are the largest single cause at xhigh. Tessera looped until it filled the context window on 7 draws and the base on 0 (Fisher p 0.014). Counting every draw that hit the cap, the totals were 19 and 13. Of the 17 items that only the base solved, 7 were loops, 4 were cut off without an exact repeat, and 6 finished with a wrong answer. At medium, 6 of the 7 losses finished wrong and none looped. Thinking at xhigh is also barely shorter than the base's, at 0.904.

(open full-size image in a new tab)

Effort still orders thinking length for both models. The medians in Figure 7 order correctly, but that is an ordering of medians, not a promise for each prompt.

5.5 Long context and safety

On 6 agentic states with inputs of 101K-131K tokens, Tessera made a valid tool call 6 of 6 times, as did the base. Neither model filled the window, looped, or wrote CJK in its visible answer. With one draw per state, this shows that Tessera works at that length but does not measure how well. Tinker's 64K and 256K tiers gave identical logprobs for Tessera on a 58,624-token sequence.

The safety and language smoke test used 20 prompts at two efforts, covering harmful requests, borderline requests, a prompt injection inside a tool output, and plain English tasks. One model from another vendor judged the answers blind, with no human audit. The registered check raised no flag against the base. Tessera refused 10 of 10 harmful draws, where the base refused 9 and partly answered 1. It over-refused none, followed 0 of 10 injections, and wrote no visible answer with more than 5% CJK characters. That is 10 draws per category per model. Tessera is not safety-tuned beyond the base.

6. The compressed CJK notation

Tessera writes compressed CJK in agentic turns. In C3a, 86 of its 88 thinks contain CJK, and across all 88 draws the median CJK share of characters is about a quarter (0.247; the base's thinks contain none). It wrote ⇒ 477 times in 42,227 think tokens, in 10 of its 88 draws, and the base never wrote it. Its visible answers stay in plain English. A longer example from one C3a state follows. For the same prompt the base wrote 388 think tokens and Tessera wrote 163.

设: 查`merge_paths.rs`与`convert_shape_to_path.rs`. 问题: 优化器须保留结构相关规则现有匹配行为; 仅特定元素或关系被结构敏感选择器影响⇒重写需阻止; 同文档无关部分仍可优化; 需从重写前结构+选择器锚点确定(因扁平化/移动目标容器可删除选择器依赖证据); 保护仅当完整选择器关系受影响时生效, 不仅某部分附近出现时; 受影响元素可为选择器目标本身, 或锚点(其关系影响外部子树匹配). 疑为`merge_paths.rs`: 合并路径→改变结构(子数变), 破坏`nth-child`等选择器. 查`merge_paths.rs`.

Figure 8. One Tessera think from the oxvg task, verbatim. It restates the issue in short form, marks a consequence with ⇒, and names a suspect file with a one-line reason. Merging paths changes the child count, which breaks nth-child selectors.

Writing denser has to mean fewer tokens for the same content, and that is where the second way stopped. Qwen's tokenizer has single tokens for most common English words, so a one-token CJK word that replaces a one-token English word gains nothing. We rewrote 27 of Tessera's math and code thinks as concise English with the same content and the same terse style, and the English versions came out 1.2% shorter. So we make no compression claim. Compressed CJK is the style this model thinks in, and the measured gain comes from the first way, thinking less.

Each route to a token saving closed. A style guide in the system prompt barely moved the model. Training on edited copies of its own thinks taught it the edits, and on 22 hard-math draws it then filled the context window with an exact repeat cycle twice, against 0 for a matched control. That gap is not significant (Fisher p 0.49), but it is the loop signature we had seen before, so we stopped. Starting the think in CJK changed nothing, because the weights set the register rather than the first token. New token ids were not available, since Tinker cannot train or sample them and reusing existing ids would save well under one percent.

7. Limitations

• Tessera is worse than the base on hard math and code at every effort we tested, so use the base model for competition math or hard algorithmic code.
• Expect an occasional repetition loop on hard reasoning. One more anti-loop round found only 29 usable training pairs against a target of 40, and training on them did not change how often the model looped again at known loop points (15 of 32 draws against 18 of 32). We closed that route as underdosed, not disproven.
• The quality evidence is thin. The multi-step test had one informative task, so we claim no quality parity.
• Most C3a turns are short, and an earlier clean measurement on long-think states was unclear (0.74x, CI 0.54-1.04).
• Only Tessera and the base ran on the C3a states, so we do not know which training step produced the saving.
• The agentic tasks are held out from our training, but we cannot rule out that they appear in Qwen's pretraining data. The reasoning items are public benchmarks.
• We evaluated Tessera on Tinker. The merged bf16 weights match the evaluated LoRA on two sequences (section 8). We did not evaluate the quantized files and make no claim about them.
• The safety check was a smoke test with one judge, and the model is not safety-tuned beyond the base.
• Section 3 gives the training settings. The evaluation manifests, seeds and scripts are kept in a private archive that this paper does not link.

8. Release

All four repositories build on Qwen3.8-27B (base revision 1d4bf0f) with the stock tokenizer and chat template, under Apache-2.0.

The GGUF files are Unsloth-layout replicas. We copied each tensor's quant type from Unsloth's Qwen3.8-27B GGUF files and used Unsloth's published imatrix, which Unsloth computed on the base model. We did not run or evaluate any GGUF or NVFP4 file.

Tinker trains separate q, k and v LoRAs in the linear-attention layers. The Hugging Face model has one fused in_proj_qkv module there, so a direct conversion silently drops those deltas in 48 of 64 layers. Our adapter fuses them into a rank-96 LoRA on that module, with a maximum relative error of 6.5e-7.

The merged model folds all 401 LoRA pairs into the bf16 weights as W' = bf16(W + BA). With a pass rule fixed in advance, we scored two held-out sequences that Tessera had generated, a 58,624-token agentic trajectory and a 15,370-token math solution. The merged weights ran on vLLM 0.31 (RTX PRO 6000 Blackwell) and the LoRA on Tinker.

The merged model matches the evaluated one to within the noise between the two engines, and it passed the rule. vLLM 0.31 served the merged folder directly, and transformers 5.17 loaded it with AutoModelForImageTextToText. We have not run other loading paths.

Run Tessera in coding-agent loops at xhigh, with the Qwen sampling settings and past thinks dropped from the history. Thinks contain CJK and symbols. Answers and tool calls are ordinary.

Training ran on Tinker and cost about $14 for the anti-loop step and $0.68 for the RFT step.

References

1. BottleCap AI. ThinkingCap-Qwen3.6-27B (technical blog post, 2026). https://bottlecapai.com/post/thinkingcap-qwen3-6-27b/
2. Zellige. Tessera-Preview-9B: Compressed Reasoning at 18x Fewer Tokens, and What It Costs (2026). /research/compressed-cjk-reasoning
3. Do NOT Think That Much for 2+3=? On the Overthinking of o1-Like LLMs. arXiv:2412.21187.
4. Stop Overthinking: A Survey on Efficient Reasoning for LLMs. arXiv:2503.16419.
5. Concise Reasoning via Reinforcement Learning. arXiv:2504.05185.
6. Training Language Models to Reason Efficiently. arXiv:2502.04463.
7. s1: Simple test-time scaling. arXiv:2501.19393.
8. Does Your Reasoning Model Implicitly Know When to Stop Thinking? arXiv:2602.08354.
9. Liquid AI. Reducing Doom Loops with Final Token Preference Optimization (blog post, 2026-07-07). https://www.liquid.ai/blog/antidoom
10. Qwen Team. Qwen3.8-27B model card. https://huggingface.co/Qwen/Qwen3.8-27B