COrAL: Order-Agnostic Language Modeling for Efficient Iterative Refinement

## Abstract

Abstract Iterative refinement has emerged as an effective paradigm for enhancing the capabilities of large language models (LLMs) on complex tasks. However, existing approaches typically implement iterative refinement at the application or prompting level, relying on autoregressive (AR) modeling. The sequential token generation in AR models can lead to high inference latency.
To overcome these challenges, we propose C ontext-Wise Or der- A gnostic L anguage Modeling (COrAL), which incorporates iterative refinement directly into the LLM architecture while maintaining computational efficiency. Our approach models multiple token dependencies within manageable context windows, enabling the model to perform iterative refinement internally during the generation process. Leveraging the order-agnostic nature of COrAL, we introduce sliding blockwise order-agnostic decoding, which performs multi-token forward prediction and backward reconstruction within context windows. This allows the model to iteratively refine its outputs in parallel in the sliding block, effectively capturing diverse dependencies without the high inference cost of sequential generation.
Empirical evaluations on reasoning tasks demonstrate that COrAL improves performance and inference speed, respectively, achieving absolute accuracy gains of 4.6 % percent 4.6 4.6\% 4.6 % on GSM8K and 4.0 % percent 4.0 4.0\% 4.0 % on LogiQA, along with inference speedups of up to 3.9 × 3.9\times 3.9 × over next-token baselines. Preliminary results on code generation indicate a drop in
pass rates due to inconsistencies in order-agnostic outputs, highlighting the inherent quality–speed trade-off.
Our code is publicly available at https://github.com/YuxiXie/COrAL .

## 1 Introduction

Figure: Figure 1: Scaling of performance and inference cost on GSM8K with increasing the minimum refinement times for each output position. $k$ represents the backward context window size. We set the decoding block size as $b=64$.
Refer to caption: x1.png

Large Language Models (LLMs) have recently achieved remarkable success across a wide range of tasks (Brown et al., ; Touvron et al., ; OpenAI, ; Dubey et al., ), such as mathematical problem-solving, logical reasoning, and programming (Yu et al., ; Pan et al., ; Schick et al., ; Rozière et al., ).
Strategies that enable LLMs to learn from previous mistakes and iteratively refine their outputs have been particularly effective, achieving human-level performance and transforming both academic research and industrial applications (Pan et al., ; Ye et al., ; OpenAI, ).
These iterative refinement approaches incorporate feedback—either external or internal—as supervision signals during training (Zelikman et al., ; Huang et al., ; Shinn et al., ; Lightman et al., ; Xie et al., ), or by developing prompting frameworks that guide the model toward improved generations through methods like guided search or self-refine (Yao et al., ; Xie et al., ; Madaan et al., ).

Despite their effectiveness, these approaches predominantly rely on autoregressive (AR) LLMs, which generate text by predicting the next token in a fixed left-to-right order using causally masked Transformers (Radford, ). This sequential generation process inherently limits the model’s ability to capture dependencies spanning beyond the immediate next token, especially those that require backward context (Hu et al., ). Moreover, the sequential nature of AR models leads to high inference latency, resulting in computational inefficiency for long sequences (Cai et al., ).

Figure: Figure 2: Sliding Blockwise Order-Agnostic Decoding. COrAL performs multi-token prediction and refinement in the sliding block with context window size $k=\!3$ and block size $b\!=\!6$.
Refer to caption: x2.png

To address these limitations, researchers have explored order-agnostic architectures that enhance representation learning and accelerate inference. Previous studies mainly focus on two solutions: permutation-based AR and non-autoregressive (NAR) modeling, but each has its own strengths and limitations.
For instance, permutation-based models propose diversity-enhanced pretraining objectives that predict multiple subsequent tokens in various orders to capture richer dependencies (Yang et al., ; Zhang et al., ).
Similarly, NAR models generate tokens in parallel, significantly reducing inference time (Gu et al., ).
However, conventional NAR models often struggle with tasks involving variable-length generation and complex token dependencies, leading to degraded text quality. As a result, these models are typically task-specific and require additional mechanisms to ensure consistency (Gui et al., ; Shi et al., ).
Inspired by the success of diffusion models in image generation (Austin et al., ), recent efforts have adapted denoising techniques to generative language modeling as an iterative extension of NAR models (Savinov et al., ; Gong et al., ). While these methods improve efficiency, they still lag behind AR models regarding generation quality and generalizability.
Given the trade-offs among different models(^1^11We make conceptual comparison among different model architectures in Appendix A.), a pivotal question arises:

Can we unify the strengths of denoising techniques with order-agnostic modeling to enhance the capabilities of AR-LLMs while mitigating their respective limitations?

In this work, we propose Context-Wise Order-Agnostic Language Modeling (COrAL), which combines the advantages of AR and order-agnostic modeling.
COrAL models token dependencies within manageable context windows, effectively balancing the capture of both local and long-range dependencies with computational efficiency. Through context-wise modeling, COrAL overcomes the limitations of fixed-order generation in AR models and the dependency modeling challenges in NAR models.
Within each context window, COrAL models diverse dependencies in an order-agnostic manner, enhancing the model’s ability to capture complex token relationships while maintaining computational efficiency.
Leveraging COrAL, we introduce Sliding Blockwise Order-Agnostic Decoding, which performs forward multi-token prediction and backward reconstruction simultaneously. As shown in Figure 1, this strategy enables the model to perform iterative refinement internally to scale up inference performance.
Additionally, to ensure that the model remains aware of target token positions without necessitating architectural changes, we apply a generalized Rotary Position Embedding (RoPE) (Su et al., ) to the last layer of the Transformer. This positional encoding technique preserves target-aware representations, which are essential for effective order-agnostic generation and iterative refinement.

We conduct extensive experiments on reasoning tasks, including arithmetic computation and logical reasoning, to evaluate the effectiveness and efficiency of COrAL. Our empirical results show that COrAL not only improves performance but also significantly accelerates inference. Specifically, COrAL achieves absolute accuracy gains of $4.6\%$ on GSM8K and $4.0\%$ on LogiQA, along with inference speedups of up to $3.9$ times over next-token baselines.
These findings demonstrate that COrAL effectively captures dependencies within context windows while maintaining computational efficiency.
However, preliminary experiments on code generation reveal a decrease in pass rates due to inconsistencies in order-agnostic outputs, highlighting the inherent quality–speed trade-offs. This suggests that further refinements are necessary for tasks that require strict syntactic coherence.

## 2 Context-Wise Order-Agnostic Language Modeling

We present Context-Wise Order-Agnostic Language Modeling, a generalized AR framework that captures conditional textual distributions based on various orders in context windows.
We first review order-agnostic autoregressive language modeling and non-autoregressive modeling with iterative refinement as background, before describing COrAL’s objective and architecture.

Figure: Figure 3: Context-Wise Order-Agnostic Language Modeling. We visualize the order-agnostic dependencies within a context window size $k=2$. For target-aware position encoding, we show how COrAL obtains query representations for multiple positions within a context window size $k=2$.
Refer to caption: x3.png

### 2.1 Background

Given a prompt $\bm{x}$ and a target sequence of $T$ tokens $\bm{y}=\{y_{1},y_{2},\cdots,y_{T}\}$, conventional AR models factorize the multivariate distribution $p(\bm{y}\mid\bm{x})$ into a product of univariate distributions using the probability chain rule:

$$ $\vspace{-.065in}\log{p(\bm{y}\mid\bm{x})}=\sum_{t=1}^{T}\log{p(y_{t}\mid\bm{y} _{<t},\bm{x})}$ (1) $$

which requires $T$ iterative sampling steps to generate the sequence. In contrast, order-agnostic AR modeling generalizes this by modeling multiple possible orderings $\sigma\in\mathcal{S}_{T}$ of the sequence:

$$ $\displaystyle\log{p(\bm{y}\mid\bm{x})}$ $\displaystyle=\log{\mathbb{E}_{\sigma\sim\mathcal{S}_{T}}p(\bm{y}\mid\bm{x}, \sigma)}$ (2) $\displaystyle\geq\mathbb{E}_{\sigma\sim\mathcal{S}_{T}}\log{p(\bm{y}\mid\bm{x} ,\sigma)}=\mathbb{E}_{\sigma\sim\mathcal{S}_{T}}\sum_{t=1}^{T}\log{p\left(y_{ \sigma(t)}\mid\bm{y}_{\sigma(<t)},\bm{x}\right)}$ $$

where $\mathcal{S}_{T}$ denotes the set of all possible permutations of the indices $\{1,2,\cdots,T\}$. However, this permutation-based objective poses a significant optimization challenge and can lead to underfitting, as observed in prior works (Yang et al., ; Hoogeboom et al., ).

On the other hand, NAR modeling (Lee et al., ) breaks the sequential dependency to accelerate inference. This approach applies sequence-level denoising steps, enabling parallel reconstruction of multiple tokens with iterative refinement to enhance generation quality. To equip the model with denoising capabilities, it employs $L$ intermediate latent variables $\{\bm{y}^{(1)},\bm{y}^{(2)},\cdots,\bm{y}^{(L)}\}$ and approximates their marginalization as follows:

$$ $\vspace{-.065in}\log{p(\bm{y}\mid\bm{x})}\geq\sum_{t=1}^{T}\log{p(y_{t}\mid\bm {y}^{(L)},\bm{x})}+\sum_{l=1}^{L}\sum_{t=1}^{T}\log{p(y_{t}^{(l)}\mid\bm{y}^{( l-1)},\bm{x})}+\sum_{t=1}^{T}\log{p(y_{t}^{(0)}\mid\bm{x})}$ (3) $$

where the latent variables are constrained to match the type of the target output $\bm{y}$. While previous studies demonstrate the efficiency of NAR modeling in specific tasks such as machine translation (Gu et al., ; Ghazvininejad et al., ; Kasai et al., ), its potential in language modeling remains underexplored. Moreover, the use of corrupted data for denoising and the assumption of token-wise independence in each reconstruction step in NAR models can introduce instability, often resulting in reduced text quality compared to their AR counterparts (Savinov et al., ).

### 2.2 Objective: Context-Wise Order-Agnostic Autoregressive Modeling

To address the above limitations in AR language modeling, we propose Context-Wise Order-Agnostic Language Modeling (COrAL), unifying token-level dependency modeling and sequence-level denoising to advance the capabilities of current LLMs. Previous order-agnostic modeling works attempt to capture various factorization orders involving long dependencies that are difficult to model and fit. In contrast, COrAL learns the orderless relationships within predetermined context windows. Built on the AR foundation, our COrAL framework leverages the superior capability of sequential language modeling in LLMs.

COrAL tackles the problem of generative language modeling by combining forward multi-token prediction with backward denoising in a context-wise and order-agnostic framework. Denoting the context window size as $k$(^2^22Without loss of generality, we can set different context window sizes for forward prediction and backward reconstruction in practice. Here, we present the objective with the same hyperparameter $k$ to avoid clutter.), we model the conditional probability distribution of each target token by considering an ensemble of dependencies over all possible positions in the context:

$$ $\vspace{-.065in}\log{p_{\theta}(\bm{y}\mid\bm{x})}\geq\sum_{t=1}^{T}\mathbb{E} _{i\in[t-k,t+k]}\mathbb{E}_{l\geq 0}\log{p_{\theta}(y_{t}\mid\bm{y}_{\leq i}^{ (l)},\bm{x})}$ (4) $$

where $\bm{y}^{(l)}$ represents an intermediate state of the target output sequence $\bm{y}$ during iterative refinement. The conventional AR modeling, in comparison, becomes a specific case where only the forward prediction with $k\!\!=\!\!1$, conditioned on previous tokens in the target sequence $\bm{y}$, is modeled.

#### Forward Prediction and Backward Reconstruction.

As shown in Figure 3, we decompose the order-agnostic objective into forward prediction and backward reconstruction. In forward prediction, COrAL learns to predict multiple future tokens simultaneously given past tokens in the ground-truth sequence. For backward reconstruction, we
randomly corrupt tokens in the input sequence to create the intermediate states $\bm{y}^{(l)}$ in Eq. 4. Similar to BERT (Devlin et al., ), we compute the loss only on the corrupted tokens. During training, we use the original data for prediction and the corrupted data for reconstruction. This decomposition disentangles the self-refinement capability from forward prediction, leveraging all data points to enhance sequence modeling.

#### Corruption Strategy.

Our corruption and reconstruction process is a form of denoising autoencoding (Vincent et al., ) in language modeling. However, instead of representation learning, we aim to endow the model with the self-refinement capability to revise the generated content. Inspired by masked autoencoders (He et al., ), we divide the output sequence into non-overlapping patches and randomly sample a subset for corruption. Each patch is a fragment of text containing one or multiple consecutive tokens in the sequence. Specifically, we corrupt a patch by either (i) replacing it with a random patch sampled from the current sequence or (ii) repeating the first token to replace the other tokens in the patch. This design draws on insight from Ye et al. () that model performance can be significantly improved by simply enhancing consistency across steps.

### 2.3 Architecture: Target-Aware Query Representation for Self-Attention

We build our framework by adapting the standard architecture of LLMs using decoder-only Transformers (Brown et al., ). Unlike prior NAR works employing encoder–decoder architectures (Lee et al., ; Kasai et al., ), the conventional AR foundation predicts the same distribution given the current context regardless of the target token position. While this demonstrates advanced capabilities of sequence modeling and generation, the typical parameterization of next-token distribution constrains its generalizability to the order-agnostic objective in Eq. 4.

Previous works on order-agnostic modeling have explored various ways to incorporate positional information,
including scaling up the dimensionality of the final projection layer (Stern et al., ) and adding look-ahead tokens (Monea et al., ) or extra decoding heads (Cai et al., ; Gloeckle et al., ). Despite their promising performance, these methods introduce the overhead of additional self-attention network calls and new parameters for multi-position prediction. Instead, we propose a seamless adjustment without adding extra model parameters. Specifically, we apply a generalized Rotary Position Embedding (RoPE) (Su et al., ) at the final layer of the decoder-only Transformers to integrate target-aware information into the query representations.

#### Target-Aware RoPE.

RoPE encodes positional information into query and key representations, ensuring that their inner product inherently contains relative position information in self-attention:

$$ $f(\bm{q}_{m},m)^{\top}f(\bm{k}_{n},n)=g(\bm{q}_{m},\bm{k}_{n},m-n)$ (5) $$

where $f$ is the positional encoding function applied to the query and key embeddings at $m$-th and $n$-th positions, respectively, to produce the product $g$. Conventional RoPE integrates positional information of the current token to form the query representation.
While this effectively enhances the position-aware representation of the input token in intermediate hidden states, it introduces inherent misalignment with the target token position when using the learned representation for output prediction. To avoid this problem, we propose Target-Aware RoPE (Figure 3), which modifies the positional encoding function at the final layer by considering the target token position in the query representation. Denoting $\mu$ as the position index of the target token within the context window to be predicted, we have:

$$ $f(\bm{q}_{m},\mu)^{\top}f(\bm{k}_{n},n)=g(\bm{q}_{m},\bm{k}_{n},\mu-n),\quad \mu\in[m-k,m+k]$ (6) $$

The rationale behind this modification is that the position encoding in RoPE can adapt the representation of the current token to be tailored for the target position. This simple yet effective adjustment endows the model with the target-aware capability, allowing it to predict tokens at various positions without the overhead of additional entire network calls.

## 3 Sliding Blockwise Order-Agnostic Decoding

Leveraging the order-agnostic capabilities of COrAL, we propose Sliding Blockwise Order-Agnostic Decoding, a parallel decoding strategy to enable efficient iterative refinement.

High inference latency significantly hinders the broader application of AR-LLMs. Recent studies have tackled this bottleneck from various angles to accelerate inference. For instance, speculative decoding employs a smaller, faster draft model to propose multiple continuations, which the larger target model then verifies and accepts (Leviathan et al., ; Miao et al., ). Blockwise parallel decoding directly leverages the large model to generate multiple tokens simutaneously (Stern et al., ; Cai et al., ).
However, these studies increase memory consumption, which thus limits the scalability and impedes distributional deployment.
Another promising line of work breaks the sequential dependency by adopting Jacobi decoding (Santilli et al., ; Fu et al., ) for iterative refinement without architectural add-ons. Kou et al. () propose consistency LLMs to further improve the performance of Jacobi decoding inspired by consistency models (Song et al., ).

While these existing approaches improve inference efficiency, they rely on the conventional left-to-right AR foundation with monotonic dependencies. In this work, we leverage the order-agnostic nature of COrAL to perform backward sequence-level refinement and forward multi-token prediction simultaneously, significantly accelerating inference. At each step, we ensemble the output distributions based on multiple possible dependencies and construct a candidate set to fill a block of the output sequence. Furthermore, this process facilitates self-refinement by modifying previous generations at a higher-level horizon, enhancing output quality with advanced inference capabilities. Figure 2 shows that this internal refinement process amends the duplicate “marine” to “organism”, based on both forward and backward dependencies in the generated context. Next, we detail the ensemble strategy in decoding for candidate construction and verification.

Figure: Algorithm 1 Sliding Blockwise Order-Agnostic Decoding

#### Prediction.

Given a set of possible distributions $\left\{p_{\theta}(y_{t}\mid\bm{y}_{\leq i},\bm{x})\right\}_{i=t-k}^{t+k}$ for the $t$-th token in the output sequence, we obtain the ensemble distribution via model arithmetic (Dekoninck et al., ). Specifically, we apply different weights to the distributions to prioritize the more accurate dependencies, with distributions based on more qualified content generally leading to better generations:

$$ $\vspace{-.02in}\pi_{\theta}(y_{t})=\mathrm{softmax}\left(\frac{1}{\sum_{i=t-k} ^{t+k}\omega_{t-i}(\bm{y}_{\leq i},\bm{x})}\sum_{i=t-k}^{t+k}\omega_{t-i}(\bm{ y}_{\leq i},\bm{x})\log p_{\theta}(y_{t}\mid\bm{y}_{\leq i},\bm{x})\right)$ (7) $$

The weight function $\omega_{t-i}(\bm{y}_{\leq i},\bm{x})=\lambda_{t-i}\cdot c(\bm{y}_{\leq i}\mid
\bm{x})$ is determined by the relative distance and direction of the dependency, as well as the confidence of the generated context $\bm{y}_{\leq i}$. Here, the factor $\lambda_{t-i}\in[0,1]$ only depends on the relative position of the target token, decaying for longer dependencies. Using order-agnostic modeling, we calculate the confidence score $c$ by gathering the predicted probabilities based on different dependencies, which we obtain in the verification stage. Generally, backward reconstruction and next-token prediction based on iteratively refined content will be associated with higher weights.
See Section 4.3 for a detailed comparison among different dependencies.
In practice, some of the distributions in Eq. 7 may not be available for all tokens at each step. We calculate the ensemble utilizing available dependencies within the context window.

#### Verification.

Following Cai et al. (), we employ tree attention(^3^33To balance exploitation and exploration in tree construction, we select nodes according to the estimated accuracy of each token. Detailed considerations of candidate selection can be found in Appendix C.) to select from multiple candidates sampled from the ensemble distribution $\pi_{\theta}$. Each candidate is a combination of tokens used to fill the sliding block. Unlike previous works that only adopt the original next-token probability for verification, we also incorporate the backward reconstruction probabilities to leverage the refinement ability of COrAL. The verification score can thereby be formulated as follows:

$$ $\vspace{-.02in}v_{\theta}(y_{t})=\frac{1}{\sum_{i=t-1}^{t+k}\lambda_{t-i}}\sum _{i=t-1}^{t+k}\lambda_{t-i}\log p_{\theta}(y_{t}\mid\bm{y}_{\leq i},\bm{x})$ (8) $$

Here, we only consider the next-token and backward predictions for the verification score calculation. This scheme can be further enhanced by introducing a contrastive objective (Li et al., ) that penalizes the possible failure cases in forward multi-token prediction:

$$ $\vspace{-.02in}v_{\theta}^{\mathrm{CD}}(y_{t})=\max\left(0,\log{p_{\theta}(y_{ t}\mid\bm{y}_{\leq t-1},\bm{x})}-\frac{1}{\sum_{i=t-k}^{t-2}\lambda^{\prime}_{ t-i}}\lambda^{\prime}_{t-i}\log{p_{\theta}(y_{t}\mid\bm{y}_{\leq i},\bm{x})}\right)$ (9) $$

where $\lambda^{\prime}_{t-i}=1/\lambda_{t-i}$ to apply a higher penalty to predictions based on longer dependencies. Combining $v_{\theta}$ with $v_{\theta}^{\mathrm{CD}}$, we keep the candidate of the highest average score. We allow several refinement iterations for each position within a sliding block to enhance the generation quality.
Specifically, we propose an ensemble rejection sampling scheme to determine the sliding step size through majority voting across multiple dependencies, where we accept each token with the probability:

$$ $\vspace{-.02in}c(y_{t}\mid\bm{y}_{\leq t+k},\bm{x})=\frac{1}{k+2}\sum_{i=t-1}^ {t+k}\mathbb{1}_{p_{\theta}(y_{t}\mid\bm{y}_{\leq i},\bm{x})>\min\left( \epsilon,\epsilon\exp\left(-H\left(p_{\theta}(\cdot\mid\bm{y}_{\leq i},\bm{x}) \right)\right)\right)}$ (10) $$

where $H(\cdot)$ is the entropy and $\epsilon$ is a fixed threshold to reject low-probability predictions. This acceptance scheme is inspired by truncation sampling (Hewitt et al., ; Cai et al., ) to choose candidates that are more likely to be sampled from the reference distributions. The sliding step size for each step is set to the length of the longest accepted prefix of the current block. We detail the sliding decoding procedure in Algorithm 1.

## 4 Experiments

In this section, we demonstrate the efficiency and breadth of COrAL regarding the quality–speed trade-offs across arithmetic, logical reasoning, and code generation.

#### Datasets.

For arithmetic reasoning, we train COrAL on MetaMathQA ($395$K) (Yu et al., ) and evaluate it using GSM8K (Cobbe et al., ) on grade school math word problems and MATH (Hendrycks et al., ) of challenging competition mathematics problems. For logical reasoning, we filter LogiCoT (Liu et al., ) with deduplication and reformulation, obtaining $313$K training samples. We assess logical reasoning performance with multiple-choice reading comprehension tasks that test interpretation and decision-making skills: LogiQA (Liu et al., ), based on the Chinese Civil Service Examination, and ReClor (Yu et al., ), sourced from Law School Admission Council exams. For code generation, we train on Magicoder-Eval-Instruct-110K (Wei et al., ) and evaluate using programming tasks from HumanEval (Chen et al., ).

#### Experimental Protocol.

To address the discrepancy between the pre-trained model based on next-token dependency and the target order-agnostic model, we adopt a two-stage training strategy (Kumar et al., ) to progressively enhance order-agnostic modeling. We begin with a domain-specific supervised fine-tuned (SFT) model for each target task. In the first stage, we perform order-agnostic training exclusively on the last target-aware layer, while freezing the other layers to preserve the output quality. In the second stage, following Cai et al. (), we train the entire model by focusing on the previously frozen layers first and then unlocking the last layer to train together. We use Mistral-7B-v0.3
as the base models for reasoning and code generation tasks, respectively. During inference, we explore the effect of the verification stage and ablate the values of decoding context window size and block size. We detail our hyperparameter settings in Section 4.2 and Appendix D.

### 4.1 Main Results

We compare our order-agnostic decoding approach (Section 3) with its next-token counterparts across three tasks. We also show the quality–speed trade-offs in by ablating the decoding settings.

**Table 1: Result comparison of performance (accuracy $\%$) and speed (accepted tokens per second) on arithmetic reasoning tasks. We compare against the conventional autoregressive greedy decoding approach as our next-token prediction baseline (NT). “verifier” and “multi-forward” represent the verification stage and multiple forward token prediction in inference.**
| Approach | GSM8K |  | MATH |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Accu. | Speed | Speedup |  | Accu. | Speed | Speedup |  |
| NT | $74.1$ | $39.7$ | $1.0\times$ |  | $21.8$ | $38.7$ | $1.0\times$ |
| Ours | $75.3$ $\uparrow$$1.2$ | $43.4$ | $1.1\times$ |  | $22.7$ $\uparrow$$0.9$ | $44.4$ | $1.1\times$ |
| Ours ${}_{\textrm{w/o verifier}}$ | $72.4$ $\downarrow$$1.7$ | $156.8$ | $\mathbf{3.9}\times$ |  | $20.0$ $\downarrow$$1.8$ | $139.7$ | $\mathbf{3.6}\times$ |
| Ours ${}_{\textrm{w/o multi-forward}}$ | $\mathbf{78.7}$ $\uparrow$$4.6$ | $14.9$ | $-$ |  | $\mathbf{24.3}$ $\uparrow$$2.5$ | $11.5$ | $-$ |

#### Arithmetic Reasoning.

As shown in Table 1, COrAL enhances the effectiveness and efficiency through different mechanisms in order-agnostic generation.
Using both verification and multiple forward token prediction in decoding, COrAL surpasses the corresponding next-token baseline with comparable inference-time cost.
Furthermore, by trading inference speed with iterative generation and verification through backward refinement, we observe a substantial improvement in accuracy from $74.1$% to $78.7$ and $21.8\%$ to $24.3\%$, on GSM8K and MATH, respectively. When skipping the verification stage for quality control, our approach significantly speeds up the decoding process up to $3.9\times$. This demonstrates the flexibility of COrAL in enhancing both the generation quality and inference speed in mathematical reasoning.

**Table 2: Result comparison of performance and speed on logical reasoning tasks.**
| Approach | LogiQA |  | ReClor |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Accu. | Speed | Speedup |  | Accu. | Speed | Speedup |  |
| NT | $55.1$ | $33.6$ | $1.0\times$ |  | $63.2$ | $33.2$ | $1.0\times$ |
| Ours | $58.2$ $\uparrow$$3.1$ | $62.1$ | $1.8\times$ |  | $62.7$ $\downarrow$$0.5$ | $38.2$ | $1.2\times$ |
| Ours ${}_{\textrm{w/o verifier}}$ | $55.7$ $\uparrow$$0.6$ | $99.1$ | $\mathbf{2.9}\times$ |  | $61.6$ $\downarrow$$1.6$ | $72.0$ | $\mathbf{2.2}\times$ |
| Ours ${}_{\textrm{w/o multi-forward}}$ | $\mathbf{59.1}$ $\uparrow$$4.0$ | $8.9$ | $-$ |  | $\mathbf{64.7}$ $\uparrow$$1.5$ | $11.3$ | $-$ |

Figure: Figure 4: Result comparison of pass rates and speed on code generation.
Refer to caption: x4.png

#### Logical Reasoning.

Table 2 compares the performance and generation speed of model outputs under different decoding settings on logical reasoning tasks. Similarly, COrAL improves the reasoning performance by augmenting next-token prediction exclusively with backward refinement. However, we observe a discrepancy in the performance improvements on LogiQA and ReClor with absolute increases of $4.0\%$ and $1.5\%$ in corresponding accuracies. We attribute this gap to the imbalanced proportions of the two tasks in our SFT data from LogiCoT (Liu et al., ). This also implies the importance of high-quality data selection to boost the effect of order-agnostic training to model different dependencies related to the target tasks.

#### Code Generation.

Results on code generation, however, show an opposite effect of order-agnostic modeling on performance. In Table 5, we observe substantial performance drops across different decoding settings using COrAL. For example, without verification, the pass rate on HumanEval decreases to $6.5\%$ from $64.6\%$ of next-token prediction. This gap remains to be large when applying verification for quality control. Error analysis in Figure 5 indicates that the major cause of this drop comes from the erroneous syntax, where the primary error type, Invalid Syntax, accounts for $70.1\%$ of all samples.
To mitigate this issue, we can turn off the mechanism of forward multi-token prediction and increase the threshold $\epsilon$ in Eq. 10 to reject tokens with low confidence scores. For example, with $\epsilon=0.5$, COrAL achieves a comparable pass rate of $61.6\%$ compared to $64.6\%$ of the baseline. The absolute decrease of $3.0\%$ indicates the deficiency of COrAL in producing incoherent content, showing the importance of specific designs for tasks requiring strict textual formats.

### 4.2 Ablation Studies

In this section, we analyze the core designs of COrAL to enable efficient iterative refinement. We probe the effect of different training and decoding hyperparameters.

Figure: (a) Block size for acceleration.
Refer to caption: x5.png

Figure: (a) Effect of corruption granularity.
Refer to caption: x7.png

Figure: (a) Token-wise loss.
Refer to caption: x9.png

#### Backward Refinement Improves Generation Quality.

Figure 1 shows how the performance and inference cost scale with iterative refinement. Note that even without backward dependencies in prediction, COrAL can still perform backward refinement using the next-token prediction. In this case, we examine the effect of backward dependencies with different context window sizes. Notably, the performance of iterative refinement scales faster than the inference cost as the iteration time increases. Furthermore, leveraging backward dependencies, COrAL reaches a higher plateau of performance compared to refining with forward dependencies only. However, the fast saturation of performance improvement with larger refinement times indicates a relatively low upper bound of the enhancement brought by backward reconstruction. We extensively discuss this problem attributed to the discrepancy between pre-training and fine-tuning objectives in Appendix E.

#### Quality–Speed Trade-off in Inference.

In Section 4.1, we demonstrate the quality–speed trade-off by ablating the employment of verification and forward multi-token prediction. We now provide a detailed analysis of the decoding hyperparameters to show this trade-off. We consider the block size $b$ and the forward context window size $k$, two variables closely related to the inference speed and quality. For block size, we probe its effect in reducing inference time in the verification-free case to maximize the speedup rate. Figure 6(a) shows that we can push the speedup boundary toward the corresponding upper bound of $k$ with large $b$. For example, given $k\!=\!4$, we approach the maximum speedup rate $4\times$ with large block sizes such as $b\!=\!64$ and $128$. Notably, leveraging the backward refinement capability of COrAL, this block size-driven acceleration process retains the generation quality at the same level, illustrating the balance of efficiency and effectiveness of our acceleration mechanism.
For forward context window size, we adopt the two-stage prediction–verification setting to explore the quality improvement boundary of the iterative refinement mechanism. Figure 6(b) shows trends of performance drop and inference speedup when increasing $k$. We explain this trade-off as a reflection of the decreasing precision in predicting future tokens of longer dependencies. We conduct further analysis on the modeling ability for different dependencies in Section 4.3.

#### Learning from Corruption Enhances Refinement Capability.

One core design in COrAL is the denoising process to enable iterative refinement, where the corruption strategy is crucial for controlling data quality and model performance. In Figure 7, we analyze the variation in performance improvements from backward refinement (w/ multi-forward) when applying corruption with different granularity or ratios. Given a backward context window size $k=8$, we observe a more significant improvement when applying corruption on longer pieces of text. For example, COrAL achieves an absolute increase of $4.6\%$ with granularity $4$, compared to $1.7\%$ under token-level corruption. However, as the corrupted context gets longer, the model’s capability to learn from mistakes may also degrade. One possible reason for this performance drop is the difficulty and inconsistency in simultaneous multi-token regeneration, as reconstructing more tokens brings higher uncertainty and noise. This indicates the importance of using a reasonable corruption granularity to obtain data of good quality and maintain training stability.
Likewise, we see a similar trend when the corruption ratio varies. Specifically, a high corruption ratio such as $0.5$ can damage the semantic meaning of the context, leading to a performance drop in both our and baseline approaches. Nevertheless, we can still benefit when increasing the corruption ratio within a reasonably lower range, such as $0.125$ to $0.25$, to enhance the reconstruction process.

### 4.3 Further Analysis

We analyze COrAL’s capability to model different dependencies, and the potential computation overhead from order-agnostic modeling.

#### How does COrAL model order-agnostic dependencies?

We compare the model capabilities across different positions using token-wise losses and accuracies in Figure 8. Generally, COrAL performs better on backward reconstruction than forward prediction, as shown in the lower losses and higher accuracies on backward dependencies. Notably, we see better generalizability of backward reconstruction. For example, given the backward context window size $k=8$ and forward context window size $k=4$, we find that the loss and accuracy of backward reconstruction with dependencies longer than the training context window size, such as positions $|\!-\!9|\!>\!|\!-\!8|$, are also at the same level as other backward dependencies. Differently, we observe a dramatic increase in loss and a drop in accuracy from positions $4$ to $5$ on longer dependencies in forward prediction. This explains how backward refinement benefits from more information in sequence-level generation to improve performance. We observe decreased performance for forward prediction as the dependency gets longer, especially when it exceeds the forward context window size in training. However, we can mitigate this issue by aggregating multiple predictions for each position. As shown in Figure 8(b), while forward positions with longer dependencies obtain lower accuracies on tghe first prediction, the accumulated accuracies of their non-first predictions are generally higher than those from other dependencies. This illustrates how COrAL can benefit from the tree construction and verification stage in decoding (Section 3) by considering multiple candidates for each position.

#### Computation Overhead.

One concern regarding order-agnostic modeling is the potential computation overhead to accommodate more dependencies in the context windows. As target-aware RoPE is only applied on the last layer, this overhead scales relatively slower as we increase the number of positions to predict. For example, with forward and backward context window sizes each set as $k=4$, each forward pass of COrAL costs $5.48$ TFLOPS, compared with $2.81$ TFLOPS of next-token prediction. In other words, COrAL predicts $8\times$ number of tokens with less than $2\times$ overhead in computational cost. This indicates the efficiency of COrAL in leveraging available computation resources to accelerate and enhance inference. Furthermore, we can adjust the forward and backward context window sizes to determine the number of tokens to predict in parallel, demonstrating the flexibility and generalizability of COrAL with target-aware RoPE.

#### Effect of Two-Stage Training.

As discussed in Section 4.2, a high corruption ratio can cause a collapse in model performance as the noisy data contains corrupted information in a format that the model has not seen in pretraining. Furthermore, we are also faced with the order-agnostic training tax to endow an AR-based LLM with denoising and multi-token prediction abilities. In this section, we elaborate on the two-stage training we designed to mitigate this issue. Following Cai et al. (), we first tune the last layer where we apply target-aware RoPE. This adapts the previous parameterization on next-token prediction to target-aware multi-position prediction. Due to the discrepancy of training objectives in pretraining and fine-tuning, full fine-tuning is still essential to ensure better performance on multi-token prediction. To stabilize the training process, we then freeze the last layer and gradually unlock it through the second training stage of full fine-tuning. Empirically, we find this strategy effective for stabilizing the autoregressive loss changes in forward prediction. However, we observe an order-agnostic training tax where the next-token prediction performance drops from $77.0\%$ to $76.5\%$ and then $74.1\%$ after the first and second stages, respectively. This performance degradation possibly comes from two aspects: the difference in training objectives and the incorporation of corrupted data in fine-tuning. We leave it to future work to further explore the effect of applying our order-agnostic framework to the pretraining stage.

## 5 Discussion and Conclusion

By unifying denoising with context-wise order-agnostic language modeling and introducing target-aware positional encoding, COrAL incorporates iterative refinement directly into the language generation process while keeping inference costs low. This approach offers a promising direction for developing more efficient and capable large language models by effectively capturing local dependencies within context windows and reducing inference latency.

The effectiveness and efficiency of COrAL underscores the promise of order-agnostic strategies as a generalized architecture to facilitate generative language modeling and text generation. Specifically, it suggests new opportunities to unify: (i) the sequence modeling and varying-length generation abilities of autoregressive modeling, (ii) the multi-dependency modeling and multi-token prediction mechanisms in order-agnostic modeling, and (iii) the efficient way of iterative refinement in denoising techniques. We hope our work will motivate future research to explore order-agnostic modeling and denoising in various tasks and other domains beyond sequence modeling.

## Limitations

This work proposes an approach to integrate iterative denoising with order-agnostic language modeling to enhance both the effectiveness and efficiency of LLM inference. While it offers a promising paradigm for mitigating issues related to monotonic dependencies and inference latency in conventional autoregressive models, several directions remain for further exploration, including designing corruption and decoding strategies to tailor the model to specific tasks, optimizing the training process to overcome the order-agnostic training tax, and probing the generalizability and scalability of COrAL across different context sizes, model scales, and tasks.

Specifically, order-agnostic language modeling can struggle with tasks that demand specific output formats or syntax due to inconsistencies in the multi-token predictions. This indicates the importance of a task-specific design of the acceptance scheme in order-agnostic decoding. For instance, the performance of the verification policy in Eq. 8 may vary by language and domain. Additionally, applying semantic-aware weights to different dependencies could further enhance task-specific features in the generated outputs. Future work can further explore the potential of incorporating different evaluation heuristics to guide the inference process.

Furthermore, incorporating corrupted data may introduce discrepancies between training- and inference-time objectives. For example, our experiments explore rule-based context-wise corruption strategies to create noisy data. Future work could focus on diversifying the types of corruption and scaling the difficulty level and proportion to better understand their impacts on model capabilities.

Finally, due to the computation constraint, we explore the model capabilities in order-agnostic modeling with fixed context window sizes during the SFT stage only. Future work may investigate the effect of scaling context window sizes in both forward and backward directions. Moreover, increasing the context window sizes may exacerbate the discrepancy between autoregressive pre-training and order-agnostic fine-tuning. We thus anticipate future work to extend COrAL to the pre-training stage to further enhance model capabilities.

## Potential Broader Impact

Compared to conventional autoregressive modeling, COrAL leverages multi-token prediction and reconstruction to backtrack and iteratively refine past generations. This strategy mirrors the human decision-making process in real-world task completion. We anticipate COrAL to inspire the community to design more efficient and effective frameworks to enhance interpretability and alignment with the reasoning and planning process of humans.

## Appendix A Conceptual Comparison among Model Architectures

We consider the properties an ideal architecture should have as follows:

- •
VL: varying-length generation
- •
BT: backtrack / look-ahead
- •
MV: multi-variable generation
- •
MD: multi-dependency (inter-sample connection) modeling
- •
FS: fitting feasibility
- •
EF: inference efficiency
- •
IT: mechanism of iterative refinement

**Table 3: Conceptual comparison regarding desired features across different architectures.**
| Architectures | VL | BT | MV | MD | FS | EF | IT |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Next-Token AR (Uria et al., ) | ✓ | ✗ | ✗ | ✗ | ✓ | ✗ | ✗ |
| Permutation-Based AR (Uria et al., ) | ✗ | ✓ | ✓ | ✓ | ✗ | ✓ | ✗ |
| NAR (Gu et al., ) | ✗ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Diffusion (Ho et al., ) | ✗ | ✓ | ✓ | ✓ | ✓ | ✗ | ✓ |
| Consistency Model (Song et al., ) | ✗ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| COrAL (Ours) | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

## Appendix B Further Related Work

#### Order-Agnostic Language Modeling.

Order-agnostic architectures have been explored to overcome the limitations of sequential generation in autoregressive models. Uria et al. () propose permutation-based autoregressive models to learn different data orderings for density estimation. In language modeling, Yang et al. () further explore the idea of order-agnostic autoregressive modeling as a generalized pretraining method. Welleck et al. () explore the possibility of non-monotonic text generation in a tree-structure manner and achieve competitive performance with the conventional left-to-right sequential generation. To avoid the high latency in autoregressive decoding, Gu et al. () introduce non-autoregressive machine translation by breaking the sequentially causal dependency across time into conditionally independent per-step distributions with latent variables as intermediate steps. Lee et al. () adopt iterative refinement to interpret the latent variable model, inspired by the design of denoising autoencoders (Alain & Bengio, ). Follow-up works on non-autoregressive machine translation show promising performance of the iterative refinement process of mask-predict (Ghazvininejad et al., ; Kasai et al., ). Our work explores the potential of unifying the strengths of order-agnostic modeling and denoising to advance sequential modeling in LLMs, demonstrating an efficient way to conduct iterative refinement internally.

#### LLM Self-Refinement.

Self-refinement in LLMs focuses on various feedback mechanisms to improve the model performance dynamically. Existing works utilize the feedback mainly in two directions. The first one relates to prompting-based frameworks such as instance-level refinement (Madaan et al., ), step-level guided search (Yao et al., ; Xie et al., ), and principle-driven reasoning (Zheng et al., ). Another line of work adapts the feedback as training signals to further enhance the performance of LLMs, including rationale-augmented refinement (Zelikman et al., ), hindsight-driven alignment (Zhang et al., ; ), and search-enhanced preference learning (Xie et al., ). Unlike existing works relying on the AR foundation in conventional LLMs, we leverage the order-agnostic modeling ability of COrAL to conduct the iterative refinement internally while foregoing the computation overhead in AR-LLMs to maintain efficiency.

#### Parallel Decoding.

Parallel decoding methods aim to accelerate LLM inference by generating multiple tokens simultaneously rather than sequentially. Non-autoregressive models (Gu et al., ) and blockwise decoding approaches (Stern et al., ; Monea et al., ; Cai et al., ) have enabled faster generation but often struggle with output inconsistencies. Speculative decoding techniques (Leviathan et al., ; Chen et al., ; Miao et al., ) adopts a faster draft model to speedup inference while struggling with the deficiency in scalability. Look-ahead (Santilli et al., ) and Jacobi (Fu et al., ) decoding, on the other hand, directly utilize the AR LLMs to enhance performance iteratively. Consistency LLMs (Kou et al., ) further reduces this iteration time drawing inspiration from consistency models (Song et al., ; Song & Dhariwal, ). In this work, we realize parallel decoding leveraging the multi-token generation ability of COrAL. Instead of decoding toward the forward direction only, we support backward refinement simultaneously to enhance the generation quality further.

## Appendix C Candidate Tree Construction in Order-Agnostic Decoding

Our specific design of tree construction aims to explore promising combinations of multi-position predictions with a fixed budget for the number of total nodes in the tree. Unlike selecting promising nodes based on the accuracies of the top predictions of different heads in Cai et al. (), we forego the need of a validation set for accuracy calculation by leveraging the model confidence of each prediction with a dedicated scaling factor. Let $p_{t}^{(i)}$ denote the model-predicted probability of the $i$-th top candidate for the $t$-th token. For a candidate sequence composed by the top $[i_{t_{s}},i_{t_{s}+1},\cdots,i_{t_{e}}]$ predictions of tokens at different positions, we estimate its accuracy as:

$$ $\prod_{j=t_{s}}^{t_{e}}\left(p_{j}^{(i_{j})}/\gamma_{j}\right)$ (11) $$

where $\gamma_{i}$ is a scaling factor to up weight the predictions based on nonconsecutive forward dependencies. As shown in Figure 8, this process benefits from the fact that COrAL obtains higher accuracies on non-first predictions on such dependencies. Empirically, we set these factors to be $1.1$, $1.2$, $1.3$ for the second, the third, and the fourth tokens to predict, respectively.

Following Eq. 11, we construct the tree in a greedy manner, adding the node with the highest confidence to the tree one by one. This process considers the token-wise confidence as the expected contribution of each prediction to the tree. We repeat the node-adding process until the total number of nodes reaches the desired number to accommodate the maximum sequence length the model can deal with.

## Appendix D Hyperparameter Setting

#### Training.

For order-agnostic training, we train for $3$ epochs at each stage with a batch size of $128$ on all tasks. We fix the context window size in training as $4$ and $8$ for forward and backward dependencies. At different training stages, we recommend employing different learning rates. We set the learning rate as $5\mathrm{e}{-6}$ and $1\mathrm{e}{-4}$ in reasoning and code generation, respectively, for the last-layer tuning stage. We increase the learning rates at the second stage to be $1\mathrm{e}{-6}$ and $2\mathrm{e}{-5}$ for corresponding tasks following the general SFT settings.

We corrupt the training data with granularity $4$ and ratio $0.25$ across all tasks for backward reconstruction. As discussed in Section 4.2, we ablate the granularity and ratios on mathematical reasoning data to study their respective effects on enhancing model’s refinement abilities. Note that as the training context window sizes are fixed as $4$ and $8$ for forward and backward dependencies, the optimal corruption hyperparameters may vary as we scale the context window sizes. Due to the computation constraint, we leave it to future work to explore the combinations of different granularities and corruption strategies.

#### Decoding.

For order-agnostic decoding, we suggest adopting different context window sizes and block sizes to balance the quality and inference speed in different tasks. We report the experiment results (Section 4.1) under the same context window and block sizes across the three tasks, where the forward and backward context window and block sizes are $4$, $8$, and $64$, respectively. For verification, we set $\epsilon=0.2$ and $0.5$ for reasoning and code generation. We implemented our order-agnostic decoding and corresponding next-token baseline without KV-Cache (Pope et al., ). During decoding, we set the batch size $1$ and conduct inference on a single GPU.

#### Computation.

For reasoning tasks with maximum sequence length $512$, all training experiments were done on single-node eight $40$GB A100s. For code generation task with maximum sequence length $2048$, we conduct training and inference on single-node four $80$GB H100s.

## Appendix E Qualitative Analysis

Figure: Figure 9: Qualitative result comparison on GSM8K.
Refer to caption: x11.png

Figure: Figure 10: Qualitative result comparison on LogiQA.
Refer to caption: x12.png

Our qualitative analysis on GSM8K and LogiQA showcases how COrAL corrects previously generated mistakes through the iterative internal process. In Figure 9, COrAL obtained a wrong calculated result $72$ at the $48$-th step. However, the backward refinement mechanism enables it to backtrack and refine the result to the correct number, $74$, as shown at the $49$-th step. In contrast, the next-token baseline cannot correct the erroneous $72$, leading to the wrong final result. On the other hand, we observe the incoherence in COrAL’s generation where COrAL can fail in correcting the mistakes when it happens to skip some positions during generation. For example, at the $1$-st step, COrAL outputs “bakeraked” instead of “baker baked”. This error incurs a chain reaction where the subsequent outputs all omit the correct token “ b” right after “baker”, indicating the need for further enhancement on the generation fluency of order-agnostic methods.

On LogiQA, interestingly, we observe a higher frequency of the inconsistencies in COrAL’s generation. As discussed in Section 4.1, we attribute this scenario to the relatively low proportion of LogiQA-related training data in LogiCoT, where there are only $5$K samples out of the $313$K data points. As shown in Figure 10, while the COrAL produces several grammatical errors in a generation, it still achieves the correct result. This indicates the advanced ability of COrAL to sematically escape from paths that may lead to dead ends through iterative refinement.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: - If the way to generate tokens in the first step is different from that in the process of iterative refinements? Are there any better methods to generate draft tokens.
soundness: 2
strengths: - This paper is well-writen and easy to follow. 
- The performance on logical reasoning tasks are good.
summary: This paper proposes Context-Wise Order-Agnostic Language Modeling (COrAL), which incorporates iterative refinement directly into the LLM architecture while maintaining computational efficiency. Empirical evaluations on reasoning tasks demonstrate that COrAL improves performance and inference speed, and results on code generation indicate a drop in pass rates due to inconsistencies in order-agnostic outputs, highlighting the inherent quality–speed trade-off.
weaknesses: - I think this paper is similar to the other type of works, i.e., speculative decoding, what the difference between them? 
- The noverty is limited, since the specific ways for iterative refinements, the training methods to learn correction, are borrowed from previous works. 
- The significant one: this method seems to only work in specific tasks, the logical reasoning tasks in this paper. However, we always focus on the generalization of current language models, i.e., the competitive on a wide range of tasks.

---

confidence: 5
contribution: 2
initial_rating: 6
presentation: 4
questions: The clarity of the paper is good, it's easy for people to follow generally. I don't have further questions.
soundness: 4
strengths: - Improved Efficiency and Performance:  COrAL’s order-agnostic framework allows simultaneous forward and backward processing, significantly reducing inference latency compared to traditional autoregressive models. Compared to the ablated baselines, empirical results on datasets like GSM8K and LogiQA demonstrate notable accuracy gains, confirming the model’s effectiveness in complex reasoning tasks.
- Scalably Adaptable from Existing Models: By using context-wise modeling and target-aware positional encoding, COrAL manages to enhance dependency capture without substantially increasing computational resources, making it feasible for deployment in large-scale applications, even with existing large language models with only minor adaptation.
summary: The paper proposes COrAL(Context-Wise Order-Agnostic Language Modeling), a novel architecture for language modeling that enhances efficiency in iterative refinement, aiming to reduce inference latency in large language models (LLMs). Traditional autoregressive models, which generate text sequentially, struggle with efficiency due to the natural linear time complexity in inference. COrAL incorporates iterative refinement directly into the model, allowing multi-token generation and backward reconstruction within manageable context windows. This order-agnostic approach enables simultaneous forward and backward decoding within sliding context windows, effectively accelerating inference and improving performance on reasoning tasks. Empirical tests show significant improvements in both accuracy and inference speed, demonstrating COrAL's promise in capturing diverse token dependencies without the high latency typical of AR models. However, challenges remain, such as reduced performance in code generation due to output consistency issues, indicating areas for further refinement.
weaknesses: - Lack of survey of some (maybe kind of obsolete yet important) existing methods: This method resembles Scheduled Sampling in multiple aspects, yet it severely lacks the acknowledgement of this method (no citation nor even mentioning). It shares many ideas and practices with SS, necessitating a deeper analysis on the connection and differences between the method. For example, I'd recommend the authors to emphasize the capability of the proposed method on semi-parallel, refinitive generation, whereas SS was originally only proposed for improvements of performance in sequential generation. 
- Lack of deeper discussion on the theoretical insights: I appreciate the authors' awesome work in presenting and delivering the empirical results, but I presume it would appeal the community more if some insightful conclusions can be presented alongside the experiment observations.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: It would be really interesting to check how much performance is lost by starting from a pretrained model as compared to full training a method employing coral from scratch. Do you think that some performance is left on the table because you start from a pretrained model? 

In the main result part, to increase my rating I would like to see a comparison to other interative refinement methods that have a similar computational cost as the w/o multi-token prediction variant of the proposed method and also a more detailed description of the autoregressive baseline.

Suggestion: Maybe it would be a good idea to incorporate an application in which this method shines. E.g., by looking into domains that can benefit from the order-agnostic aspect such as protein language modelling.
soundness: 3
strengths: * the authors propose an interesting paradigm and show that it has promise for reducing computational cost and enhancing performance in certain settings
* the method is applicable to autoregressive pretrained language models and seems to improve their performance in certain settings
* the authors provide a quite extensive ablation study for their method
* the paper contains some beautiful figures such as figure (2) and (3). Even though Figure (2) is a little bit unclear to me. Why are there seemingly different offsets for the refinements and why is there not much visual seperation inbetween forward prediction and refinement?
summary: The authors introduce a novel decoding strategy combining autoregressive modelling with ROBERTA-like order agnostic refinement. Given a partial sequence, they predict multiple tokens ahead, which they subsequently refine using ROBERTA-like denoising autoencoder. The authors see performance improvements on GSM8K and LogiQA and poor performance on code generation.
weaknesses: * pseudo-code for Algorithm 1 is provided without walking through the pseudo-code
* in the experimental section the baselines are not described in enough detail, just AR. the proposed method requires finetuning, are the AR baselines also finetuned on the tasks?
* the by-far-best performance is achieved using the w\o multi-head prediction ablation, which is not the proposed method and thus weird. I assume this variant suffers from increased computational cost compared to the proposed method. It would be interesting to compare this ablation with a method from the related work that has a similar computational cost.
* comparison to refinement methods from the related work is missing
* a somewhat non-standard notation for expected values is used. their subscripts seem to be used much like in summations, but usually subscripts at an expected value are used to indicate over which distribution the expectation is taken: e.g., equation (1) and equation (3)

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: In eq.8 entropy is always positive, so -H(x) is always negative and exp(-H(x)) is always less than 1. So min(a,a*exp(-H(x))) is always a*exp(-H(x)).
soundness: 4
strengths: 1. The topic of the paper is interesting, transformer-based model do have the problem of slow decoding speed. 

2. It make a good balance between the speed and the performance.
summary: The authors propose a new decoding method, called CORAL, which can speed up the decoding process and maintain (or upraise) the performance of the model in some tasks. CORAL has 2 parts: prediction and verification. The experiment shows that the verification part can help the model to generate more accurate results. CORAL also designed a strategy named "multi-forward" to speed up the decoding process (although it may hurt the performance). The result shows that the CORAL is useful in math problems but is useless in the code generation task.
weaknesses: 1. The improvement of the CORAL is not generalizable enough. It only works well in the some math/logic problems but not in the code generation task.

2. Although the speed of the decoding process is improved, it needs to use more GPU memory (and "waste" some computation because of verification and multi-forward) to achieve this. So it is not friendly to equipment that most people use.

Meta-review: **Summary:** 

The paper introduces COrAL, a framework designed to integrate iterative refinement directly into LLMs while maintaining computational efficiency. COrAL addresses limitations of autoregressive models, such as high inference latency and sequential dependency, by modeling token dependencies within context windows in an order-agnostic manner. It combines forward multi-token prediction and backward reconstruction to enable efficient sliding block-wise decoding, achieving improvements in both accuracy and inference speed. 

**Strength:**
- COrAL’s order-agnostic framework enables simultaneous forward and backward processing.
- The method enhances dependency modeling with minimal computational overhead.
- The authors conduct extensive ablation studies, showcasing the robustness of their approach in balancing speed and performance.

**Weakness:**
- The paper lacks discussion and citations for related works.
- While the empirical results are robust, the paper could benefit from deeper theoretical discussions to provide insights beyond experimental observations.
- While COrAL excels in math and logic tasks, it struggles with code generation, limiting its general applicability.

Decision: Reject