acceptodds
Under review as a conference paper at ICLR 2027

Workflow-Style Instruction Following with Atomic Synthesis and Adaptive RL

Abstract

Complex instruction following is almost always scaled along one axis—more constraints on a single task—yet many instructions are workflows: interdependent sub-tasks under conditional branches, the hardest of which turn on the model's own intermediate output, so the correct route cannot be known before the response is written. Such execution flow is largely absent from existing data, and checklist-style verification does not match it: a checklist is fixed before the response, whereas the path to be checked is not. We propose CASCADE, an iterative synthesis framework that expands a seed instruction into a workflow-style complex instruction by adding exactly one atomic unit per round—a constraint, a sub-task, or a conditional branch. Verification follows the same structure: a check graph models an instruction's execution as a directed acyclic graph, and each response is judged node by node along the path it ought to follow. The same pipeline on held-out seeds yields CascadeEval, a benchmark of such instructions. Because expansion is atomic, synthesis also yields, at no extra cost, a difficulty spectrum for every instruction: the ordered sequence of versions from the seed to the hardest one. We exploit it with SPIRAL, a reinforcement learning (RL) data-selection algorithm that chooses, at each step, which version of each instruction to rollout, keeping training matched to the model's current ability. On Qwen3.5-9B, RL on the hardest CASCADE instructions raises the instruction-following average by +11.00 points over the strongest existing corpus; SPIRAL adds a further +1.88 points over that setting while cutting wall-clock training time by 40%. Our data and code will be made publicly available after peer review.

Primary area:
foundation or frontier models, including LLMs
Keywords:
large language models, data synthesis, instruction following, reinforcement learning with verifiable rewards

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_si3yOpenReview ↗
Rating
3
Confidence
2(+1)
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces CASCADE, which synthesizes complex instructions by incrementally adding constraints, subtasks, and conditional branches, including branches determined by the model’s intermediate output. It co-constructs check graphs for verification and instruction versions for difficulty-adaptive RL through SPIRAL. Experiments cover SFT and RL on three models, seven benchmarks, and a new benchmark, CASCADEEval, evaluated on 48 models.

Critical strengths
  1. CASCADE addresses a meaningful aspect of instruction following: executing dependent subtasks with output-dependent branching. Jointly constructing instructions, verification graphs, and intermediate versions provides a coherent resource for both training and evaluation.

  2. The corpus shows substantial benefits beyond the newly introduced benchmark, supported by both SFT and RL experiments. For example, on Qwen3.5-9B, CASCADE-hard achieves 67.96 on ComplexBench versus 52.30 for the strongest existing-corpus result in that column. SPIRAL also reduces measured training time by approximately 40% relative to hardest-only training.

Critical weaknesses
  1. SPIRAL’s incremental accuracy gains need stronger validation. Improvements over hardest-only training are 0.22, 0.62, and 1.88 IF-Avg points across the three models, but training uses a single random seed. There is also no direct comparison with an established difficulty-aware selection method; removing the offset does not substitute for such a comparison. Consequently, the robustness and distinct benefit of the proposed scheduler remain uncertain.

  2. The complete training pipeline has a substantial reasoning tradeoff. On Qwen3.5-9B, CASCADE-adaptive achieves IF-Avg 54.98 and OOD-Avg 61.73, whereas CASCADE-SFT achieves 54.16 and 73.80, respectively (Tables 1 and 12). Moreover, the cold-start stage reduces OOD-Avg from 77.53 to 52.09. The shared initialization supports the controlled RL comparisons, but improvements over this weakened checkpoint do not establish that the overall recipe preserves reasoning or offers a better tradeoff than SFT.

Questions for authors
  1. Do SPIRAL’s gains persist across training seeds and against an established difficulty-aware selector operating on the same instruction-version pool under matched budgets?

  2. What causes the substantial reasoning degradation during cold start? Is there evidence that SPIRAL improves the instruction-following–reasoning tradeoff when initialized from the original Qwen3.5 model or the CASCADE-SFT checkpoint?

5 comments

We thank the reviewer for highlighting the need for stronger validation of the scheduler and a clearer assessment of the reasoning tradeoff. We added multi-seed runs, adaptive sampling baselines, and RL experiments initialized from CASCADE-SFT, and respond to each concern below; we will incorporate the resulting revisions into the paper and upload a revised version shortly.

W1 / Q1. SPIRAL's gains over hardest-only training (0.22 / 0.62 / 1.88 IF-Avg across the three models) use a single seed, with no comparison to an established difficulty-aware selector. Do the gains persist across seeds and against such a selector under matched budgets?

SPIRAL improves IF-Avg on both tested seeds, and its OOD and length benefits are consistent across them. We repeated Hardest and SPIRAL on Qwen3.5-4B with seeds 0 and 42. SPIRAL improves IF-Avg on both (paired gains +0.41 and +0.62; mean +0.51), improves OOD-Avg by a mean of +3.62, and produces 12.1% shorter responses.

MethodSeedIFEvalIFBenchComplexAdvIFCasEvalIF-AvgIF-LenGPQAAIME26OOD-Avg
Hardest080.3142.1758.1728.2514.8044.74241761.3637.5049.43
Hardest4282.4443.3361.8325.5319.2046.47281460.6137.5049.06
Hardestmean81.3842.7560.0026.8917.0045.61261660.9937.5049.24
SPIRAL079.5740.6759.3027.5918.6445.15232563.8942.7153.30
SPIRAL4282.4443.5061.5725.9222.0047.09227462.1242.7152.42
SPIRALmean81.0142.0960.4426.7620.3246.12230063.0142.7152.86

Against DAPO-style dynamic sampling (Yu et al., 2025) and AdaRFT (Shi et al., 2025), on the same instruction pool and under a matched update budget, SPIRAL has the highest IF-Avg in the new Qwen3.5-9B comparison. Since budgets are matched in optimization updates rather than total rollout compute, DAPO-DS's extra sampling and verification are counted in its runtime. SPIRAL reduces RL training time by 40.3% relative to Hardest and 36.1% relative to DAPO-DS.

Qwen3.5-9B. Δ\Delta is relative to Flatten. Times are wall-clock hours on 16 H200 GPUs. AdaRFT's additional offline annotation costs 16.05 hours.

ConfigurationIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-LenGPQAAIME26OOD-AvgTrain (h)Preproc. (h)
Flatten80.0441.0047.4327.4226.4044.46—62269.9549.1759.5612.890.00
AdaRFT b=0.583.6444.8357.0934.2319.2047.80+3.34101972.4756.8864.677.6716.05
AdaRFT b=0.385.5850.3366.3536.1618.8051.44+6.98257572.9850.0061.498.8316.05
Hardest84.9451.5067.9633.9227.2053.10+8.64264767.9348.1258.0317.440.00
DAPO-DS86.6052.0068.9639.2825.2054.41+9.95274772.7348.1260.4216.300.00
SPIRAL85.6752.6767.7836.7832.0054.98+10.52207870.9652.5061.7310.420.00

The comparison isolates where the scheduler helps. SPIRAL's lead over the established selectors concentrates on the hardest, most branch-heavy data, with the best CasEval at 32.00 (+6.80 over DAPO-DS), while it stays close to them on the rule-style benchmarks. On the accuracy–reasoning balance, AdaRFT (b=0.5b=0.5) is the only run with higher OOD-Avg (64.67) but pays about 7 IF-Avg points for it (47.80 vs. 54.98); no baseline is strong on both axes at once, whereas SPIRAL pairs the best IF-Avg with the second-best OOD-Avg at the lowest training cost of any method that needs no offline annotation.

W2 / Q2. The pipeline shows a reasoning tradeoff: cold start lowers OOD-Avg from 77.53 to 52.09, and CASCADE-SFT reaches higher OOD-Avg than CASCADE-adaptive. What causes the cold-start degradation, and does SPIRAL improve the instruction-following vs. reasoning tradeoff when initialized from the original model or CASCADE-SFT?

Starting RL from CASCADE-SFT improves both instruction following and reasoning. On Qwen3.5-9B, SPIRAL raises IF-Avg from 54.16 to 55.58 (+1.42) and OOD-Avg from 73.80 to 75.55 (+1.75), with 32.4% shorter responses. Compared with Hardest from the same checkpoint, IF-Avg is comparable (+0.05), while OOD-Avg improves by 1.60.

The cold-start degradation reflects the shift toward instruction-following data without dedicated reasoning data. We constructed this checkpoint using queries from all comparison corpora, CASCADE, and general instruction sources, with a common response-generation and rejection-sampling protocol. The SFT experiments evaluate CASCADE as a training corpus; the original RL experiments use this shared initialization to compare training data and scheduling strategies.

Qwen3.5-9B, initialized from CASCADE-SFT. Δ\Delta is relative to the SFT checkpoint; each “+” row denotes an RL continuation.

ConfigurationIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-LenGPQAAIME26OOD-Avg
CASCADE-SFT82.9050.0063.6135.9038.4054.16—322371.9775.6273.80
+ Flatten76.9931.5048.7421.0533.2042.30-11.8688072.2267.2969.75
+ Hardest85.5852.3366.5735.9837.2055.53+1.37229473.7474.1773.95
+ SPIRAL85.1251.1766.3540.8634.4055.58+1.42217972.9878.1275.55

SPIRAL therefore improves both IF and OOD scores over CASCADE-SFT, although OOD-Avg remains 1.98 points below the original model's 77.53.

References. Shi et al. (2025), AdaRFT, arXiv:2504.05520; Yu et al. (2025), DAPO, arXiv:2503.14476.

Reviewer_MnsHOpenReview ↗
Rating
4
Confidence
4
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper targets at a new complex instruction scenario with cascaded constraints and subtasks. It proposes a workflow-style instruction data synthesis pipeline with both instructions and verification rules for evaluation. In. addition, it also experiments with SPIRAL to boost the model’s instruction following capabilities on CASCADE.

Critical strengths
  • The proposed workflow-style complex instruction scenario by CASCADE is novel, where the subtasks and constraints are given step-by-step with DAG representations. Such formulation (e.g., response-relevant/irrelevant) is not well studied in the present studies.
  • The paper addresses the group-contrasted RL optimization bottleneck by SPIRAL which keeps the question fixed but changes difficulty with delta expansion rules. This technique appears reasonable.
  • The paper is generally well written and easy to follow, and the illustration corresponds to the maths representation properly.
Critical weaknesses
  • The complex instruction definition is not clearly presented with highlighted differences with respect to previous methods. For example, in previous work (Lv, Fangrui, et al. "Attend to the Active: Structure-Aware Dynamic Attention in LLMs for Compositional Instruction Following." The Fourteenth International Conference on Learning Representations. 2026. & Wen, Bosi, et al. "Benchmarking complex instruction-following with multiple constraints composition." Advances in Neural Information Processing Systems 37 (2024): 137610-137645.), instruction structures with chaining/branching nodes have been proposed for synthesis/performance improvement.
  • The difficulty-aware curriculum RL has been studied but the paper did not comprehensively compare with previous methods. For example, one simple method would be dynamic sampling that keeps the intra-group information valid (gradients). Another line of research lies in environment tuning which gradually increases the difficulty of tasks either by pre-defined heuristics (maths grade) or reward of model feedbacks. Therefore, the missing of previous methods (especially those difficulty-aware data selection techniques in RL) for comparison and explanations devalues the proposed method.
Questions for authors
  • What’s the key difference between the proposed method with previous complex instruction synthesis method? Are response-dependent sub-tasks (non-deterministic branch) and the corresponding agentic verifiers the most crucial ones?
  • The proposed Eqs. 3~5 in Sec. 2.2 seem to be the calibration between the model ability and the prior definition on difficulties. Can any other kind of techniques be used as proxy?
  • How to ensure that different tasks share a similar comparable tunable difficulty delta constraints/subtasks with consideration of the model’s ability L?
  • From Fig. 5, the moving of c from 0.50 to 0.25 causes different performance variation trends on these benchmarks. What is the general tuning guideline? Can these guidelines generalize across model scales and families?
  • The discussion on the effectiveness of SPIRAL beyond accuracy is missing. It is highly encouraged for the authors to present the changes of model’s response pattern. Especially for the response-dependent (non-deterministic) chaining instructions, it would be better to see how the training shapes the model towards more robust interaction/follow-up turns.
7 comments

We thank the reviewer for the constructive comments and recognition of the workflow formulation and SPIRAL. We respond to each point below, and will incorporate the resulting revisions into the paper and upload a revised version shortly.

W1 / Q1. The definition and its difference from prior work (e.g., ComplexBench; ATA, Lv et al. 2026) are not clearly presented, since chaining/branching structures already exist. What is the key difference, and are response-dependent sub-tasks (non-deterministic branches) and the agentic verifiers the crucial ones?

Yes. The key distinction is that intermediate outputs determine which subtasks to execute and which requirements to verify. We define workflow-style instructions as multiple subtasks and constraints organized into dependent execution flows that may branch. ComplexBench and ATA already study chained and input-conditioned compositions. CASCADE's check graph determines the applicable downstream path from generated intermediate content.

BenchmarkMulti-constraintMulti-subtaskDeterministic branchesNon-deterministic branchesVerification structure
IFEvalYesNoNoNochecklist
IFBenchYesNoNoNochecklist
ComplexBenchYesYesYesNochecklist
AdvancedIFYesYesYesNochecklist
CASCADEEvalYesYesYesYescheck graph

To our knowledge, CASCADEEval is the first instruction-following benchmark to combine explicitly modeled output-dependent workflow branches with response-conditioned check-graph verification. CASCADE constructs each instruction together with a check graph, which follows the branch selected by the model’s intermediate output and checks the requirements on that path.

W2. Difficulty-aware curriculum RL is not comprehensively compared with prior methods (e.g., dynamic sampling that keeps gradients valid; difficulty scheduling by heuristics or model feedback). Missing these comparisons devalues the method.

We added DAPO-style dynamic sampling (Yu et al., 2025), which retains rollout groups with mixed outcomes, and AdaRFT (Shi et al., 2025), which selects samples around an adaptive difficulty target. Both operate on the flattened CASCADE version pool. For AdaRFT, bb denotes its target average reward; we test b=0.5b=0.5 and 0.30.3.

Flatten is the basic baseline: it converts CASCADE’s two-dimensional organization of instructions and difficulty versions into a one-dimensional dataset. Hardest uses only the final version of each instruction.

Qwen3.5-9B. Δ\Delta is relative to Flatten. Times are wall-clock hours on 16 H200 GPUs; preprocessing denotes the additional offline difficulty-annotation pass.

ConfigurationIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-LenGPQAAIME26OOD-AvgTrain (h)Preproc. (h)
Flatten80.0441.0047.4327.4226.4044.46—62269.9549.1759.5612.890.00
AdaRFT b=0.583.6444.8357.0934.2319.2047.80+3.34101972.4756.8864.677.6716.05
AdaRFT b=0.385.5850.3366.3536.1618.8051.44+6.98257572.9850.0061.498.8316.05
Hardest84.9451.5067.9633.9227.2053.10+8.64264767.9348.1258.0317.440.00
DAPO-DS86.6052.0068.9639.2825.2054.41+9.95274772.7348.1260.4216.300.00
SPIRAL85.6752.6767.7836.7832.0054.98+10.52207870.9652.5061.7310.420.00

SPIRAL exceeds DAPO-DS by 0.57 IF-Avg, 6.80 CasEval, and 1.31 OOD-Avg, while reducing training time from 16.30 to 10.42 hours. AdaRFT at b=0.5b=0.5 has higher OOD-Avg (64.67), but lower IF-Avg (47.80). Our AdaRFT implementation additionally requires 16.05 hours of difficulty annotation using 16 Qwen3.6-35B-A3B instances on 16 H200s. Including this one-time annotation cost, a fresh AdaRFT run takes 23.72/24.88 hours versus 10.42 for SPIRAL.

Q2. Eqs. 3–5 calibrate model ability against a difficulty prior. Could other techniques serve as the proxy?

Yes. SPIRAL factorizes into a difficulty prior and an ability feedback signal, and either can be swapped; we deliberately choose the cheapest adequate proxy for each.

  • Difficulty prior (which versions exist and their order). We use the synthesis version index. Its only requirement is a rough monotone ordering per instruction; the SPIRAL (E-IRR) experiment in Q3 shows irregular spacing is fine. Any ordering signal is admissible: an offline difficulty score from a reference model, a constraint/sub-task count, or human difficulty labels. The version index is attractive only because atomic expansion produces it for free.
  • Ability feedback (where the model currently stands). We use the current rollout group's pass rate ρq\rho_q. It is free and online, already a by-product of the GRPO reward and available before any extra generation. Drop-in replacements include a running average of ρq\rho_q over repeated visits to the same instruction, a small learned success predictor conditioned on (instruction, version), or the group reward variance / mean absolute advantage (equivalent to ρq\rho_q under a binary reward).

The two-cursor update of Eqs. 3–5 assumes only that the feedback moves monotonically with the match between version difficulty and model ability; it does not depend on the specific functional form of either proxy. The one design constraint we hold fixed is that both proxies stay free and annotation-less: a learned predictor or an offline difficulty pass would recover finer calibration at the cost of the efficiency that is SPIRAL's main advantage.

Q3. How can different tasks be made to share a comparable, tunable difficulty delta, given the model's ability LL?

Different expansion operations can produce different difficulty increments, and even the same operation can affect different instructions differently. SPIRAL does not require these increments to be equal or precisely quantified. The versions of each instruction give a rough ordering from easier to harder. The shared LL tracks global curriculum progress, while each instruction's offset δq\delta_q adjusts its selected version using the model's observed rollout success rate. Selection therefore adapts to actual performance without requiring a precisely calibrated difficulty scale across tasks.

To stress-test this, we constructed E-IRR (Irregular difficulty spectrum). For each instruction we randomly delete 2–4 intermediate versions, keeping both endpoints (v0v_0 and the hardest version vTv_T) and at least three versions. This preserves each instruction's full difficulty range while thinning the rungs inside it, so adjacent retained versions are now separated by a varying number of atomic expansion steps instead of exactly one (seed fixed; Qwen3.5-9B):

Gap between adjacent retained versions (atomic steps)12345
Share57%27%11%4%1%

In the original spectrum this distribution is 100% at a gap of 1; after E-IRR, 43% of adjacent transitions span more than one atomic step (up to five). This matches the shape of general iterative-augmentation data, where different operations yield very different difficulty increments, so E-IRR directly tests whether SPIRAL needs a uniform, calibrated scale. The algorithm and all hyperparameters are unchanged, and retaining vTv_T keeps the Hardest baseline applicable.

Qwen3.5-9B, c=0.30c=0.30. Δ\Delta is relative to Hardest.

ConfigurationIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-LenGPQAAIME26OOD-Avg
Hardest84.9451.5067.9633.9227.2053.10—264767.9348.1258.03
SPIRAL85.6752.6767.7836.7832.0054.98+1.88207870.9652.5061.73
SPIRAL (E-IRR)86.3251.8367.6138.0527.6054.28+1.18240771.4649.3860.42

On this coarse, irregular spectrum SPIRAL still clearly beats Hardest (+1.18 IF-Avg, +2.39 OOD-Avg) and stays close to its own full-spectrum result (54.28 vs. 54.98 IF-Avg; 60.42 vs. 61.73 OOD-Avg). The small gap to the full spectrum is expected, since removing rungs can only remove information, but it is far smaller than the margin over Hardest. SPIRAL therefore performs well even when the scale is neither fine nor uniform.

ConfigurationAll-pass (ρ=1\rho=1)All-fail (ρ=0\rho=0)Mixed (0<ρ<10<\rho<1)
SPIRAL5.27%16.61%78.13%
SPIRAL (E-IRR)5.14%18.05%76.81%

The coarser spectrum retains a similar proportion of mixed-outcome groups (76.81% vs. 78.13%). These results support that SPIRAL remains effective without precisely calibrated difficulty increments.

Why coarsening costs so little. SPIRAL's cursor reads only the version index and the pass-rate feedback; it never treats a version as a fixed difficulty unit. Thinning the rungs leaves the two things it depends on intact: the difficulty range (both endpoints are kept) and a per-step pass-rate signal that re-anchors L+δqL+\delta_q regardless of spacing (the mixed-outcome share barely moves). The fine spectrum still helps a little, since more rungs give the cursor finer placement, which is why the full spectrum edges out E-IRR. But the effect is small next to the margin over Hardest, so the method remains effective when the scale becomes irregular.

Reviewer_jiUMOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes a new framework called CASCADE for improving workflow-style instruction following capability of LLM. By incrementally expands instructions through atomic operations and constructs corresponding check graphs for graph-based verification, the framework can gradually guide models to learn sequential tasks and conditional branches. Built on that, the paper proposed a new RL algorithm called SPIRAL which dynamically selects instruction difficulty based on the model's current performance. Experiments shows that the proposed method can provide substantial improvements on three Qwen models over existing instruction-following datasets and the new-curated CASCADEEVAL benchmark.

Critical strengths
  1. The paper is well organized and the three algorithms are closely connected with the central idea of atomic instruction expansion and adaptive training sample choosing.
  2. The empirical improvements are substantial, especially the ~11-point improvement of CASCADE-hard over the strongest prior corpus indicates the method is indeed bringing improvements.
Critical weaknesses
  1. In the ablations, the graph-based method versus the end-to-end verification produces only a ~0.3-point difference in IF-Avg for Qwen3.5-4B, which poses question on whether the graph-based method is essential for learning better instruction following capability.
  2. In the Qwen3.5-4B experiment, the IF-Avg performance drops over 7 points when tuning the asymmetric center cc from 0.3 to 0.5, which indicates that the method might be sensitive to hyperparameters tuning. A further sensitive analysis on these parameters could be more informative on how this method could be used in practice.
Questions for authors
  1. Is the check graph essential for learning better instruction following, or is a sufficiently capable end-to-end LLM judge almost as effective?
  2. How would the method performs on different thinking efforts (and possibly different model backbones)?
5 comments

We thank the reviewer for the constructive feedback. We address each concern below with clarifications and additional experiments, and will incorporate the resulting revisions into the paper and upload a revised version shortly.

W1 / Q1. Graph-based and end-to-end verification differ by only ~0.3 IF-Avg on Qwen3.5-4B. Is the check graph essential, or is a capable end-to-end LLM judge almost as effective?

On aggregate IF-Avg this ablation is close, but the check graph buys two things a capable E2E judge does not: resistance to length-related reward hacking under RL, and node-level failure attribution. A human-annotated audit of 100 responses shows the two verifiers agree on accuracy when used only as a one-shot judge (94% graph-based vs. 93% E2E, same Qwen3.6 judge); the difference between them appears under RL, not in judging accuracy.

Because the check graph verifies each applicable requirement separately, reward is assigned at the requirement level rather than from a single end-to-end verdict. When training Qwen3.5-4B on flattened CASCADE with an E2E judge, responses grow substantially longer from around step 10, while the reward stays comparable and even edges up near the end. This is the signature of length-related reward hacking. Graph-based verification instead yields 37.44 IF-Avg at 550 response tokens, versus 37.16 at 899 tokens for E2E: comparable accuracy with no length blow-up. The same per-node decisions let CASCADEEval attribute a failure to a specific requirement or routing error, which a single end-to-end verdict cannot produce. The value of the check graph is therefore not a higher aggregate score but these two properties: it is harder to hack along the length axis under RL, and it is interpretable at the node level.

W2. IF-Avg drops over 7 points when the asymmetric center cc moves from 0.3 to 0.5, suggesting hyperparameter sensitivity; a sensitivity analysis is requested.

The 7.31-point IF-Avg drop is consistent with reduced exposure to difficult tasks at c=0.50c=0.50. Moving from 0.300.30 to 0.500.50 removes the curriculum's deliberate bias toward harder versions. In the Qwen3.5-4B run, c=0.50c=0.50 keeps training at difficulty level 2 from steps 11–26, helping explain its lower IF-Avg (39.78 vs. 47.09).

We recommend c=0.30c=0.30 to balance difficult-task coverage and useful learning feedback. If cc is too large, training stays on easier versions; if it is too small, tasks can become too difficult, weakening the reward signal. On Qwen3.5-4B, decreasing cc further to 0.250.25 lowers IF-Avg from 47.09 to 46.66, supporting an intermediate balance.

To address the sensitivity concern further, we added a six-point sweep on MiniCPM5-2B. IF-Avg stays within 48.49–48.76 for c=0.25c=0.25–0.350.35, showing a useful range rather than a single isolated setting on this model. Although 0.250.25 scores highest, 0.300.30 is only 0.27 IF-Avg / 0.47 OOD-Avg behind and produces 17.7% shorter responses. Together, these results support c=0.30c=0.30 as a practical default across the tested families, balancing learning progress, difficult-task coverage, and response length.

MiniCPM5-2B, thinking. Δ\Delta is relative to CASCADE. All cc configurations use SPIRAL.

ConfigurationIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-LenGPQAAIME26OOD-Avg
CASCADE86.8858.6743.9118.8011.6043.97—164652.5364.7958.66
CASCADE-hard86.6957.6750.0423.2022.4048.00+4.03346351.2670.0060.63
c=0.50c=0.5089.2862.0048.4822.2312.4046.88+2.91141556.0668.7562.41
c=0.45c=0.4585.8659.3350.5721.6613.2046.12+2.15197855.5668.1261.84
c=0.40c=0.4088.9158.8350.1721.7514.8046.89+2.92225753.5473.1263.33
c=0.35c=0.3588.5460.1752.0425.3516.4048.50+4.53300956.5773.5465.06
c=0.30c=0.30 (default)87.9959.6750.9623.4220.4048.49+4.52287557.5875.4266.50
c=0.25c=0.2587.4360.1751.3924.4320.4048.76+4.79349455.8178.1266.97

Q2. How does the method perform across different thinking efforts, and possibly other backbones?

SPIRAL improves over CASCADE-hard with thinking both enabled and disabled, and on a second model family. On Qwen3.5-9B with thinking disabled during both training and evaluation, IF-Avg improves by 1.26 points, with 37.4% shorter responses. With thinking enabled, IF-Avg improves from 53.10 to 54.98 (+1.88). On MiniCPM5-2B in thinking mode, SPIRAL improves IF-Avg/OOD-Avg by 0.49/5.87.

Qwen3.5-9B, non-thinking training and evaluation. Δ\Delta is relative to CASCADE.

DataIFEvalIFBenchComplexAdvIFCasEvalIF-AvgΔIF-Len
CASCADE76.9932.0032.7420.835.2033.55—225
CASCADE-hard79.3932.5048.1324.879.2038.82+5.27778
SPIRAL82.1633.0048.0025.6611.6040.08+6.53487
AuthorsOpenReview ↗

Final Day of the Rebuttal Period: We Would Appreciate Your Feedback

With only one day remaining in the rebuttal period, we would greatly appreciate any feedback on our responses. If you have any remaining concerns, please let us know. We would be happy to provide further clarification. Thank you for your time and consideration!

Comments on the paper

2 comments
AuthorsOpenReview ↗

Summary of Revisions

Revised passages are blue in the PDF, listed in order of appearance; consequential edits (counts, wording, config notes) are folded in. Each heading tags the reviewer concern (W = Weakness, Q = Question) for jiUM, MnsH, si3y.

1. Benchmark comparison table (Introduction, Table 1) · MnsH W1/Q1

A new table contrasts CASCADEEval with IFEval, IFBench, ComplexBench, and AdvancedIF across the constraint, sub-task, branch, and verification axes. Chaining and branching already exist in prior benchmarks, but their conditions are fixed before the response, so none models a non-deterministic branch or uses a response-conditioned check graph — the key difference MnsH asked us to clarify.

2. A fourth base model, MiniCPM5-2B (Table 2) · jiUM Q2

The main RL table gains a MiniCPM5-2B block. CASCADE-adaptive (SPIRAL) has the best IF-Avg and OOD-Avg in the block, so the ordering CASCADE < -hard < -adaptive and the rule-only out-of-distribution collapse both reproduce on a second model family. Setup, headline claims, and the config appendix were updated to four bases.

3. Comparison with difficulty-aware selectors (§3.3 + appendix) · MnsH W2 + si3y W1/Q1

A new subsection compares SPIRAL against DAPO-style dynamic sampling and AdaRFT on the same instructions under a matched update budget. On Qwen3.5-9B, SPIRAL has the best IF-Avg and second-best OOD-Avg, beats DAPO-DS on IF-Avg/CasEval/OOD-Avg while using 36.1% less training time, and is the only strong instruction-following method needing no offline difficulty annotation (AdaRFT needs 16 hours of it). The full breakdown is in the appendix. This answers MnsH W2 (comparison with prior difficulty-aware methods) and si3y W1/Q1 (an established selector under matched budgets).

4. Tuning guideline and cross-family sensitivity of c (§3.4 + appendix) · jiUM W2 + MnsH Q4

The ablation now recommends c = 0.30 (enough hard versions to drive gains, while keeping a usable learning signal) and shows it transfers across families via a six-point c sweep on MiniCPM5-2B (appendix): IF-Avg is far less sensitive to c there, and c = 0.30 is near-best — jiUM W2's sensitivity analysis and MnsH Q4's guideline and cross-scale/family generalization.

5. Alternatives for the difficulty and ability proxies (Appendix C) · MnsH Q2

A new subsection explains that SPIRAL factorizes into a difficulty prior (the version index) and an ability feedback signal (the rollout pass rate), and that either can be swapped for another free, annotation-less signal of the same kind — MnsH Q2's other proxy techniques.

6. Check graph vs. end-to-end judging (Appendix D) · jiUM W1/Q1

A sentence makes the existing ablation's headline explicit: on aggregate accuracy the check graph and a capable end-to-end judge are close, but the check graph buys two things a single verdict cannot — resistance to length-related reward hacking under RL and node-level failure attribution — which is why it is essential (jiUM W1/Q1).

7. Multi-seed robustness (Appendix D) · si3y W1/Q1

A new subsection repeats CASCADE-hard and CASCADE-adaptive on Qwen3.5-4B with seeds 0 and 42. SPIRAL improves IF-Avg on both seeds, improves OOD-Avg, and shortens responses — si3y W1/Q1's single-seed concern.

8. Thinking and non-thinking modes (Appendix D) · jiUM Q2

A new subsection shows that with thinking disabled during training and evaluation on Qwen3.5-9B, SPIRAL still improves IF-Avg over CASCADE-hard with much shorter responses; the gain also holds in thinking mode across bases, including MiniCPM5-2B (jiUM Q2).

9. Robustness to an irregular difficulty spectrum (Appendix D) · MnsH Q3

A new subsection (E-IRR) randomly deletes intermediate versions per instruction, so adjacent retained versions span a varying number of atomic steps. On this coarse spectrum SPIRAL still clearly beats CASCADE-hard and stays close to its full-spectrum result, with the mixed-outcome rollout share almost unchanged — so it needs no precisely calibrated difficulty scale (MnsH Q3).

10. Beyond accuracy: how RL reshapes branch routing (Appendix D) · MnsH Q5

A new subsection evaluates the cold-start checkpoint, CASCADE-hard, and CASCADE-adaptive on the hardest round of CASCADEEval. RL on the spectrum lifts non-deterministic branch-routing accuracy 2.3×; with training fixed, the scheduler's own effect is to solve more instructions fully with shorter responses (MnsH Q5, SPIRAL beyond accuracy on response-dependent chaining).

11. RL initialized from CASCADE-SFT (Appendix D) · si3y W2/Q2

A new subsection starts RL from the CASCADE-SFT checkpoint: SPIRAL raises both IF-Avg and OOD-Avg with shorter responses, and improves OOD-Avg over CASCADE-hard from the same start. It also explains the cold-start OOD degradation (a shift toward instruction-following data without dedicated reasoning data) — si3y W2/Q2.

AuthorsOpenReview ↗

Rebuttal Summary

We thank the reviewers for the constructive discussion. All three reviewers (jiUM, MnsH, si3y) hold a positive assessment and, after the rebuttal, each confirmed they maintain their positive rating. Their closing comments were uniformly positive:

  • jiUM: "the detailed explanation and additional experiment results, which provides a more comprehensive efficacy landscape of the proposed method. I will keep the positive rating."
  • si3y: "I'm glad to see such solid work in the field of instruction following."
  • MnsH: "I keep my positive rating and hope that the explanations above can be added into the manuscript." (now incorporated)

The workflow-style formulation and SPIRAL were explicitly recognized during the reviews, and the discussion focused on strengthening the empirical case rather than on any fundamental concern.

How the concerns were addressed (revised manuscript uploaded, changes in blue; see the "Summary of Revisions" comment for an itemized list):

  • Positioning vs. prior work (MnsH W1/Q1): a new benchmark-comparison table showing the distinguishing features are non-deterministic branches and the response-conditioned check graph.
  • Comparison with difficulty-aware selectors (MnsH W2, si3y W1/Q1): direct comparisons to DAPO-style dynamic sampling and AdaRFT under a matched budget; SPIRAL attains the best IF-Avg with 36.1% less training time and no offline difficulty annotation.
  • Robustness (si3y W1/Q1, MnsH Q3): multi-seed runs and an irregular-spectrum (E-IRR) study confirm the gains and show no calibrated difficulty scale is needed.
  • Generality (jiUM Q2): a fourth base model (MiniCPM5-2B) and thinking/non-thinking runs; the method ordering reproduces across families.
  • Sensitivity and guideline (jiUM W2, MnsH Q4): a cross-family sweep of the center c with a default (c = 0.30), showing the method is not brittle.
  • Design justifications (jiUM W1/Q1, MnsH Q2, MnsH Q5, si3y W2/Q2): what the check graph buys over an end-to-end judge, swappable proxies, branch-routing behavior beyond accuracy, and the cold-start tradeoff including RL from CASCADE-SFT.

We are grateful for the reviewers' careful and constructive engagement, which has made the paper stronger.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.