Tessera-27B-B-CJK-RL

Tessera-27B-B-CJK-RL

Runs coding-agent loops with a 27B model that thinks in a compressed English and Chinese shorthand, so it spends fewer thinking tokens per turn. For developers who host a large model themselves.

Made by ZelligeAI on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Tessera-27B-B-CJK-RL started from Qwen3.8-27B and was tuned to act as a coding agent. Its private reasoning is a terse mix of English, Chinese words and symbols, so each agent turn costs fewer thinking tokens than the base model needs. Answers and tool calls stay in plain English and code. It extends the earlier Tessera-27B-B-CJK through eight rounds of RL training that used math and code tasks.

Who it suits: Developers who run coding agents on a model they host themselves, and researchers who study short, compressed reasoning.

Industry | Who uses it | How they use it | Example
Software | Agent builders | Drive a coding-agent loop with a model that thinks briefly each turn | A loop that edits files, runs tests and reports results
AI research | ML researchers | Compare thinking length and accuracy against the base model | Check per-turn thinking tokens on held-out coding tasks
Math and code tools | Tool developers | Use the added math and code training for harder problems | Competition-style math questions

You can skip it if you lack hardware for 55.6 GB of bf16 weights, or if you want a model with its own safety tuning, since this fine-tune adds none.

Where to use it: It targets agent loops that you host yourself, and the card ran it through vLLM.

• vLLM on a machine that holds the 55.6 GB bf16 weights
• The transformers library, which the card used to load the weights
• Other builds from the same maker: a PEFT adapter, GGUF files and an NVFP4 and FP8 checkpoint

Use case | Who | What they get back
Coding-agent loop | Agent developers | Short thinking per turn and plain tool calls
Competition math | Researchers | More correct answers than the earlier Tessera model
Build comparison | ML engineers | A merged model plus adapter and quantized repositories to try

How to set it up: You need Python and enough storage and memory for a 27.8B parameter model, whose bf16 weights are about 55.6 GB.

• Python with pip
• About 55.6 GB of disk space for the bf16 weights, or about 13.9 GB at 4-bit as an estimate
• vLLM, the version the card used being 0.31

1. Install the Hugging Face download tool.
2. Download the merged weights to your computer.
3. Load them with vLLM, as shown in the next section.

pip install -U huggingface_hub
hf download ZelligeAI/Tessera-27B-B-CJK-RL

How to use it: Put it inside an agent loop. Set the reasoning effort to xhigh, set top-k to 20, top-p to 0.95 and temperature to 1.0, and keep earlier thinking out of the message history. The chat template takes low, medium or xhigh as the reasoning effort. The card loaded the weights this way with vLLM.

from vllm import LLM, SamplingParams

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

Tool | What it does
vLLM | Serves the merged bf16 weights, as the card ran them
transformers | Loads the weights, as the card did
reasoning_effort | Takes low, medium or xhigh, and the card advises xhigh for agents

Example: In an agent loop, the model finishes a change and checks its own work. The card shows one such turn, a 45 token think in mixed Chinese and English shorthand. It notes that the test suite matches the baseline with no regressions, then runs lint on the changed files. The base model used 158 tokens at the same state.

For newcomers and experts: A coding agent is a program that lets a model read code, run commands and fix things in a loop. Before each step the model writes private thinking, and this one writes it in a tight shorthand to save tokens. A first small try is to download the weights and load them with the vLLM lines above.

For experts, the weights are a beta: a rank-32 LoRA adapter was baked into the bf16 base model. Reinforcement learning on math and code lifted competition scores against the earlier model, and it kept most of the per-turn thinking saving in agent work. The card says the typical turn used 0.67 times the base model's thinking tokens, a little above the earlier model's 0.60. The trade is accuracy against brevity, and the card measures it on 16 held-out coding-agent tasks.

Agent loop sends a task state to the model
Model thinks in compressed CJK shorthand
Model answers or calls a tool in plain English
Past thinks are dropped from the history
The loop continues with the next state

Good to know: The numbers below come from the card's own runs with fixed seeds, at xhigh effort and 64K tokens of context.

• Beta: The card calls this a beta release, and the quantized GGUF and NVFP4 repositories were not evaluated.
• Tested path: The card ran merged weights from a local copy and did not test loading from the Hub.
• Safety: Training added no extra safety work on top of what the base model had.

Title: Correct attempts out of 126 on competition math
Tessera-27B-B-CJK-RL: 108 correct
Tessera-27B-B-CJK: 97 correct

• License: Apache 2.0.
• Cost to run: none named, the source lists no API key, account or paid service, though the weights need a machine that holds about 55.6 GB.
• Data it reaches: only the prompts and files your own agent loop gives it, and the model files it downloads from Hugging Face.
• Not for: relying on extra safety tuning, since none was added, or on the GGUF and NVFP4 copies, which the card did not evaluate.

On Hugging Face, 13 November 2026

• Task: image text to text
• Library: transformers
• Parameters: 27.8B
• Weights: about 55.6 GB in BF16; about 13.9 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 85
• Likes: 3
• License: apache-2.0
• Languages: en
• Based on: Qwen/Qwen3.8-27B
• Quantized versions: 2
• Tags: transformers, safetensors, qwen3_5, image-text-to-text, agentic, coding-agent, efficient-reasoning, reinforcement-learning, tessera, conversational

Links

• Model: https://huggingface.co/ZelligeAI/Tessera-27B-B-CJK-RL
• Files: https://huggingface.co/ZelligeAI/Tessera-27B-B-CJK-RL/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ZelligeAI/Tessera-27B-B-CJK-RL

Then follow the usage in its model card. Nothing in this kit runs by itself.