Compresschain: Adaptive Reasoning Efficiency

• Compresschain is a reasoning-efficiency paradigm that treats chain-of-thought as a controllable resource, compressing responses for simple tasks and expanding them for complex ones.
• It employs a dual reward mechanism based on online difficulty estimation, dynamically adjusting chain length by comparing group and batch pass ratios.
• Empirical results on math benchmarks show improved accuracy and significant token reduction on hard problems, validating its adaptive approach.

Compresschain is a reasoning-efficiency paradigm in which chain-of-thought length is treated as a controllable computational resource rather than a uniformly penalized cost. In its most explicit current formulation, DeepCompress defines Compresschain as dynamically compressing and extending chain-of-thought to maximize accuracy per token: concise chains are preferred for problems the model already handles reliably, while longer exploratory chains are encouraged on problems it currently finds difficult (Liang et al., 31 Oct 2025). The central claim is that large reasoning models exhibit two complementary inefficiencies—overthinking simple problems and underthinking hard ones—and that a difficulty-aware control law can improve both accuracy and token efficiency, rather than forcing a global shorter-is-better policy.

1. Conceptual basis and motivation

DeepCompress formulates Compresschain around a length–performance dichotomy observed during reinforcement learning. For single-shot evaluation such as pass@1, shorter responses tend to perform better. By contrast, for multi-sample metrics such as pass@k with group sampling used in RL, longer chains provide broader coverage and yield more correct samples within a group. The resulting claim is not that long reasoning is intrinsically better, but that uniform length compression reduces the supply of positive trajectories that contain the “one correct solution in the batch,” especially on difficult items (Liang et al., 31 Oct 2025).

This directly motivates a selective policy. On simple problems, unnecessarily long chains waste tokens and may drift from correct reasoning. On hard problems, premature termination suppresses exploration and can eliminate the trajectories needed for successful learning. Compresschain therefore aims to compress chain-of-thought for simple cases while allowing longer, exploratory chains for hard cases—adaptively and in real time.

A common misconception in this area is that chain compression is equivalent to adding a constant token-length penalty. DeepCompress rejects that assumption. Its argument is that constant penalties shift the trajectory distribution away from longer successful explorations, which degrades RL signal quality and produces systematic accuracy loss on difficult items (Liang et al., 31 Oct 2025).

2. Difficulty-aware reward formulation

The core mechanism is a dual-reward adaptive length controller built on online difficulty estimation. For each question $x$ in a training batch, the model samples $G$ trajectories and computes the per-question group pass ratio

$$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$

It also computes a batch pass ratio $P_b$ and smooths it with an exponential moving average $P_{b,t}$. Difficulty is then defined through the bias

$\beta(x)=P_g(x)-P_{b,t}.$

When $\beta(x)>0$, the item is treated as “Simple”; when $\beta(x)<0$, it is treated as “Hard” (Liang et al., 31 Oct 2025).

Length is normalized within each sampled group. If $|\hat y|$ is the token length of a sampled response and $\mu,\sigma$ are the group mean and standard deviation of response lengths, the standardized length is

$G$0

where $G$1 is a small stabilizer. DeepCompress then defines a sigmoidal shaping reward

$G$2

and scales it as

$G$3

The sign of $G$4 flips the meaning of length. For simple items, shorter-than-group-average chains receive higher rewards; for hard items, longer-than-group-average chains receive higher rewards, but only up to a saturating bonus because of the sigmoid form (Liang et al., 31 Oct 2025).

Accuracy remains the primary signal. The outcome reward is rule-based:

$G$5

To prevent reward hacking, length reward is correctness-conditioned:

$G$6

This means that longer or shorter reasoning is rewarded only when it produces a correct answer. The resulting policy objective is

$G$7

Within this framework, Compresschain is not merely compression; it is a bidirectional control law that compresses under mastery and expands under uncertainty (Liang et al., 31 Oct 2025).

3. Online classification and dynamic control

The online “Simple” versus “Hard” classification rule is formalized as

$G$8

with “Simple” if $G$9 and “Hard” otherwise. Stability is provided by an exponential moving average of the true batch pass ratio:

$$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$0

with $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$1 and $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$2 in experiments. The initialization $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$3 is intended to keep early training optimistic and avoid over-penalizing length while the model is still weak (Liang et al., 31 Oct 2025).

The interpretation of $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$4 has two parts. First, $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$5 controls the mode: compression when positive, exploration when negative. Second, $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$6 controls intensity: items that are much easier than the current average receive stronger compression pressure, while items much harder than average receive a stronger exploration bonus.

This mechanism makes the decision boundary model-relative rather than dataset-static. Difficulty is not defined once for all questions; it is recomputed from the model’s current ability. A plausible implication is that Compresschain behaves like an online curriculum, but with curriculum signals derived from group pass ratios instead of fixed annotations.

4. Training and inference pipeline

DeepCompress is implemented with the Zero RL recipe using DAPO, described as a PPO-style, group-relative policy optimization method (Liang et al., 31 Oct 2025). In each training step, a batch of $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$7 questions is sampled; for each question, $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$8 responses are sampled from the policy with temperature $$P_g(x)=\frac{\text{number of correct samples among }G}{G}.$$9; a rule-based verifier assigns correctness rewards; group pass ratios and the EMA-smoothed batch pass ratio are computed; $P_b$0 is formed; and the final rewards are used to compute DAPO/GRPO-style relative advantages before a clipped PPO update.

The main implementation settings reported for Compresschain with DeepCompress are summarized below.

Component	Setting
Base models	Qwen2.5-3B, Qwen2.5-7B
Group and batch sizes	$P_b$1, $P_b$2
Length reward weight	$P_b$3
EMA smoothing	$P_b$4, $P_b$5
Optimizer settings	$P_b$6, clip ratios $P_b$7
KL coefficient	$P_b$8
Training limits	max prompt length $P_b$9, max response length $P_{b,t}$0, train steps $P_{b,t}$1

The paper also notes several stability heuristics: sufficient within-group length variation is needed; training generations are capped at $P_{b,t}$2 tokens to prevent runaway trajectories; an “overlong buffer” of $P_{b,t}$3 may be used for extremely long outliers; and a small KL term can be reintroduced if drift from SFT becomes undesirable, although the main runs use no KL regularization (Liang et al., 31 Oct 2025).

At inference time, no external verifier is used. The trained policy self-regulates chain length. Evaluations use temperature $P_{b,t}$4, top_p $P_{b,t}$5, and max_tokens $P_{b,t}$6. The resulting behavior is that familiar patterns tend to yield concise chains, while difficult items elicit longer exploratory reasoning without hard decoding constraints (Liang et al., 31 Oct 2025).

5. Empirical performance on mathematical reasoning

DeepCompress is evaluated on seven math datasets: MATH-500, AMC 2023, OlympiadBench, Minerva Math, AIME 2024, AIME 2025, and PolyMath (English). The reported metric is pass@1 accuracy with 16 samples per problem at test time; training generation length is capped at $P_{b,t}$7 tokens, and inference uses max_tokens $P_{b,t}$8 (Liang et al., 31 Oct 2025).

Model comparison	Average accuracy	Average length change
DeepCompress-Zero-3B vs DeepMath-Zero-3B	36.6 vs 34.6	$P_{b,t}$9 tokens
DeepCompress-Zero-7B vs DeepMath-Zero-7B	48.7 vs 46.0	$\beta(x)=P_g(x)-P_{b,t}.$0 tokens

The 3B model improves on MATH-500, OlympiadBench, Minerva, AIME24, AIME25, and PolyMath, with average accuracy increasing from $\beta(x)=P_g(x)-P_{b,t}.$1 to $\beta(x)=P_g(x)-P_{b,t}.$2. The 7B model improves from $\beta(x)=P_g(x)-P_{b,t}.$3 to $\beta(x)=P_g(x)-P_{b,t}.$4, with especially notable gains on hard sets: AIME24 rises from $\beta(x)=P_g(x)-P_{b,t}.$5 to $\beta(x)=P_g(x)-P_{b,t}.$6, and AIME25 rises from $\beta(x)=P_g(x)-P_{b,t}.$7 to $\beta(x)=P_g(x)-P_{b,t}.$8 (Liang et al., 31 Oct 2025).

Efficiency gains are also dataset-specific. On AIME24, the 3B model uses $\beta(x)=P_g(x)-P_{b,t}.$9 tokens with a $\beta(x)>0$0 accuracy-point gain, and the 7B model uses $\beta(x)>0$1 tokens with a $\beta(x)>0$2 gain. This is important because it shows that Compresschain is not trading accuracy for brevity on the hardest sets in the evaluation.

Ablation results further clarify the mechanism. A fixed penalty with $\beta(x)>0$3 produces the shortest chains but lower accuracy. A fixed bonus with $\beta(x)>0$4 produces longer chains and somewhat higher accuracy but poor efficiency. The adaptive rule $\beta(x)>0$5 yields initially high policy entropy, then stabilized entropy with controlled length, and monotonically improving pass@1 during training. On hard sets, DeepCompress also reflects more frequently than baselines but with shorter average length; for the 7B case, reflection frequency is $\beta(x)>0$6 versus $\beta(x)>0$7, average length is $\beta(x)>0$8 versus $\beta(x)>0$9, and pass@1 is $\beta(x)<0$0 versus $\beta(x)<0$1 (Liang et al., 31 Oct 2025).

6. Position within chain-of-thought compression research

DeepCompress is part of a broader CoT-compression literature, but its design differs from both global shortening and offline rewriting methods. R1-Compress, for example, performs chunk-level compression by segmenting long chain-of-thought traces into chunks, sampling multiple compressed candidates per chunk with an LLM, and using inter-chunk search to choose a coherent sequence. On MATH500, it reports $\beta(x)<0$2 accuracy with about $\beta(x)<0$3 token reduction relative to a Long-CoT baseline, with a $\beta(x)<0$4 drop in accuracy (Wang et al., 22 May 2025). That method is chiefly an offline compression and distillation pipeline; DeepCompress instead modifies the RL reward so that chain length is adapted during policy learning.

MACC, or Multiround Adaptive Chain-of-Thought Compression, introduces another distinct approach: progressive multiround refinement with an elasticity-based stopping rule. It reports an average accuracy improvement of $\beta(x)<0$5 percent over state-of-the-art baselines, an average CoT length reduction of $\beta(x)<0$6 tokens, and lower latency, while also using interpretable predictors such as perplexity and compression rate to forecast post-compression performance (Yan et al., 26 Sep 2025). Compared with MACC, Compresschain in DeepCompress is less about iterative post hoc rewriting and more about online difficulty-conditioned control of the reasoning process itself.

CompactPrompt extends compression beyond reasoning traces to full LLM workflows. It combines hard prompt compression, n-gram abbreviation for textual attachments, and quantization for numerical columns, reporting up to roughly $\beta(x)<0$7 token reduction on TAT-QA and FinQA with generally less than $\beta(x)<0$8 accuracy drop when conservatively tuned (Choi et al., 20 Oct 2025). This suggests that Compresschain-style reasoning compression can be interpreted as one layer in a larger stack of token-efficiency mechanisms.

Across these papers, a clear methodological divide emerges. Some methods compress already-produced rationales; some compress prompts and retrieved context; DeepCompress changes the policy so that the model learns when to be short and when to be long. That distinction is central to its claim that accuracy and efficiency can improve simultaneously (Liang et al., 31 Oct 2025).

7. Limitations, misconceptions, and alternate technical usages

DeepCompress identifies several limitations. The method requires within-group length diversity; if all $\beta(x)<0$9 samples have similar lengths, $|\hat y|$0-standardization provides little control. Training caps of $|\hat y|$1 tokens may limit exploration for exceptionally hard tasks. Early in training, $|\hat y|$2 can be noisy, although EMA smoothing and correctness-gated rewards mitigate this. The learned behavior is prompt-sensitive, and the current evidence is centered on math; transfer to code, scientific QA, or multimodal reasoning remains to be validated. The paper also notes an ethical concern: compressing thought on high-stakes problems might hide deliberation, so transparency modes may be needed (Liang et al., 31 Oct 2025).

The most persistent misconception is that Compresschain simply means shorter chain-of-thought. In the DeepCompress formulation, that is incorrect. The operational rule is “compress when confident, explore when uncertain,” not universal truncation (Liang et al., 31 Oct 2025).

The term itself is also polysemous across arXiv. In blockchain systems, “Compresschain” has been used for a Setchain algorithm that compresses local batches before appending them as epochs in a CometBFT-backed ledger (Karmegam et al., 11 Sep 2025). Related blockchain uses include decentralized multimedia compression and immutable storage via Proof-of-WorkStore (Arslan et al., 2019), and state compression of UTXO blockchains through RSA accumulators in CompactChain (Reddy et al., 2022). These usages are technically unrelated to chain-of-thought control, but they share the broader idea of turning a large sequential artifact into a more compact representation.

In the reasoning-model literature, however, Compresschain most precisely denotes adaptive control over the length of reasoning traces. Under that usage, DeepCompress provides the clearest formalization: a dual, difficulty-aware reward that compresses CoT for simple items, extends it for hard items, and empirically improves accuracy per token on mathematical reasoning benchmarks (Liang et al., 31 Oct 2025).