Towards Understanding Pause Token Fine-Tuning Dynamics: A Mode Retention Perspective
Organizations: HodooAI Lab, Seoul, South Korea · Seoul National University, Seoul, South Korea
Abstract
Pause-token methods improve LLM reasoning by inserting special tokens into sequences. Prior work explains these gains through computational expressivity. However, there is relatively little investigation into the training dynamics of pause tokens. We explore how pause tokens reshape the training dynamics of fine-tuning. Two controlled pilots expose distinct asymmetries. On a synthetic continual-learning task, masked pauses overwrite a previously-learned distribution roughly 4x less at matched final adaptation (H1, mode retention); on a synthetic math-reasoning probe, the boundary-adjacent token comes to encode substantially more downstream-step information (H2, non-myopic compression). We formalize a training rule consistent with both - Masked Boundary Pause (MBP), pause tokens placed at reasoning-step boundaries with their loss masked. Across 1B-8B Qwen and Llama models, MBP consistently improves reasoning, achieving gains of up to 6 points on math and 2.5 points on code, while preserving general language understanding abilities. We further demonstrate that this mode-preserving strategy extend gains to GRPO. These results recast pause tokens as a training-dynamics intervention on the retention-adaptation trade-off, rather than merely an inference-time computation device.
Figures & tables
| Model | Method | GSM8K | MATH500 | MATH | AMC23 | MINERVA | Avg. |
|---|---|---|---|---|---|---|---|
| Qwen3-1.7B Base | Base | 65.13 | 54.20 | 54.82 | 35.00 | 17.65 | 45.36 |
| SFT | 82.41 | 63.40 | 62.98 | 27.50 | 20.59 | 51.38 | |
| MBP | 83.02 | 61.00 | 64.56 | 37.50 | 23.16 | 53.85 | |
| Qwen3-4B Base | Base | 82.56 | 66.00 | 67.64 | 37.50 | 28.68 | 56.48 |
| SFT | 91.36 | 69.20 | 71.24 | 45.00 | 29.78 | 61.32 | |
| MBP | 90.07 | 73.40 | 72.32 | 50.00 | 30.51 | 63.26 |
| Model | Method | MBPP | MBPP+ | HumanEval | HumanEval+ | Avg. |
|---|---|---|---|---|---|---|
| Qwen3-1.7B Base | Base | 69.05 | 59.26 | 58.54 | 53.05 | 59.98 |
| SFT | 69.58 | 62.43 | 67.07 | 61.59 | 65.17 | |
| MBP | 73.02 | 62.43 | 70.12 | 65.24 | 67.70 | |
| Qwen3-4B Base | Base | 74.34 | 64.81 | 76.83 | 72.56 | 72.14 |
| SFT | 78.04 | 67.99 | 79.27 | 73.78 | 74.77 | |
| MBP | 79.10 | 65.08 | 82.93 | 78.05 | 76.29 |
| Trained Domain | Method | MMLU | GPQA | HellaSwag | BBH | PIQA | Avg. |
|---|---|---|---|---|---|---|---|
| Math | Base | 62.95 | 27.46 | 38.69 | 38.84 | 62.13 | 46.01 |
| SFT | 62.32 | 24.78 | 40.39 | 42.06 | 66.10 | 47.13 | |
| MBP | 63.93 | 27.23 | 48.32 | 44.13 | 67.63 | 50.25 | |
| Code | Base | 62.95 | 29.91 | 38.00 | 38.84 | 62.13 | 46.37 |
| SFT | 60.19 | 23.88 | 36.44 | 39.15 | 60.66 | 44.06 | |
| MBP | 63.78 | 25.67 | 44.01 | 42.88 | 68.01 | 48.87 |
| Method | Math | Avg. | ||||
|---|---|---|---|---|---|---|
| GSM8K | MATH500 | MATH | AMC23 | MINERVA | ||
| Base | 65.13 | 54.20 | 54.82 | 35.00 | 17.65 | 45.36 |
| SFT | 82.41 | 63.40 | 62.98 | 27.50 | 20.59 | 51.38 |
| Append | 79.68 | 59.20 | 60.96 | 30.00 | 22.79 | 50.53 |
| Random | 81.35 | 60.80 | 63.26 | 20.00 | 23.16 | 49.71 |
| DIT | 68.01 | 57.20 | 56.38 | 30.00 | 20.22 | 46.36 |
| Method | GSM8K | MATH | AMC23 | Minerva | AUC |
|---|---|---|---|---|---|
| Qwen3-1.7B-Base | |||||
| Standard | 80.52 | 59.68 | 37.50 | 20.96 | 0.366 |
| MBP | 81.35 | 61.24 | 40.00 | 21.32 | 0.414 |
| Qwen3-4B-Base | |||||
| Standard | 92.19 | 74.30 | 50.00 | 30.15 | 0.505 |
| MBP | 91.58 | 75.26 | 57.50 | 23.90 | 0.550 |
| Metric | Method | GSM8K | MATH | Overall |
|---|---|---|---|---|
| BCP | Standard | 92.08 | 88.33 | 89.18 |
| MBP | 93.36 | 89.09 | 90.00 | |
| NSR | Standard | 63.04 | 33.42 | 38.20 |
| MBP | 66.74 | 36.83 | 41.11 | |
| Acc. | Standard | 81.96 | 63.52 | 67.14 |
| MBP | 84.08 | 65.48 | 68.87 |
| OOD | In-domain | |||
| Model | MMLU | GPQA | GSM8K | MATH |
| Step boundaries | ||||
| Base | 0.707 | 0.607 | 0.500 | 0.579 |
| SFT | 0.403 | 0.380 | 0.278 | 0.339 |
| MBP | 0.463 | 0.440 | 0.365 | 0.380 |
| All tokens | ||||
| Dataset | Base | SFT | MBP |
|---|---|---|---|
| GSM8K | 0.00 | 1.43 | 6.31 |
| MATH | 0.00 | 2.64 | 4.84 |
| DeepMath Eval | 0.00 | 4.67 | 8.29 |
Appendix figures & tables11 assets
Supplementary material from the paper’s appendix.
Appendix
| After | No pause | Pause | Gap |
|---|---|---|---|
| Hyperparameter | SFT on math |
|---|---|
| Learning rate | Qwen: ; Llama3.2: ; Llama3.1: |
| Epochs | 3 |
| Batch size | 32 |
| Optimizer | FusedAdam |
| Scheduler | CosineAnnealingLR |
| Warmup ratio | 0.03 |
| Hyperparameter | SFT on code |
|---|---|
| Learning rate | Qwen3-1.7B-Base: ; Qwen3-4B-Base: ; Qwen3-8B-Base: ; Llama3.1-8B-Instruct: |
| Epochs | 3 |
| Batch size | 32 |
| Optimizer | FusedAdam |
| Scheduler | CosineAnnealingLR |
| Warmup ratio | 0.03 |
| Hyperparameter | GRPO |
|---|---|
| Learning rate | |
| Episodes | 1 |
| Batch size | 128 |
| Rollouts per prompt | 8 |
| Optimizer | FusedAdam |
| Scheduler | CosineAnnealingLR |
| Statistic | Train | Eval | Total |
|---|---|---|---|
| Examples | 83,438 | 4,391 | 87,829 |
| Full SFT tokens | 44.14M | 2.36M | 46.51M |
| Pause tokens | 1.34M | 71.72K | 1.41M |
| Pause-token ratio | 3.02% | 3.03% | 3.03% |
| Pauses/sample | 16.003 | 16.332 | 16.020 |
| Method | Math example |
|---|---|
| MBP | Question. Round each number to the nearest tenth and add the results: 543.55, 25.23, and 299.98. Answer. <|PAUSE|> First, let’s round each number to the nearest tenth: <|PAUSE|> 1. 543.55 rounds to 543.6 (since the hundredths place is 5). <|PAUSE|> 2. 25.23 rounds to 25.2 (since the hundredths place is less than 5). <|PAUSE|> 3. 299.98 rounds to 300.0 (since the hundredths place is 8). <|PAUSE|> Now, let’s add the rounded numbers: <|PAUSE|> 543.6 + 25.2 + 300.0 = 868.8. <|PAUSE|> So, the final answer is . |
| append | Question. Round each number to the nearest tenth and add the results: 543.55, 25.23, and 299.98. <|PAUSE|><|PAUSE|><|PAUSE|> <|PAUSE|><|PAUSE|><|PAUSE|><|PAUSE|> Answer. First, let’s round each number to the nearest tenth: 1. 543.55 rounds to 543.6 (since the hundredths place is 5). 2. 25.23 rounds to 25.2 (since the hundredths place is less than 5). 3. 299.98 rounds to 300.0 (since the hundredths place is 8). Now, let’s add the rounded numbers: 543.6 + 25.2 + 300.0 = 868.8. So, the final answer is . |
| random | Question. Round each number to the nearest tenth and add the results: 543.55, 25.23, and 299.98. Answer. First, let’s round each number to the nearest tenth: 1. 543.55 rounds to 5 <|PAUSE|> 4 <|PAUSE|> 3.6 (since the hundredths place is 5). 2. 25.23 rounds to 25. <|PAUSE|> 2 (since the hundred <|PAUSE|> ths place is less than 5). 3. 299.98 rounds to 3 <|PAUSE|> 00.0 (since the hundredths place is 8). Now, let’s add the rounded numbers: 543.6 + 25.2 + 300.0 = 868.8. So, the final <|PAUSE|> answer is boxed <|PAUSE|> {868.8}. |
| dit | Question. Round each number to the nearest tenth and add the results: 543.55, 25.23, and 299.98. Answer. <|PAUSE|> First, <|PAUSE|> let’s round each number to the nearest tenth: <|PAUSE|> 1. 543.55 rounds to 543.6 (since the hundredths place is 5 <|PAUSE|> ). 2. 25.23 rounds to 25.2 (since the hundredths place is <|PAUSE|> less than 5). 3. 299.98 rounds to 300.0 (since the hundredths place is 8). Now, let’s add the rounded numbers: 543.6 + 25.2 + 300.0 = 868.8. So, the <|PAUSE|> final answer is <|PAUSE|> . |
| Method | Code example |
|---|---|
| MBP | Question. Ninja Atsushi stands guard atop the Ninja Building, which consists of two adjacent buildings of equal height. Each building has a series of walls of varying heights. Atsushi must jump between buildings to patrol the rooftops. Given the heights of the walls for both buildings, determine the minimum height Atsushi must jump for each wall position. Input: two lists of integers, heights_building_1 and heights_building_2 , with the same length. Output: a list of integers where each element is the minimum height Atsushi must jump for each wall position. Constraints: the common list length is between 1 and , and each wall height is between 1 and . Sample input: heights_building_1 = [3, 6, 2] , heights_building_2 = [5, 4, 8] . Sample output: [5, 6, 8] . Answer. <|PAUSE|> def min_jumps(heights_building_1, heights_building_2): <|PAUSE|> Calculate the minimum height Atsushi must jump for each wall position between two buildings. <|PAUSE|> :param heights_building_1: list of integers representing the heights of walls in the first building. <|PAUSE|> :param heights_building_2: list of integers representing the heights of walls in the second building. <|PAUSE|> :return: list of integers representing the minimum jump heights for each wall position. <|PAUSE|> if len(heights_building_1) != len(heights_building_2): <|PAUSE|> raise ValueError("Both buildings must have the same number of walls."). <|PAUSE|> return [ max(heights_building_1[i], heights_building_2[i]) for i in range(len(heights_building_1)) ]. |
| append | Question. Ninja Atsushi stands guard atop the Ninja Building, which consists of two adjacent buildings of equal height. Each building has a series of walls of varying heights. Atsushi must jump between buildings to patrol the rooftops. Given the heights of the walls for both buildings, determine the minimum height Atsushi must jump for each wall position. Input: two lists of integers, heights_building_1 and heights_building_2 , with the same length. Output: a list of integers where each element is the minimum height Atsushi must jump for each wall position. Constraints: the common list length is between 1 and , and each wall height is between 1 and . Sample input: heights_building_1 = [3, 6, 2] , heights_building_2 = [5, 4, 8] . Sample output: [5, 6, 8] . <|PAUSE|><|PAUSE|> <|PAUSE|><|PAUSE|><|PAUSE|><|PAUSE|><|PAUSE|><|PAUSE|> <|PAUSE|><|PAUSE|> Answer. def min_jumps(heights_building_1, heights_building_2): Calculate the minimum height Atsushi must jump for each wall position between two buildings. :param heights_building_1: list of integers representing the heights of walls in the first building. :param heights_building_2: list of integers representing the heights of walls in the second building. :return: list of integers representing the minimum jump heights for each wall position. if len(heights_building_1) != len(heights_building_2): raise ValueError("Both buildings must have the same number of walls."). return [ max(heights_building_1[i], heights_building_2[i]) for i in range(len(heights_building_1)) ]. |
| Method | Code example |
|---|---|
| random | Question. Ninja Atsushi stands guard atop the Ninja Building, which consists of two adjacent buildings of equal height. Each building has a series of walls of varying heights. Atsushi must jump between buildings to patrol the rooftops. Given the heights of the walls for both buildings, determine the minimum height Atsushi must jump for each wall position. Input: two lists of integers, heights_building_1 and heights_building_2 , with the same length. Output: a list of integers where each element is the minimum height Atsushi must jump for each wall position. Constraints: the common list length is between 1 and , and each wall height is between 1 and . Sample input: heights_building_1 = [3, 6, 2] , heights_building_2 = [5, 4, 8] . Sample output: [5, 6, 8] . Answer. def min_jumps(heights_building <|PAUSE|> _1, <|PAUSE|> heights_building_2): Calculate the minimum height Atsushi must jump for each wall position between two buildings. :param heights_building_1: list of integers representing the heights of walls in the first building. <|PAUSE|> :param heights_building_2: list of integers representing the heights of walls in the second building. :return: list of integers representing the minimum jump heights for each wall position <|PAUSE|> . if len <|PAUSE|> (height <|PAUSE|> s_building_1) != len(heights_building_2): raise ValueError("Both buildings must have the same number of walls."). return [ max(heights_building_1[i], heights_building_2 <|PAUSE|> [i <|PAUSE|> ]) for i in range <|PAUSE|> (len(heights_building_1 <|PAUSE|> )) ]. |
| dit | Question. Ninja Atsushi stands guard atop the Ninja Building, which consists of two adjacent buildings of equal height. Each building has a series of walls of varying heights. Atsushi must jump between buildings to patrol the rooftops. Given the heights of the walls for both buildings, determine the minimum height Atsushi must jump for each wall position. Input: two lists of integers, heights_building_1 and heights_building_2 , with the same length. Output: a list of integers where each element is the minimum height Atsushi must jump for each wall position. Constraints: the common list length is between 1 and , and each wall height is between 1 and . Sample input: heights_building_1 = [3, 6, 2] , heights_building_2 = [5, 4, 8] . Sample output: [5, 6, 8] . Answer. <|PAUSE|> def min <|PAUSE|> _jumps( heights_building_1, heights_building_2): Calculate the minimum height Atsushi must jump for each wall position <|PAUSE|> between two buildings. <|PAUSE|> :param heights_building_1: list of integers representing the heights of <|PAUSE|> walls in the first building. :param heights_building_2: list of integers representing the heights of walls in the second building. :return: list of integers representing the minimum <|PAUSE|> jump heights for each wall position. <|PAUSE|> if len(heights_building_1) != len(heights_building_2): raise ValueError("Both buildings must have the same number of walls <|PAUSE|> ."). <|PAUSE|> return [ max(heights_building_1[i], heights_building_2[i]) for i in range(len(heights_building_1)) ]. <|PAUSE|> |
| Method | GSM8K | MATH500 | MATH | AIME24 | AMC23 | MINERVA | MMLU | GPQA | HellaSwag | BBH | PIQA | Average |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Qwen3-1.7B-Base | ||||||||||||
| Base | 65.13 | 54.20 | 54.82 | 0.00 | 35.00 | 17.65 | 62.95 | 27.46 | 38.69 | 38.84 | 62.13 | 41.53 |
| SFT | 82.41 | 63.40 | 62.98 | 0.00 | 27.50 | 20.59 | 62.32 | 24.78 | 40.39 | 42.06 | 66.10 | 44.78 |
| Append | 79.68 | 59.20 | 60.96 | 0.00 | 30.00 | 22.79 | 62.93 | 25.67 | 41.53 | 42.62 | 66.59 | 44.72 |
| Random | 81.35 | 60.80 | 63.26 | 0.00 | 20.00 | 23.16 | 63.64 | 23.66 | 48.73 | 43.96 | 69.64 | 45.29 |
| DIT | 68.01 | 57.20 | 56.38 | 6.67 | 30.00 | 20.22 | 62.90 | 25.67 | 44.75 | 42.66 | 69.31 | 43.98 |
| Method | MBPP | MBPP+ | HumanEval | HumanEval+ | MMLU | GPQA | HellaSwag | BBH | PIQA | Average |
|---|---|---|---|---|---|---|---|---|---|---|
| Qwen3-1.7B-Base | ||||||||||
| Base | 69.05 | 59.26 | 58.54 | 53.05 | 62.95 | 27.46 | 38.69 | 38.84 | 62.13 | 52.22 |
| SFT | 69.58 | 62.43 | 67.07 | 61.59 | 60.19 | 23.88 | 36.44 | 39.15 | 60.66 | 53.44 |
| Append | 69.84 | 60.58 | 70.73 | 65.24 | 61.53 | 27.90 | 36.58 | 40.65 | 64.09 | 55.24 |
| Random | 70.37 | 61.11 | 67.07 | 62.80 | 64.03 | 24.78 | 48.36 | 42.50 | 68.77 | 56.64 |
| DIT | 69.84 | 60.58 | 71.95 | 65.24 | 63.71 | 25.45 | 50.40 | 43.09 | 67.41 | 57.52 |
| Method | GSM8K | M500 | MATH | AIME24 | AMC23 | Minerva | Avg. | AUC |
|---|---|---|---|---|---|---|---|---|
| Qwen3-1.7B-Base | ||||||||
| Standard | 80.52 | 61.20 | 59.68 | 3.33 | 37.50 | 20.96 | 43.87 | 0.366 |
| MBP | 81.35 | 61.80 | 61.24 | 3.33 | 40.00 | 21.32 | 44.84 | 0.414 |
| Qwen3-4B-Base | ||||||||
| Standard | 92.19 | 74.40 | 74.30 | 13.33 | 50.00 | 30.15 | 55.73 | 0.505 |
| MBP | 91.58 | 76.00 | 75.26 | 16.67 | 57.50 | 23.90 | 56.82 | 0.550 |
LLM Fine-Tuning
LLM fine-tuning adapts pretrained large language models to tasks, domains, languages, and behaviors through additional training.
See all 758 papers