Tessera-Preview-9B: Compressed Reasoning at 18x Fewer Tokens, and What It Costs

Abstract

Reasoning models buy accuracy with tokens, and most of them go to intermediate reasoning that never reaches the user. We test whether that channel can be compressed, and measure what the compression costs. Tessera-Preview-9B is a 9B coding model, fine-tuned from Tesslate/OmniCoder-9B (a Qwen3.5-9B GatedDeltaNet hybrid) on 10,205 examples, that reasons in a dense CJK "mentalese" minted by a compressor we own while emitting ordinary code and well-formed tool calls.

This is a proof of concept. On the full LiveCodeBench set (1,055 problems, same harness, same prompts, same 16,384-token generation budget, both models paired per problem), Tessera scores 34.9% at greedy against 39.5% for its own re-measured base, a real gap (McNemar p ≈ 0.002), while spending a median 17.7× fewer output tokens per problem (19.6× restricted to problems both models completed; the multiple is a lower bound because the base's median output is the 16K ceiling). The reasoning is causally load-bearing: on the archived 50-problem protocol, forcing an empty think collapses accuracy to 4%, with 48 of 50 outputs empty. The channel separation is measured on the same archived run: the reasoning stream carries a median 29.1% CJK characters, the emitted code 0.0%.

The two models fail differently. The base almost never writes wrong code: 95.9% of the problems it completes, it solves, but it thinks into the token ceiling on 58.8% of problems at greedy. Tessera inverts the economy: it completes 78% of problems at a median 639 tokens end-to-end, and errs mainly by writing wrong code (44.5% completion accuracy). Sampling helps the base (+6.4 points at temperature 0.6, by breaking greedy reasoning loops) and does nothing for Tessera (−1.2), so the base leads at every operating point measured: by 4.6 points at matched greedy and 12.2 at matched temperature 0.6. On IFEval the gap is wider (40.9% vs 59.9% prompt-strict): Tessera falls into a 16K reasoning loop on 46.8% of instruction-following prompts, a prompt family its 100%-code training corpus contains zero examples of.

That last observation anchors our read of the whole result. The capabilities the small corpus covers (repository coding, tool calls, the compressed register itself, multi-turn recall) transfer or degrade modestly; the capabilities it does not cover collapse. This pattern is consistent with the training data (7.62M target tokens, all code-agentic) being a major cause of the measured gaps, though it does not prove it, and we are explicit below about what would (§7). What the preview establishes is the feasibility claim: a 9B model can relocate its reasoning into a compressed private channel, keep the output channel clean, and retain most of its coding ability at a ~18× token discount, from a single small LoRA run. Whether scale, of data above all, closes the remaining gaps is the question the successor is built to answer. The model, the compressor, and its usage harness are released at ZelligeAI on Hugging Face.

1. Introduction

Chain-of-thought and extended "thinking" traces are now standard for hard coding and agentic work, and they demonstrably help. But the help is paid for in tokens. Every thinking token is latency the user waits through and cost the operator absorbs, and on hard problems the reasoning trace routinely dwarfs the answer it produces. Measured concretely on our own base model: across the full LiveCodeBench set at greedy decoding, its median response is pinned at the 16,384-token generation ceiling, and nearly six problems in ten end with the budget exhausted mid-thought.

One response is to compress the reasoning itself. If a model can carry the same latent computation in fewer, denser tokens, it keeps some of the accuracy that thinking-out-loud buys at a fraction of the token bill. The risk is that compression is not free: forcing a model to reason in an unfamiliar compressed register could degrade the very capabilities it is meant to preserve. How much capability, and where the damage lands, are empirical questions, and answering them cheaply, before committing to scale, is the entire purpose of a preview model.

The specific bet in Tessera-Preview-9B is a 9B model that reasons internally in compressed CJK "mentalese" but emits clean code and real tool calls in ordinary form. CJK notation packs more meaning per character, and the owned compressor's token-level gates measured a ~1.4× token reduction against native verbose thinks on training passages (§5.3 decomposes this at inference time: the register itself buys ~1.7× per think, and most of the measured saving is trained brevity rather than notation). The reasoning channel gets denser while the output channel stays exactly as legible as before. A user never reads the mentalese; they get normal code and normal, valid tool calls.

Three properties are at stake, and the preview measures all three:

1. How much coding capability survives. Measured against the model's own base on the full LiveCodeBench set, paired per problem, at a matched generation budget.
2. Whether the model actually reasons in compressed CJK. Reliably, under real agentic pressure, not only when prompted gently.
3. What it costs elsewhere. Instruction following, sampling robustness, and out-of-distribution behavior all get measured directly.

The preview is small on every axis: one LoRA fine-tune on a single GPU, a 10,205-example corpus (7.62M target tokens, 100% code-agentic), a single 9B base, an unrefined single-pass compression pipeline. Across nineteen prior ad-hoc iterations, variants achieved one or two of the desired properties and lost the rest; Tessera is the first run built under a pre-registered protocol (§3.4) to answer the question cleanly. The result is mixed: the mechanism works (the model thinks in the compressed register, ships clean code, and holds most of its coding ability at ~18× fewer tokens) and the costs are real, landing where the training distribution is thinnest (§5.5, §6). If those gaps are mostly a data-coverage artifact, a larger corpus closes them; if they are intrinsic to the compression, better to learn it at 9B than after scaling. The scaled successor (larger base, substantially larger and broader corpus, refined compression and data-collection pipelines) is in active preparation, and this paper is the baseline it must beat.

2. Related work

Compressed and truncated reasoning is an active line. ORION (arXiv:2511.22891) trains models to reason in a compact "mentalese" with SLPO and reports 4–16× compression at 90–98% of accuracy; it is the closest antecedent to this work. Chain of Draft (arXiv:2502.18600) reaches ~7.6% of the token count through prompting alone. TokenSkip (arXiv:2502.12067) prunes ~40% of CoT tokens with <0.4% performance drop via LoRA. A complementary line questions length itself: shorter chains can be more accurate (arXiv:2505.17813), reasoning length correlates negatively with performance under budget control (arXiv:2602.13517), and aggressive CoT compression can even improve accuracy (arXiv:2602.08324). OpenThoughts (arXiv:2506.04178, ICLR 2026) documents the data-recipe discipline for reasoning distillation that our pipeline borrows in spirit.

What this work adds is not a new compression objective but an owned, deterministic compressor with fidelity gates (§3.1): training targets are minted by a 1.5B student we control, under per-passage checks that numbers and identifiers survive compression, so a compression failure costs savings rather than fidelity. Combined with an inference-faithful training render (§3.3) and a pre-registered evaluation contract (§3.4), the contribution is a cheap, inspectable measurement of what reasoning compression preserves and what it costs at small scale, with the savings multiple measured and paired against the model's own base on the full benchmark (§5.3).

3. Method

3.1 An owned compressor

No public dataset supplies compressed-CJK reasoning, so training targets must be minted. We did that once with a bounded DeepSeek teacher rig, then trained a Qwen2.5-Coder-1.5B-Instruct LoRA to replace it. The design that worked is passage-level compression: segment and group a native <think> block, classify each passage, compress it against chain-tail context, then run per-passage fidelity gates. The passage's novel numbers and identifiers must survive as substrings; output must not exceed a rules-only compression in tokens; no code fences. Any passage that fails falls back to rules-only. Whole-block one-shot compression failed acceptance precisely because it asked the smallest model to do something the teacher itself never did.

All acceptance numbers are measured on the same 103 held-out mixed reasoning blocks, never trained on, under four pre-registered criteria: (1) the per-passage fidelity gate, requiring that novel numbers and identifiers survive compression as substrings (a lexical check; the judged criterion 4 covers semantics), at 99.0% of passages; (2) median per-passage compression ratio 0.716, inside the teacher-gold band; (3) CJK adoption 98.9%; and (4) a judged semantic-equivalence check at 103/103 blocks, against 97.1% for the teacher's own references on the same blocks. 24% of passages fall back to rules-only compression, matching the teacher's own fallback rate on the same data; fallback passages count against savings, never against fidelity, and the 30.4% effective corpus saving is net of them.

Owning the teacher matters beyond the artifact: any high-quality English reasoning dataset becomes Tessera training data at near-zero marginal cost, and a data bug is fixable deterministically instead of by re-rolling a stochastic frontier model.

3.2 Data design

Tessera trains on 10,205 examples (7.62M target tokens, 2 epochs) in four pools, budgeted by token mass. The backbone (Pool A, 7,428 single-turn CJK examples) is proven data behind the best prior coding checkpoint, re-gated to a 99% CJK pass rate (8,305/8,389 before selection). Pool B (877) wraps backbone items in tool schemas to control the call ratio; P(call | tools present) is held at 40.5% on a target-turn basis. Pool C (1,500) replaces every prior synthetic agentic pool with real, execution-verified long-horizon trajectories from CoderForge-Preview (reward-1 split; per-record source licenses, all permissive in our slice, see Appendix B), compressed through our own pipeline. The 1,500 windows were selected from a ~2,500-trajectory converted bank (6× surplus), with 375 termination windows, 589 unique tasks, and quartile-stratified turn counts (6–42) against mode collapse. Pool R (400) fills the one behavior with zero prior coverage, multi-turn recall, by deterministic extraction: a templated follow-up whose answer is substring-verified against the conversation. That is synthesis of the narrow anti-hallucination kind.

The pool-C decision was diagnosis-driven. Retrospective evidence localized an earlier capability collapse to the interactional layer (lost conversation chain, no recall) while the CJK reasoning layer held. The short, templated synthetic pools were the identified cause and were dropped outright, along with ~10.5K unverified raw traces.

The corpus is 100% code-agentic, a fact §5.5 turns on. It contains no general instruction-following data, no long-form writing, no IFEval-style constraint prompts. That narrowness kept the preview small and fast to train, and it has measurable consequences.

3.3 Training recipe

Two training-side fixes define the run, both surfaced by a dedicated pre-run review:

• F1: train ≡ serve. Training examples are rendered inference-faithfully at pretokenize time: history assistant turns carry empty or no think blocks exactly as the serving template produces them, with the full CJK think and the loss on the target turn only. A no-GPU render-diff gate confirmed 600/600 records byte-identical to inference replay before pretokenization proceeded. This closed a confirmed train/serve contract violation in earlier runs, where every mid-conversation context at deployment was out-of-distribution relative to training.
• F3: token-mass loss normalization. Grad-accumulation loss is normalized over the accumulated batch's unmasked tokens, so ~1.2K-token single-turn items don't silently get 50–100× per-token up-weighting over 7–14K-token agentic windows. The known cost: the fix defeats fused cross-entropy, materializing full logits, which pushes peak VRAM to 65.5/80 GB at the 14K-token windows. Larger sequences or a larger model OOM on one GPU; that is a known scale-up boundary.

Figure 1. Training loss over the single gated run (raw per-10-step values, EMA overlay), from the preserved trainer state. The token-mass normalization (F3) was active for the entire run; peak VRAM 65.5/80 GB.

3.4 Pre-registration as method

After nineteen ad-hoc iterations, a written contract replaced guessing. Ten behavioral probes with numeric acceptance bars were frozen before any Tessera data existed (probe 10 added by a written amendment), and moving a bar requires writing down why, in the file. The contract imposed a hard cap of two 9B training runs (the run reported here plus at most one debug run, the entire remaining training budget) and explicit stop rules: ship at ≥8/10 probes, one narrowly-scoped debug at 6–7, stop below that. A behavioral-coverage checklist enforced the retrospective's load-bearing lesson that every past failure was visible in the data before training, by requiring, per probe, a counted number of demonstrating examples in the assembled set. One amendment predates assembly and is disclosed: the agentic token-mass cap was raised from a registered ≤25% to ~40–53% before any data was assembled or any model measured, with the rationale written down (the cap had been defending against synthetic data that no longer exists in the mix).

The discipline caught two of its own measurement errors, and both matter to how this paper should be read. First, an early automated pass reported a 14-point coding regression that traced to an unpinned sampling temperature in the harness, not the model (§5.4). Second, and more consequentially: the frozen probe protocol evaluated coding and instruction following on the first 50 problems of each benchmark, for comparability with how all prior internal checkpoints had been measured. When the full sets were run for this paper, every accuracy, both models and both benchmarks, dropped by roughly half: the first-50 slice is simply much easier than the full distribution. The probe gate was met under its frozen protocol (§5.6), but the full-set numbers reported throughout this paper supersede the slice numbers, including two the gate relied on. One consequence: the full-set analysis, its McNemar p-values included, is post hoc relative to the frozen contract and should be read as descriptive rather than confirmatory. Pre-registration caught the temperature bug; it did not protect against an unrepresentative slice baked into the frozen protocol itself. The successor's contract fixes the slice.

4. Experimental setup

Serving. The base ships as a vision-language wrapper (AutoModelForImageTextToText), so serving requires a merge, repack, and config swap: merge the LoRA on CPU, repack keys (model.language_model.* → language_model.model.*), swap in the Qwen3.5-9B text config, and launch vLLM. The full recipe and the containerized evaluation bundle are in Appendix B.

Evaluation. Coding uses LiveCodeBench release_v6, the full 1,055-problem set, pass@1, max_tokens 16384; instruction following uses the full 541-prompt IFEval. Harness is evalscope 1.9.0 with sampling temperature pinned explicitly per condition; §5.4 documents what happens when it is not. Problems that generate to the 16,384-token ceiling without completing are scored as failures. Behavioral probes use a frozen harness (seeded, temperature per probe spec) whose bars predate the data (§3.4).

Measurement environment and stack sensitivity. All full-set numbers come from one pinned, hermetic stack: vLLM 0.21.0 (the official release image), CUDA graphs, evalscope 1.9.0 with dataset bytes staged from our own storage, run as containerized jobs on A100-80G. The stack is pinned because we measured that it matters: replaying the same 50-problem greedy evaluation across serving stacks (two vLLM versions, eager vs CUDA-graph execution, three GPU environments) moved the score between 54% and 66% and moved the 16K-loop rate by 3×, with prompts byte-identical and no flipped problem sharing identical code: pure kernel-numerics trajectory divergence, to which greedy decoding on a loop-prone model family is maximally sensitive. vLLM 0.24.0 degraded this model asymmetrically and is disqualified; the pinned stack was validated against an eager reference profile before any full-set run. Greedy point estimates for this model family should be read as stack-conditioned; the paired design (both models, one stack) is what protects the comparisons within that stack; it does not establish that the gap itself is stack-independent. The full validation matrix ships with the evaluation bundle.

5. Results

5.1 Coding: most capability survives, and the gap is real

Figure 2. Full-set scores with Wilson 95% intervals, both models on the pinned paired harness. Left: LiveCodeBench-1055 at both temperatures, 16K budget. Right: IFEval-541 prompt-strict at greedy.

At matched greedy decoding on the full set, compression as trained here costs 4.6 points of coding accuracy (paired difference −4.6 points, 95% CI [−7.5, −1.8]; exact two-sided McNemar on the 231 discordant pairs, p ≈ 0.0015: a real gap rather than noise). The two models agree on 277 solved and 547 unsolved problems; Tessera alone solves 91, the base alone 140. For calibration: 34.9% is 88% of the base's greedy score, retained through a register change, a 10K-example fine-tune, and an 18× budget cut.

The per-benchmark pattern is the paper's most informative result. The gap is smallest where the training corpus is densest (repository-style coding), moderate on coding overall, and largest on IFEval, a prompt family the 100%-code corpus contains zero examples of (§5.5). Capability loss tracks data coverage, not some uniform tax on everything the base knew. That is the signature you would expect if the small corpus, rather than compression per se, is the binding constraint, an interpretation the preview cannot prove but the data-scaled successor directly tests. The alternative, that relocating reasoning into a compressed register intrinsically costs capability, is not excluded; §7's brevity-matched English control is the experiment that separates them.

5.2 Channel separation

The design promise is that compression stays confined to the private channel. Per-problem measurement over the archived greedy run confirms it: the reasoning stream carries a median 29.1% CJK share of non-space characters (an intentionally mixed register, CJK operators and connectives over preserved English/code identifiers, per the fidelity gates), while the emitted code carries a median 0.0%. None of the 46 completed problems leaked CJK into the shipped code channel, and the compressed-register rate under sampling pressure is 100% (probe 5, temperature 0.7).

Figure 3. CJK share per problem across the two channels (46 completed problems of the archived greedy run; horizontal bars mark medians). The separation is categorical: the output-channel distribution is a point mass at zero.

5.3 The savings multiple, measured and paired on the full set

Across all 1,055 paired problems at greedy, Tessera's median end-to-end output (reasoning plus answer) is 639 tokens; the base's is 16,384, the generation ceiling itself, because 58.8% of its responses die there. The per-problem paired multiple is a median 17.7× (16.7× at temperature 0.6). Restricting to the 406 problems both models completed, where the base's thinks are efficient by its own standard, the multiple is 19.6×. Because the ceiling censors the base's true output lengths on a majority of problems, the all-problem multiples are lower bounds; the both-completed 19.6× is the one uncensored estimate.

Figure 4. All 1,055 problems, one point each: Tessera's output tokens against the base's on the identical prompt (log-log; guides at 1×/10×/30×). The horizontal band is the base's 16,384-token ceiling; 58.8% of its responses sit on it. Blue points are problems Tessera solved, red ones it failed; the failures are not concentrated among its cheap responses.

At the think-channel level (measured on the archived 50-problem run, where reasoning and answer streams were recorded separately), Tessera's median think is 248 tokens against the base's ~10,000: a 33× multiple on the private channel specifically, with a median 176-token answer riding on it. The frozen think-budget probe passes at a median of 148.5 tokens against its ≤400 bar.

The saving was trained in, and the training data accounts for most of it. The compression pipeline's contribution can be measured directly on grounded data, because every compressed think in the agentic training pool retains its English source; the pairs are same-meaning by construction, each CJK think being the pipeline's fidelity-gated rendering of that exact English source rather than an independently judged match. Across all 45,202 paired thinks, the compressed CJK rendering costs a median 0.58× the tokens of its English source (2.5% are intentional sub-0.2× stubs, exploration narration reduced to action markers; excluding them barely moves the median, 0.59×). The 0.58× is smaller than the compressor's per-passage 0.716 (§3.1) because it is measured on whole thinks, where segmentation glue, connective narration, and the stub tail are removed on top of the fidelity-gated passage compression. Re-notation plus glue-removal therefore accounts for roughly 1.7×, measured on training pairs rather than as an inference-time intervention. The rest comes from the training corpus simply thinking less: the median training target think is 23 tokens (mean 168, p90 418, sampled n=4,229), short per-step deliberations rather than the base's monolithic ceiling-length traces, which appear nowhere in the training distribution. At inference on hard problems Tessera draws from the upper tail of what it was taught, a distribution match Figure 5 makes visible. The decomposition is roughly 1.7× from the register and the balance from a brevity curriculum; one measurement already suggests the notation itself may contribute little (the worked example's 538-character CJK think is 372 tokens while a faithful minimal-English rendering of the same content is 274, because CJK characters cost roughly one token each while English amortizes ~4 characters per token). The brevity-trained English control (§7) is the decisive experiment.

Two verbatim training pairs show what the 0.58× looks like when it preserves meaning; identifiers, line numbers, and logic survive the register change (token counts under the model's tokenizer):

Pair 1 (85 → 49 tokens, 0.58×):

EN : So the classes are: - Integer (line 32) - Boolean (line 262) - BitString (line 341)
     - OctetString (line 693) - Null (line 971) - ObjectIdentifier (line 1023)
     Let me look at the base class to see if it defines __mul__:

CJK: Integer(line32),Boolean(line262),BitString(line341),OctetString(line693),
     Null(line971),ObjectIdentifier(line1023). 查基类是否定义__mul__:

Pair 2 (130 → 82 tokens, 0.63×):

EN : Good! We fixed the IndexError, but now we have a different issue. The problem is
     that for frames where we don't provide a duration value in the list, the
     encoderinfo["duration"] key is never set, so it falls back to the default value
     of 0. But when we get to line 1152: [code follows]

CJK: 设: 缺duration值→encoderinfo["duration"]未设置⇒回退0. 然至line1152:
     [code follows] It's trying to call `round()` on list (default value 0), but
     actually that ¬ make sense. check what default value should be:

Figure 5. Left: the 45,202 paired same-meaning thinks from the agentic training pool (English source vs compressed CJK tokens, log-log; subsampled for display). The cloud hugs the 2× guide. Right: reasoning-length provenance. Tessera's inference thinks (blue) are drawn from its training distribution (green); the base's native traces (grey) sit more than an order of magnitude to the right and were never part of the training distribution.

5.4 Temperature: the base has sampling headroom, Tessera has none

An early automated pass reported a 14-point coding regression that traced to the harness omitting temperature: 0.0 and silently sampling at a nonzero default. The re-run at matched greedy settings erased the "regression", and the episode fixed a standing rule: temperature is part of the serving contract, and every number in this paper pins it explicitly.

The full-set measurement settles the temperature story. The base benefits from sampling, at least at the one temperature measured: 39.5% at greedy rising to 45.9% at 0.6, because sampling noise breaks the greedy reasoning loops that kill 58.8% of its greedy responses (its budget-death rate falls to 52.3% and its completions remain 96% accurate). Tessera is flat to slightly fragile: 34.9% falling to 33.7%. Its compressed thinks rarely loop, so it has nothing to gain from sampling and only distribution-sharpness to lose. The net: the base leads at both operating points, by 4.6 at matched greedy and 12.2 at matched temperature 0.6 (paired 95% CI [−15.0, −9.3]; 11.0 comparing each model at its better setting). (On the easy first-50 slice this appeared as a dramatic crossing with Tessera fragile by 10 points; the full set shrinks Tessera's fragility to noise and reveals the slice artifact. The direction (base gains, Tessera doesn't) replicated; the magnitudes did not.)

The operational consequence for Tessera deployment stands: greedy for code, pinned in the serving config. The deeper consequence is for the method: a model trained to think briefly in a narrow register forfeits the sampling-mode headroom that verbose reasoning families get for free, and recovering it (sampled-decode augmentation, self-consistency over cheap candidates, which the 18× savings can fund) is successor work.

Figure 6. Temperature response on the shared harness, full 1,055 problems. Sampling rescues the base's looping failures (+6.4); Tessera, which rarely loops on code, is flat (−1.2). The base leads at both points.

5.5 Instruction following: where the narrow corpus bites

IFEval is Tessera's worst benchmark, and the mechanism is specific. At greedy on the full 541 prompts, Tessera scores 40.9% prompt-strict against the base's 59.9% (paired difference −19.0 points, 95% CI [−24.5, −13.6]; exact McNemar p ≈ 5e-11 on 72 Tessera-only vs 175 base-only discordant prompts), and 46.8% of its responses are 16,384-token reasoning loops that never produce an answer. The same model that loops on 21.6% of hard competitive-programming problems loops on nearly half of "write a travel blog post in all lowercase" prompts. Its completion accuracy when it does answer is 76.7%, against the base's 93.4%.

We read this as the clearest data-coverage signature in the preview. The training corpus contains literally zero prompts of this family (§3.2): no long-form writing, no formatting constraints, no general chat. The base's own instruction tuning, which the LoRA overwrites in the reasoning channel, is what knew how to budget thought for such prompts. Behaviors the corpus does cover degrade far less (coding, −4.6) or not at all (tool-call formatting, the compressed register, multi-turn recall, all §5.6). This is the pattern a data-coverage cause would produce, though a compression-intrinsic contribution cannot be excluded from this data alone.

Two disclosures qualify the comparison. First, the archived first-50 IFEval number for Tessera (68%, reported by the frozen probe protocol) was inflated twice over: the slice is easy, and the archived serving path returned think-text inline for a scorer that stripped it manually, on a run that itself contained 24% empty responses. The full-set number from the pinned reasoning-separated harness supersedes it entirely. Second, because loop rate was the most stack-sensitive behavior in our validation matrix (§4), we replicated this measurement on an independent serving stack (eager execution, different GPU environment): 41.3% prompt-strict with a 48.4% loop rate, against 40.9% and 46.8% on the pinned stack. The instruction-prompt loop is a property of the weights, not of any one serving configuration.

5.6 Failure analysis: two different economies, and the probe scorecard

Figure 7. Left: outcome decomposition for both models at both temperatures on the full set (pass / wrong answer / budget death), with completion rates and completion accuracy annotated. Right: the think-channel ablation of §5.7 (archived n=50 protocol).

The base essentially never writes wrong code: 18 wrong answers in 1,055 problems at greedy (1.7%); everything else it either solves (417) or exhausts the budget thinking about (620). Its bottleneck is not reasoning quality but reasoning termination. Tessera inverts the economy: it completes 78% of problems, cheaply and promptly, and its errors are ordinary wrong answers (459 at greedy, 43.5%). Compression training cut the family's budget-death rate by nearly two-thirds (58.8% → 21.6%) and replaced silent budget exhaustion with fast, inspectable failure.

Which economy is preferable depends on the deployment. Token counts alone suggest a budget-capped, latency-sensitive serving path benefits from Tessera's economy on easy-to-medium work while an unconstrained-budget path favors the base, but we have not measured latency or dollar cost directly, and both greedy scores are functions of the 16,384-token budget: 58.8% of the base's greedy responses end at the ceiling unresolved, and whether those convert to passes at larger budgets is what §7's budget-scaling curves would measure.

A second, independent gap: on greenfield tasks requiring a large body of new code, Tessera tends to dump the code inline rather than route it through the write tool. The agentic training traces under-represent "author a new file" relative to "read-then-edit an existing file"; on the read-then-edit path the model behaves (read-before-fix 9/10, correct Read→Edit on real files). The gap tracks the training distribution, the same coverage pattern as §5.5.

The pre-registered probe scorecard. Ten behavioral probes were frozen before the data existed (§3.4); the gate required ≥8/10 and was met at 8/10 under the frozen protocol. We report all ten with provenance, and flag the two whose frozen protocol the full-set measurement has since superseded:

The behavioral probes that measure mechanism (register stability, channel separation, confabulation, recall) all hold, at full strength. The two that measured capability on an easy slice were met as written and are superseded by the full-set numbers. We keep both facts on the table: the gate did its job on the mechanism claims, and it embedded an unrepresentative slice for the capability claims, a protocol bug the successor's contract fixes (§3.4).

5.7 The compressed channel is causally load-bearing

Could the mentalese be decoration, with the model solving problems in the forward pass and narrating afterward? The ablation answers no. Serving the identical weights with a chat template that force-closes the think block (<think>\n\n</think>, the model's own native no-think rendering) collapses greedy LCB from 66% to 4% on the archived 50-problem protocol, and the failure mode is total: 48 of 50 outputs are empty. Deprived of its reasoning channel, Tessera does not produce degraded code; it produces nothing. Generation is inseparable from the think policy.

Two qualifications apply. First, an empty think on the target turn is out-of-distribution by construction: the inference-faithful render (§3.3) always trained a full CJK think there, so the ablation demonstrates that the think channel is causally necessary for generation under this template, not that the content of the mentalese is what matters; a scramble-think variant (§7) would separate content from format. Second, this has a deployment consequence worth stating plainly: Tessera has no functional no-think mode. The enable_thinking: false switch that works on the base family effectively disables Tessera.

6. Limitations

• This is a preview, and the gaps are real. At matched full-set greedy the base leads by 4.6 points on coding and 19 on instruction following, and it leads at every temperature measured. Nothing in this paper claims otherwise; the claim is feasibility at 18× fewer tokens, with the costs measured.
• The data-coverage explanation is supported, not proven. Capability loss tracks training-corpus coverage (§5.1, §5.5), which implicates the 10K-example, 100%-code corpus, but a compression-intrinsic capability tax at this scale would produce partially overlapping evidence. The brevity-matched English control and the data-scaled successor are the separating experiments.
• The notation's own contribution is small and possibly negative. The measured decomposition (§5.3) assigns the register ~1.7× (0.58× median on 45,202 paired training thinks) and the brevity curriculum the rest; the same-content comparison (CJK 372 vs minimal-English 274 tokens) suggests disciplined English could do at least as well per think.
• Budget-relative scores, on both sides. All greedy accuracies are functions of the 16,384-token budget: 58.8% of the base's greedy responses and 21.6% of Tessera's die on the ceiling, and the savings multiple is censored by the same ceiling (a lower bound). Budget-scaling curves (§7) are the missing figure.
• Greedy point estimates are stack-conditioned. Replaying the same evaluation across serving stacks moved n=50 greedy scores by up to 12 points and loop rates by 3× (§4). Full-set paired comparisons are valid for the pinned stack, though pairing does not establish stack-independence of the gap; single absolute numbers quoted without their stack are softer than they look, an observation we suspect generalizes beyond this model family.
• The ablation shows necessity, not content-dependence. Force-closing the think collapses the model (§5.7), but an empty target-turn think is out-of-distribution by training design; a scramble-think test is needed to show the content of the mentalese matters.
• Single base, single scale, one training run. One 9B hybrid-attention base, one LoRA run under the pre-registered cap; nothing here establishes the behavior transfers across architectures or scales. That is precisely the successor's question.

7. Future work

The successor program, already in preparation, is organized around one question the preview sharpened: how much of the measured cost is the corpus, and how much is the compression? In priority order:

1. Scale the data, broadly. A substantially larger corpus that covers what the preview's could not (instruction-following prompts, long-form output, greenfield file authoring) alongside more and harder code. If the coverage hypothesis of §5.5 is right, this closes most of the IFEval gap and some of the coding gap; if it doesn't, that is strong evidence for an intrinsic compression tax.
2. Brevity-vs-notation control. A brevity-trained English variant on the same data budget. If disciplined English matches the CJK register's budgets and scores, the notation is doing no work and the contribution is the brevity curriculum.
3. Budget-scaling curves. Pass@1 as a function of generation budget (4K/8K/16K/32K) for both models turns the budget-relative snapshot of §5.6 into the efficiency frontier this work is implicitly about, including where (or whether) the base's curve overtakes at large budgets, and at what token cost.
4. Scramble-think ablation. Substituting shuffled or off-topic mentalese of matched length separates the content of the compressed reasoning from its format (§5.7 established only necessity).
5. Sampling-robustness recovery. Sampled-decode augmentation during SFT, a robustness term in the optional RL stage, or greedy self-consistency over n candidates, the last funded by the 18× savings itself.

The successor also moves to a larger base model, adds a genuine agentic benchmark (SWE-bench-style) so tool-use is measured rather than probed, replaces single runs with distributions, fixes the evaluation contract's slice bug (§3.4), attacks the residual 16K-loop tail (better stop criteria or the length-penalty RL stage), and carries the public training-data release.

Appendix A: A worked example

LiveCodeBench problem 33 of the archived greedy run (LeetCode-style Minimize String Length), solved correctly. The complete private reasoning is 538 characters, 68% CJK, and 372 tokens under the model's tokenizer (the English gloss below is 274; see §5.3). It states the problem, finds the invariant, sketches a proof, and flags the edge case. The shipped answer is three lines of ordinary Python. This is the intended behavior on a real benchmark problem: deliberation in the compressed register, a clean shipped answer.

Private reasoning channel (excerpted from the 538-char record):

设 s 为 0-indexed 字符串。操作：选 i，c=s[i]，删除 i 左侧最近 c 和右侧最近 c（若存在）。
可重复任意次。求最小化后长度。

观察：每次操作删除两个相同字符（可能一个）。关键：操作不改变字符种类集合，仅减少计数。
最终每个字符种类最多剩 1 个。

考虑贪心：每次选中间字符删除两侧同字符。……只要计数 ≥2，总能通过选择中间字符删除一对，
直到只剩 1 个。故最终长度 = 不同字符数。

证明：操作不改变字符种类，仅减少计数。若最终有 ≥2 个同字符……选中间位置（如 p⌈k/2⌉），
其左侧最近 c 为 p⌈k/2⌉-1，右侧最近为 p⌈k/2⌉+1，删除后计数减 2。重复直至只剩 1 个。
故最小长度 = 不同字符数。

算法：返回 len(set(s))。复杂度 O(n|1)。⊘：s 长度 1 → 返回 1。

Gloss: Let s be a 0-indexed string. Operation: pick i, c=s[i]; delete the nearest c to the left and right of i, if they exist; repeat freely; minimize final length. Observation: each operation only reduces counts, never removing a character class. Greedy: while any class has count ≥2, picking a middle occurrence deletes a pair, so every class reduces to exactly one survivor. Proof sketch follows; hence minimum length = number of distinct characters. Algorithm: return len(set(s)). Edge (⊘): length-1 string → 1.

Output channel (verbatim, complete):

class Solution:
    def minimizedStringLength(self, s: str) -> int:
        return len(set(s))

Middle sections of the reasoning are elided (……) for layout only; the full 538-character record is preserved in the archived per-problem JSON. ⊘ is the compressor's edge-case marker, and O(n|1) is the compressed register's complexity shorthand (time n, space 1), not a typo in our transcription: notation artifacts like these are part of what the model learned from the compressor's output distribution.

Appendix B: Reproduction

Base: Tesslate/OmniCoder-9B (Qwen3.5-9B GatedDeltaNet hybrid, 24 DeltaNet + 8 full-attention GQA layers, distributed behind a vision-language wrapper, which is why the repack exists).

Licensing (verified via the Hugging Face API). The base model is Apache-2.0, ungated. togethercomputer/CoderForge-Preview declares no dataset-level license; licensing is per-record (each trajectory carries its source repository's license). Our exact 1,500-window training slice is 100% permissive: BSD-3-Clause 545, HPND 370, MIT 368, Apache-2.0 166, BSD 15, BSD-2-Clause 12, BSD-3-Clause AND MIT 12, PSF-2.0 12. No copyleft. The residual obligation is per-record attribution handling if the training data itself is ever redistributed; the trained-model release is not license-blocked. The full training pipeline remains internal; the compression usage harness ships with the compressor.

Serving and evaluation stack (pinned). All full-set numbers: vLLM 0.21.0 (official vllm/vllm-openai:v0.21.0 image), CUDA graphs, evalscope 1.9.0, A100-80G, containerized jobs with dataset bytes staged from project storage (fully hermetic at eval time). The bundle, comprising model prep for both Tessera (merge → repack → config swap) and the base (repack-only, identical tokenizer and chat template), a one-condition-per-job runner, and the stack-validation record (the 54–66% cross-stack matrix of §4), is archived with the project. Serve recipe:

python3 -m vllm.entrypoints.openai.api_server \
  --model ZelligeAI/tessera-preview-9b --served-model-name tessera-preview-9b \
  --host 0.0.0.0 --port 8000 --max-model-len 32768 --max-num-seqs 64 \
  --language-model-only --dtype bfloat16 \
  --gpu-memory-utilization 0.90 --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

evalscope eval --eval-type openai_api --model tessera-preview-9b \
  --api-url http://localhost:8000/v1 --api-key dummy \
  --datasets live_code_bench --eval-batch-size 64 \
  --generation-config '{"max_tokens":16384,"temperature":0.0,"timeout":2400,"stream":true}'
# subset_list pinned to ['release_v6']; full set (no --limit). ALWAYS pin temperature, see §5.4.
# stream+timeout matter: 16K-token reasoning loops outlast default client timeouts.

Artifact availability. The model ships as merged, vLLM-ready weights with the LoRA adapter alongside at ZelligeAI/tessera-preview-9b. The compressor, its q8_0 GGUF quantization, and the complete usage harness (driver, segmentation, fidelity gates, token-max rules) are at ZelligeAI/tessera-compressor. Full per-problem records for every full-set condition (all four LCB runs, both IFEval runs, the ablation, all probe JSONL, and the paired archived n=50 runs), the training log, and the stack-validation matrix are preserved in the project archive and available on request.

References

1. ORION: Reasoning in Mentalese via SLPO. arXiv:2511.22891.
2. Chain of Draft: Thinking Faster by Writing Less. arXiv:2502.18600.
3. TokenSkip: Controllable Chain-of-Thought Compression in LLMs. arXiv:2502.12067.
4. Don't Overthink It: Preferring Shorter Thinking Chains. arXiv:2505.17813.
5. Think Deep, Not Just Long. arXiv:2602.13517.
6. Extra-CoT: Extreme Chain-of-Thought Compression. arXiv:2602.08324.
7. OpenThoughts: Data Recipes for Reasoning Models. arXiv:2506.04178, ICLR 2026.